test: use ERM to destroy sqlite database handles after tests

Signed-off-by: Renegade334 <contact.9a5d6388@renegade334.me.uk>
PR-URL: #63076
Refs: #63052
Reviewed-By: Chemi Atlow <chemi@atlow.co.il>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Edy Silva <edigleyssonsilva@gmail.com>

Author: Renegade334

test/parallel/test-sqlite-database-sync-dispose.js

@@ -89,19 +89,18 @@ suite('DatabaseSync() constructor', () => {
 
 test('is not read-only by default',(t)=>{
 constdbPath=nextDb();
-constdb=newDatabaseSync(dbPath);
+usingdb=newDatabaseSync(dbPath);
 db.exec('CREATE TABLE foo (id INTEGER PRIMARY KEY)');
 });
 
 test('is read-only if readOnly is set',(t)=>{
 constdbPath=nextDb();
 {
-constdb=newDatabaseSync(dbPath);
+usingdb=newDatabaseSync(dbPath);
 db.exec('CREATE TABLE foo (id INTEGER PRIMARY KEY)');
-db.close();
 }
 {
-constdb=newDatabaseSync(dbPath,{readOnly: true});
+usingdb=newDatabaseSync(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)=>{
 constdbPath=nextDb();
-constdb=newDatabaseSync(dbPath);
+usingdb=newDatabaseSync(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)=>{
 constdbPath=nextDb();
-constdb=newDatabaseSync(dbPath,{enableForeignKeyConstraints: false});
+usingdb=newDatabaseSync(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)=>{
 constdbPath=nextDb();
-constdb=newDatabaseSync(dbPath);
-t.after(()=>{db.close();});
+usingdb=newDatabaseSync(dbPath);
 t.assert.throws(()=>{
 db.exec('SELECT "foo";');
 },{
@@ -170,8 +166,7 @@ suite('DatabaseSync() constructor', () => {
 
 test('allows enabling double-quoted string literals',(t)=>{
 constdbPath=nextDb();
-constdb=newDatabaseSync(dbPath,{enableDoubleQuotedStringLiterals: true});
-t.after(()=>{db.close();});
+usingdb=newDatabaseSync(dbPath,{enableDoubleQuotedStringLiterals: true});
 db.exec('SELECT "foo";');
 });
 
@@ -186,8 +181,7 @@ suite('DatabaseSync() constructor', () => {
 
 test('allows reading big integers',(t)=>{
 constdbPath=nextDb();
-constdb=newDatabaseSync(dbPath,{readBigInts: true});
-t.after(()=>{db.close();});
+usingdb=newDatabaseSync(dbPath,{readBigInts: true});
 
 constsetup=db.exec(`
  CREATE TABLE data(key INTEGER PRIMARY KEY, val INTEGER) STRICT;
@@ -216,8 +210,7 @@ suite('DatabaseSync() constructor', () => {
 
 test('allows returning arrays',(t)=>{
 constdbPath=nextDb();
-constdb=newDatabaseSync(dbPath,{returnArrays: true});
-t.after(()=>{db.close();});
+usingdb=newDatabaseSync(dbPath,{returnArrays: true});
 constsetup=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)=>{
 constdbPath=nextDb();
-constdb=newDatabaseSync(dbPath,{allowBareNamedParameters: false});
-t.after(()=>{db.close();});
+usingdb=newDatabaseSync(dbPath,{allowBareNamedParameters: false});
 constsetup=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)=>{
 constdbPath=nextDb();
-constdb=newDatabaseSync(dbPath,{allowUnknownNamedParameters: true});
-t.after(()=>{db.close();});
+usingdb=newDatabaseSync(dbPath,{allowUnknownNamedParameters: true});
 constsetup=db.exec(
 'CREATE TABLE data(key INTEGER, val INTEGER) STRICT;'
 );
@@ -284,8 +275,7 @@ suite('DatabaseSync() constructor', () => {
 
 test('has sqlite-type symbol property',(t)=>{
 constdbPath=nextDb();
-constdb=newDatabaseSync(dbPath);
-t.after(()=>{db.close();});
+usingdb=newDatabaseSync(dbPath);
 
 constsqliteTypeSymbol=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)=>{
 constdbPath=nextDb();
-constdb=newDatabaseSync(dbPath,{open: false});
-t.after(()=>{db.close();});
+usingdb=newDatabaseSync(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)=>{
-constdb=newDatabaseSync(nextDb(),{open: false});
-t.after(()=>{db.close();});
+usingdb=newDatabaseSync(nextDb(),{open: false});
 
 t.assert.strictEqual(db.isOpen,false);
 db.open();
@@ -324,15 +312,15 @@ suite('DatabaseSync.prototype.open()', () => {
 
 suite('DatabaseSync.prototype.close()',()=>{
 test('closes an open database connection',(t)=>{
-constdb=newDatabaseSync(nextDb());
+usingdb=newDatabaseSync(nextDb());
 
 t.assert.strictEqual(db.isOpen,true);
 t.assert.strictEqual(db.close(),undefined);
 t.assert.strictEqual(db.isOpen,false);
 });
 
 test('throws if database is not open',(t)=>{
-constdb=newDatabaseSync(nextDb(),{open: false});
+usingdb=newDatabaseSync(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)=>{
-constdb=newDatabaseSync(nextDb());
-t.after(()=>{db.close();});
+usingdb=newDatabaseSync(nextDb());
 conststmt=db.prepare('CREATE TABLE webstorage(key TEXT)');
 t.assert.ok(stmtinstanceofStatementSync);
 });
 
 test('throws if database is not open',(t)=>{
-constdb=newDatabaseSync(nextDb(),{open: false});
+usingdb=newDatabaseSync(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)=>{
-constdb=newDatabaseSync(nextDb());
-t.after(()=>{db.close();});
+usingdb=newDatabaseSync(nextDb());
 
 t.assert.throws(()=>{
 db.prepare();
@@ -379,8 +365,7 @@ suite('DatabaseSync.prototype.prepare()', () => {
 
 suite('DatabaseSync.prototype.exec()',()=>{
 test('executes SQL',(t)=>{
-constdb=newDatabaseSync(nextDb());
-t.after(()=>{db.close();});
+usingdb=newDatabaseSync(nextDb());
 constresult=db.exec(`
  CREATE TABLE data(
  key INTEGER PRIMARY KEY,
@@ -398,8 +383,7 @@ suite('DatabaseSync.prototype.exec()', () => {
 });
 
 test('reports errors from SQLite',(t)=>{
-constdb=newDatabaseSync(nextDb());
-t.after(()=>{db.close();});
+usingdb=newDatabaseSync(nextDb());
 
 t.assert.throws(()=>{
 db.exec('CREATE TABLEEEE');
@@ -419,7 +403,7 @@ suite('DatabaseSync.prototype.exec()', () => {
 });
 
 test('throws if database is not open',(t)=>{
-constdb=newDatabaseSync(nextDb(),{open: false});
+usingdb=newDatabaseSync(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)=>{
-constdb=newDatabaseSync(nextDb());
-t.after(()=>{db.close();});
+usingdb=newDatabaseSync(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)=>{
-constdb=newDatabaseSync(':memory:');
+usingdb=newDatabaseSync(':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)=>{
-constdb=newDatabaseSync(':memory:');
+usingdb=newDatabaseSync(':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)=>{
-constdb=newDatabaseSync(nextDb(),{open: false});
+usingdb=newDatabaseSync(nextDb(),{open: false});
 
 t.assert.throws(()=>{
 returndb.isTransaction;
@@ -481,7 +464,7 @@ suite('DatabaseSync.prototype.isTransaction', () => {
 
 suite('DatabaseSync.prototype.location()',()=>{
 test('throws if database is not open',(t)=>{
-constdb=newDatabaseSync(nextDb(),{open: false});
+usingdb=newDatabaseSync(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)=>{
-constdb=newDatabaseSync(nextDb());
-t.after(()=>{db.close();});
+usingdb=newDatabaseSync(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)=>{
-constdb=newDatabaseSync(':memory:');
+usingdb=newDatabaseSync(':memory:');
 t.assert.strictEqual(db.location(),null);
 });
 
 test('returns db path when connected to a persistent database',(t)=>{
 constdbPath=nextDb();
-constdb=newDatabaseSync(dbPath);
-t.after(()=>{db.close();});
+usingdb=newDatabaseSync(dbPath);
 t.assert.strictEqual(db.location(),dbPath);
 });
 
 test('returns that specific db path when attached',(t)=>{
 constdbPath=nextDb();
 constotherPath=nextDb();
-constdb=newDatabaseSync(dbPath);
-t.after(()=>{db.close();});
-constother=newDatabaseSync(dbPath);
-t.after(()=>{other.close();});
+usingdb=newDatabaseSync(dbPath);
 
 // Adding this escape because the test with unusual chars have a single quote which breaks the query
 constescapedPath=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)=>{
+constdb=newDatabaseSync(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)=>{
+constdb=newDatabaseSync(nextDb(),{open: false});
+t.assert.strictEqual(db.isOpen,false);
+db[Symbol.dispose]();
+});
+});