diff --git a/test/parallel/test-sqlite-database-sync-dispose.js b/test/parallel/test-sqlite-database-sync-dispose.js
deleted file mode 100644
index 67a1ab6757b848..00000000000000
--- a/test/parallel/test-sqlite-database-sync-dispose.js
+++ /dev/null
@@ -1,33 +0,0 @@
-'use strict';
-const { skipIfSQLiteMissing } = require('../common');
-skipIfSQLiteMissing();
-const tmpdir = require('../common/tmpdir');
-const assert = require('node:assert');
-const { join } = require('node:path');
-const { DatabaseSync } = require('node:sqlite');
-const { suite, test } = require('node:test');
-let cnt = 0;
-
-tmpdir.refresh();
-
-function nextDb() {
-  return join(tmpdir.path, `database-${cnt++}.db`);
-}
-
-suite('DatabaseSync.prototype[Symbol.dispose]()', () => {
-  test('closes an open database', () => {
-    const db = new DatabaseSync(nextDb());
-    db[Symbol.dispose]();
-    assert.throws(() => {
-      db.close();
-    }, /database is not open/);
-  });
-
-  test('supports databases that are not open', () => {
-    const db = new DatabaseSync(nextDb(), { open: false });
-    db[Symbol.dispose]();
-    assert.throws(() => {
-      db.close();
-    }, /database is not open/);
-  });
-});
diff --git a/test/parallel/test-sqlite-database-sync.js b/test/parallel/test-sqlite-database-sync.js
index d778f839098737..ac3a3c66d6469a 100644
--- a/test/parallel/test-sqlite-database-sync.js
+++ b/test/parallel/test-sqlite-database-sync.js
@@ -89,19 +89,18 @@ suite('DatabaseSync() constructor', () => {
 
   test('is not read-only by default', (t) => {
     const dbPath = nextDb();
-    const db = new DatabaseSync(dbPath);
+    using db = new DatabaseSync(dbPath);
     db.exec('CREATE TABLE foo (id INTEGER PRIMARY KEY)');
   });
 
   test('is read-only if readOnly is set', (t) => {
     const dbPath = nextDb();
     {
-      const db = new DatabaseSync(dbPath);
+      using db = new DatabaseSync(dbPath);
       db.exec('CREATE TABLE foo (id INTEGER PRIMARY KEY)');
-      db.close();
     }
     {
-      const db = new DatabaseSync(dbPath, { readOnly: true });
+      using db = new DatabaseSync(dbPath, { readOnly: true });
       t.assert.throws(() => {
         db.exec('CREATE TABLE bar (id INTEGER PRIMARY KEY)');
       }, {
@@ -122,12 +121,11 @@ suite('DatabaseSync() constructor', () => {
 
   test('enables foreign key constraints by default', (t) => {
     const dbPath = nextDb();
-    const db = new DatabaseSync(dbPath);
+    using db = new DatabaseSync(dbPath);
     db.exec(`
       CREATE TABLE foo (id INTEGER PRIMARY KEY);
       CREATE TABLE bar (foo_id INTEGER REFERENCES foo(id));
     `);
-    t.after(() => { db.close(); });
     t.assert.throws(() => {
       db.exec('INSERT INTO bar (foo_id) VALUES (1)');
     }, {
@@ -138,12 +136,11 @@ suite('DatabaseSync() constructor', () => {
 
   test('allows disabling foreign key constraints', (t) => {
     const dbPath = nextDb();
-    const db = new DatabaseSync(dbPath, { enableForeignKeyConstraints: false });
+    using db = new DatabaseSync(dbPath, { enableForeignKeyConstraints: false });
     db.exec(`
       CREATE TABLE foo (id INTEGER PRIMARY KEY);
       CREATE TABLE bar (foo_id INTEGER REFERENCES foo(id));
     `);
-    t.after(() => { db.close(); });
     db.exec('INSERT INTO bar (foo_id) VALUES (1)');
   });
 
@@ -158,8 +155,7 @@ suite('DatabaseSync() constructor', () => {
 
   test('disables double-quoted string literals by default', (t) => {
     const dbPath = nextDb();
-    const db = new DatabaseSync(dbPath);
-    t.after(() => { db.close(); });
+    using db = new DatabaseSync(dbPath);
     t.assert.throws(() => {
       db.exec('SELECT "foo";');
     }, {
@@ -170,8 +166,7 @@ suite('DatabaseSync() constructor', () => {
 
   test('allows enabling double-quoted string literals', (t) => {
     const dbPath = nextDb();
-    const db = new DatabaseSync(dbPath, { enableDoubleQuotedStringLiterals: true });
-    t.after(() => { db.close(); });
+    using db = new DatabaseSync(dbPath, { enableDoubleQuotedStringLiterals: true });
     db.exec('SELECT "foo";');
   });
 
@@ -186,8 +181,7 @@ suite('DatabaseSync() constructor', () => {
 
   test('allows reading big integers', (t) => {
     const dbPath = nextDb();
-    const db = new DatabaseSync(dbPath, { readBigInts: true });
-    t.after(() => { db.close(); });
+    using db = new DatabaseSync(dbPath, { readBigInts: true });
 
     const setup = db.exec(`
       CREATE TABLE data(key INTEGER PRIMARY KEY, val INTEGER) STRICT;
@@ -216,8 +210,7 @@ suite('DatabaseSync() constructor', () => {
 
   test('allows returning arrays', (t) => {
     const dbPath = nextDb();
-    const db = new DatabaseSync(dbPath, { returnArrays: true });
-    t.after(() => { db.close(); });
+    using db = new DatabaseSync(dbPath, { returnArrays: true });
     const setup = db.exec(`
       CREATE TABLE data(key INTEGER PRIMARY KEY, val TEXT) STRICT;
       INSERT INTO data (key, val) VALUES (1, 'one');
@@ -240,8 +233,7 @@ suite('DatabaseSync() constructor', () => {
 
   test('throws if bare named parameters are used when option is false', (t) => {
     const dbPath = nextDb();
-    const db = new DatabaseSync(dbPath, { allowBareNamedParameters: false });
-    t.after(() => { db.close(); });
+    using db = new DatabaseSync(dbPath, { allowBareNamedParameters: false });
     const setup = db.exec(
       'CREATE TABLE data(key INTEGER PRIMARY KEY, val INTEGER) STRICT;'
     );
@@ -267,8 +259,7 @@ suite('DatabaseSync() constructor', () => {
 
   test('allows unknown named parameters', (t) => {
     const dbPath = nextDb();
-    const db = new DatabaseSync(dbPath, { allowUnknownNamedParameters: true });
-    t.after(() => { db.close(); });
+    using db = new DatabaseSync(dbPath, { allowUnknownNamedParameters: true });
     const setup = db.exec(
       'CREATE TABLE data(key INTEGER, val INTEGER) STRICT;'
     );
@@ -284,8 +275,7 @@ suite('DatabaseSync() constructor', () => {
 
   test('has sqlite-type symbol property', (t) => {
     const dbPath = nextDb();
-    const db = new DatabaseSync(dbPath);
-    t.after(() => { db.close(); });
+    using db = new DatabaseSync(dbPath);
 
     const sqliteTypeSymbol = Symbol.for('sqlite-type');
     t.assert.strictEqual(db[sqliteTypeSymbol], 'node:sqlite');
@@ -295,8 +285,7 @@ suite('DatabaseSync() constructor', () => {
 suite('DatabaseSync.prototype.open()', () => {
   test('opens a database connection', (t) => {
     const dbPath = nextDb();
-    const db = new DatabaseSync(dbPath, { open: false });
-    t.after(() => { db.close(); });
+    using db = new DatabaseSync(dbPath, { open: false });
 
     t.assert.strictEqual(db.isOpen, false);
     t.assert.strictEqual(existsSync(dbPath), false);
@@ -306,8 +295,7 @@ suite('DatabaseSync.prototype.open()', () => {
   });
 
   test('throws if database is already open', (t) => {
-    const db = new DatabaseSync(nextDb(), { open: false });
-    t.after(() => { db.close(); });
+    using db = new DatabaseSync(nextDb(), { open: false });
 
     t.assert.strictEqual(db.isOpen, false);
     db.open();
@@ -324,7 +312,7 @@ suite('DatabaseSync.prototype.open()', () => {
 
 suite('DatabaseSync.prototype.close()', () => {
   test('closes an open database connection', (t) => {
-    const db = new DatabaseSync(nextDb());
+    using db = new DatabaseSync(nextDb());
 
     t.assert.strictEqual(db.isOpen, true);
     t.assert.strictEqual(db.close(), undefined);
@@ -332,7 +320,7 @@ suite('DatabaseSync.prototype.close()', () => {
   });
 
   test('throws if database is not open', (t) => {
-    const db = new DatabaseSync(nextDb(), { open: false });
+    using db = new DatabaseSync(nextDb(), { open: false });
 
     t.assert.strictEqual(db.isOpen, false);
     t.assert.throws(() => {
@@ -347,14 +335,13 @@ suite('DatabaseSync.prototype.close()', () => {
 
 suite('DatabaseSync.prototype.prepare()', () => {
   test('returns a prepared statement', (t) => {
-    const db = new DatabaseSync(nextDb());
-    t.after(() => { db.close(); });
+    using db = new DatabaseSync(nextDb());
     const stmt = db.prepare('CREATE TABLE webstorage(key TEXT)');
     t.assert.ok(stmt instanceof StatementSync);
   });
 
   test('throws if database is not open', (t) => {
-    const db = new DatabaseSync(nextDb(), { open: false });
+    using db = new DatabaseSync(nextDb(), { open: false });
 
     t.assert.throws(() => {
       db.prepare();
@@ -365,8 +352,7 @@ suite('DatabaseSync.prototype.prepare()', () => {
   });
 
   test('throws if sql is not a string', (t) => {
-    const db = new DatabaseSync(nextDb());
-    t.after(() => { db.close(); });
+    using db = new DatabaseSync(nextDb());
 
     t.assert.throws(() => {
       db.prepare();
@@ -379,8 +365,7 @@ suite('DatabaseSync.prototype.prepare()', () => {
 
 suite('DatabaseSync.prototype.exec()', () => {
   test('executes SQL', (t) => {
-    const db = new DatabaseSync(nextDb());
-    t.after(() => { db.close(); });
+    using db = new DatabaseSync(nextDb());
     const result = db.exec(`
       CREATE TABLE data(
         key INTEGER PRIMARY KEY,
@@ -398,8 +383,7 @@ suite('DatabaseSync.prototype.exec()', () => {
   });
 
   test('reports errors from SQLite', (t) => {
-    const db = new DatabaseSync(nextDb());
-    t.after(() => { db.close(); });
+    using db = new DatabaseSync(nextDb());
 
     t.assert.throws(() => {
       db.exec('CREATE TABLEEEE');
@@ -419,7 +403,7 @@ suite('DatabaseSync.prototype.exec()', () => {
   });
 
   test('throws if database is not open', (t) => {
-    const db = new DatabaseSync(nextDb(), { open: false });
+    using db = new DatabaseSync(nextDb(), { open: false });
 
     t.assert.throws(() => {
       db.exec();
@@ -430,8 +414,7 @@ suite('DatabaseSync.prototype.exec()', () => {
   });
 
   test('throws if sql is not a string', (t) => {
-    const db = new DatabaseSync(nextDb());
-    t.after(() => { db.close(); });
+    using db = new DatabaseSync(nextDb());
 
     t.assert.throws(() => {
       db.exec();
@@ -444,7 +427,7 @@ suite('DatabaseSync.prototype.exec()', () => {
 
 suite('DatabaseSync.prototype.isTransaction', () => {
   test('correctly detects a committed transaction', (t) => {
-    const db = new DatabaseSync(':memory:');
+    using db = new DatabaseSync(':memory:');
 
     t.assert.strictEqual(db.isTransaction, false);
     db.exec('BEGIN');
@@ -456,7 +439,7 @@ suite('DatabaseSync.prototype.isTransaction', () => {
   });
 
   test('correctly detects a rolled back transaction', (t) => {
-    const db = new DatabaseSync(':memory:');
+    using db = new DatabaseSync(':memory:');
 
     t.assert.strictEqual(db.isTransaction, false);
     db.exec('BEGIN');
@@ -468,7 +451,7 @@ suite('DatabaseSync.prototype.isTransaction', () => {
   });
 
   test('throws if database is not open', (t) => {
-    const db = new DatabaseSync(nextDb(), { open: false });
+    using db = new DatabaseSync(nextDb(), { open: false });
 
     t.assert.throws(() => {
       return db.isTransaction;
@@ -481,7 +464,7 @@ suite('DatabaseSync.prototype.isTransaction', () => {
 
 suite('DatabaseSync.prototype.location()', () => {
   test('throws if database is not open', (t) => {
-    const db = new DatabaseSync(nextDb(), { open: false });
+    using db = new DatabaseSync(nextDb(), { open: false });
 
     t.assert.throws(() => {
       db.location();
@@ -492,8 +475,7 @@ suite('DatabaseSync.prototype.location()', () => {
   });
 
   test('throws if provided dbName is not string', (t) => {
-    const db = new DatabaseSync(nextDb());
-    t.after(() => { db.close(); });
+    using db = new DatabaseSync(nextDb());
 
     t.assert.throws(() => {
       db.location(null);
@@ -504,24 +486,20 @@ suite('DatabaseSync.prototype.location()', () => {
   });
 
   test('returns null when connected to in-memory database', (t) => {
-    const db = new DatabaseSync(':memory:');
+    using db = new DatabaseSync(':memory:');
     t.assert.strictEqual(db.location(), null);
   });
 
   test('returns db path when connected to a persistent database', (t) => {
     const dbPath = nextDb();
-    const db = new DatabaseSync(dbPath);
-    t.after(() => { db.close(); });
+    using db = new DatabaseSync(dbPath);
     t.assert.strictEqual(db.location(), dbPath);
   });
 
   test('returns that specific db path when attached', (t) => {
     const dbPath = nextDb();
     const otherPath = nextDb();
-    const db = new DatabaseSync(dbPath);
-    t.after(() => { db.close(); });
-    const other = new DatabaseSync(dbPath);
-    t.after(() => { other.close(); });
+    using db = new DatabaseSync(dbPath);
 
     // Adding this escape because the test with unusual chars have a single quote which breaks the query
     const escapedPath = otherPath.replace("'", "''");
@@ -530,3 +508,18 @@ suite('DatabaseSync.prototype.location()', () => {
     t.assert.strictEqual(db.location('other'), otherPath);
   });
 });
+
+suite('DatabaseSync.prototype[Symbol.dispose]', () => {
+  test('closes an open database', (t) => {
+    const db = new DatabaseSync(nextDb());
+    t.assert.strictEqual(db.isOpen, true);
+    db[Symbol.dispose]();
+    t.assert.strictEqual(db.isOpen, false);
+  });
+
+  test('does not throw on databases that are not open', (t) => {
+    const db = new DatabaseSync(nextDb(), { open: false });
+    t.assert.strictEqual(db.isOpen, false);
+    db[Symbol.dispose]();
+  });
+});