better-sqlite3-multiple-ciphers 7.4.7-beta.1 → 7.5.0-beta.0

package/test/35.database.load-extension.js

@@ -1,75 +0,0 @@
-'use strict';
-const fs = require('fs');
-const path = require('path');
-const Database = require('../.');
-
-describe('Database#loadExtension()', function () {
-	let filepath;
-	before(function () {
-		const releaseFilepath = path.join(__dirname, '..', 'build', 'Release', 'test_extension.node');
-		const debugFilepath = path.join(__dirname, '..', 'build', 'Debug', 'test_extension.node');
-		try {
-			fs.accessSync(releaseFilepath);
-			filepath = releaseFilepath;
-		} catch (_) {
-			fs.accessSync(debugFilepath);
-			filepath = debugFilepath;
-		}
-	});
-	beforeEach(function () {
-		this.db = new Database(util.next());
-	});
-	afterEach(function () {
-		this.db.close();
-	});
-
-	it('should throw an exception if a string argument is not given', function () {
-		expect(() => this.db.loadExtension()).to.throw(TypeError);
-		expect(() => this.db.loadExtension(undefined)).to.throw(TypeError);
-		expect(() => this.db.loadExtension(null)).to.throw(TypeError);
-		expect(() => this.db.loadExtension(123)).to.throw(TypeError);
-		expect(() => this.db.loadExtension(new String(filepath))).to.throw(TypeError);
-		expect(() => this.db.loadExtension([filepath])).to.throw(TypeError);
-	});
-	it('should throw an exception if the database is busy', function () {
-		let invoked = false;
-		for (const value of this.db.prepare('select 555').pluck().iterate()) {
-			expect(value).to.equal(555);
-			expect(() => this.db.loadExtension(filepath)).to.throw(TypeError);
-			invoked = true;
-		}
-		expect(invoked).to.be.true;
-	});
-	it('should throw an exception if the extension is not found', function () {
-		try {
-			this.db.loadExtension(filepath + 'x');
-		} catch (err) {
-			expect(err).to.be.an.instanceof(Database.SqliteError);
-			expect(err.message).to.be.a('string');
-			expect(err.message.length).to.be.above(0);
-			expect(err.message).to.not.equal('not an error');
-			expect(err.code).to.equal('SQLITE_ERROR');
-			return;
-		}
-		throw new Error('This code should not have been reached');
-	});
-	it('should register the specified extension', function () {
-		expect(this.db.loadExtension(filepath)).to.equal(this.db);
-		expect(this.db.prepare('SELECT testExtensionFunction(NULL, 123, 99, 2)').pluck().get()).to.equal(4);
-		expect(this.db.prepare('SELECT testExtensionFunction(NULL, 2)').pluck().get()).to.equal(2);
-	});
-	it('should not allow registering extensions with SQL', function () {
-		expect(() => this.db.prepare('SELECT load_extension(?)').get(filepath)).to.throw(Database.SqliteError);
-		expect(this.db.loadExtension(filepath)).to.equal(this.db);
-		expect(() => this.db.prepare('SELECT load_extension(?)').get(filepath)).to.throw(Database.SqliteError);
-		this.db.close();
-		this.db = new Database(util.next());
-		try {
-			this.db.loadExtension(filepath + 'x');
-		} catch (err) {
-			expect(() => this.db.prepare('SELECT load_extension(?)').get(filepath)).to.throw(Database.SqliteError);
-			return;
-		}
-		throw new Error('This code should not have been reached');
-	});
-});

package/test/36.database.backup.js

@@ -1,240 +0,0 @@
-'use strict';
-const { existsSync, writeFileSync, readFileSync } = require('fs');
-const Database = require('../.');
-
-describe('Database#backup()', function () {
-	beforeEach(function () {
-		this.db = new Database(util.next());
-		this.db.prepare("CREATE TABLE entries (a TEXT, b INTEGER, c REAL, d BLOB, e TEXT)").run();
-		this.db.prepare("INSERT INTO entries WITH RECURSIVE temp(a, b, c, d, e) AS (SELECT 'foo', 1, 3.14, x'dddddddd', NULL UNION ALL SELECT a, b + 1, c, d, e FROM temp LIMIT 5) SELECT * FROM temp").run();
-	});
-	afterEach(function () {
-		this.db.close();
-	});
-
-	const fulfillsWith = (value, p) => p.then(v => void expect(v).to.deep.equal(value));
-	const rejectsWith = (type, p) => {
-		const shouldReject = () => { throw new Error('Promise should have been rejected') };
-		const reasonIs = (reason) => { if (!(reason instanceof type)) throw reason; }
-		return p.then(shouldReject, reasonIs);
-	};
-
-	it('should be rejected when destination is not a string', async function () {
-		await rejectsWith(TypeError, this.db.backup());
-		await rejectsWith(TypeError, this.db.backup(null));
-		await rejectsWith(TypeError, this.db.backup(0));
-		await rejectsWith(TypeError, this.db.backup(123));
-		await rejectsWith(TypeError, this.db.backup(new String(util.next())));
-		await rejectsWith(TypeError, this.db.backup(() => util.next()));
-		await rejectsWith(TypeError, this.db.backup([util.next()]));
-	});
-	it('should not allow an empty destination string', async function () {
-		await rejectsWith(TypeError, this.db.backup(''));
-		await rejectsWith(TypeError, this.db.backup(' \t\n '));
-	});
-	it('should not allow a :memory: destination', async function () {
-		await rejectsWith(TypeError, this.db.backup(':memory:'));
-		expect(existsSync(':memory:')).to.be.false;
-	});
-	it('should backup the database and fulfill the returned promise', async function () {
-		expect(existsSync(this.db.name)).to.be.true;
-		expect(existsSync(util.next())).to.be.false;
-		const promise = this.db.backup(util.current());
-		expect(existsSync(util.current())).to.be.false;
-		await fulfillsWith({ totalPages: 2, remainingPages: 0 }, promise);
-		expect(existsSync(this.db.name)).to.be.true;
-		expect(existsSync(util.current())).to.be.true;
-		const rows = this.db.prepare('SELECT * FROM entries').all();
-		this.db.close();
-		this.db = new Database(util.current());
-		expect(this.db.prepare('SELECT * FROM entries').all()).to.deep.equal(rows);
-	});
-	it('should be rejected if the directory does not exist', async function () {
-		expect(existsSync(util.next())).to.be.false;
-		const filepath = `temp/nonexistent/abcfoobar123/${util.current()}`;
-		await rejectsWith(TypeError, this.db.backup(filepath));
-		expect(existsSync(filepath)).to.be.false;
-		expect(existsSync(util.current())).to.be.false;
-	});
-	it('should be rejected if a database cannot be opened at the destination', async function () {
-		writeFileSync(util.next(), 'not a database file');
-		await rejectsWith(Database.SqliteError, this.db.backup(util.current()));
-		expect(readFileSync(util.current(), 'utf8')).to.equal('not a database file');
-	});
-	it('should accept the "attached" option', async function () {
-		const source = this.db.name;
-		const destination = util.next();
-		let promise;
-		this.db.close();
-		this.db = new Database(':memory:');
-		this.db.prepare('ATTACH ? AS cool_db').run(source);
-		expect(existsSync(source)).to.be.true;
-		expect(existsSync(destination)).to.be.false;
-		await fulfillsWith({ totalPages: 2, remainingPages: 0 },
-			this.db.backup(destination, { attached: 'cool_db' }));
-		expect(existsSync(source)).to.be.true;
-		expect(existsSync(destination)).to.be.true;
-		const rows = this.db.prepare('SELECT * FROM cool_db.entries').all();
-		this.db.close();
-		this.db = new Database(destination);
-		expect(this.db.prepare('SELECT * FROM main.entries').all()).to.deep.equal(rows);
-	});
-	it('should accept the "progress" option', async function () {
-		expect(existsSync(this.db.name)).to.be.true;
-		expect(existsSync(util.next())).to.be.false;
-		const calls = [];
-		const promise = this.db.backup(util.current(), { progress(...args) {
-			calls.push([this, ...args]);
-		} });
-		expect(existsSync(util.current())).to.be.false;
-		await fulfillsWith({ totalPages: 2, remainingPages: 0 }, promise);
-		expect(existsSync(this.db.name)).to.be.true;
-		expect(existsSync(util.current())).to.be.true;
-		const rows = this.db.prepare('SELECT * FROM entries').all();
-		this.db.close();
-		this.db = new Database(util.current());
-		expect(this.db.prepare('SELECT * FROM entries').all()).to.deep.equal(rows);
-		expect(calls).to.deep.equal([[undefined, { totalPages: 2, remainingPages: 2 }]]);
-	});
-	it('should allow control over transfer sizes via the progress callback', async function () {
-		let transferSize = 0;
-		const expected = [];
-		const actual = [];
-		const promise = this.db.backup(util.next(), { progress(state) {
-			actual.push(state);
-			return transferSize;
-		} });
-		promise.catch(() => {});
-		expect(actual).to.deep.equal(expected);
-		while (!actual.length) await new Promise(setImmediate);
-		expected.push({ totalPages: 2, remainingPages: 2 });
-		expect(actual).to.deep.equal(expected);
-		await new Promise(setImmediate);
-		transferSize = 1;
-		await new Promise(setImmediate);
-		expected.push({ totalPages: 2, remainingPages: 2 });
-		expected.push({ totalPages: 2, remainingPages: 2 });
-		expect(actual).to.deep.equal(expected);
-		await new Promise(setImmediate);
-		expected.push({ totalPages: 2, remainingPages: 1 });
-		expect(actual).to.deep.equal(expected);
-		const payload = Buffer.alloc(4096 * 5).fill(0x7a).toString();
-		this.db.prepare('INSERT INTO entries (a, b) VALUES (?, 999)').run(payload);
-		transferSize = Infinity;
-		await new Promise(setImmediate);
-		expected.push({ totalPages: 7, remainingPages: 5 });
-		expect(actual).to.deep.equal(expected);
-		await new Promise(setImmediate);
-		expect(actual).to.deep.equal(expected);
-		await fulfillsWith({ totalPages: 7, remainingPages: 0 }, promise);
-		this.db.close();
-		this.db = new Database(util.current());
-		expect(this.db.prepare('SELECT a FROM entries WHERE b = 999').pluck().get()).to.deep.equal(payload);
-	});
-	it('should be aborted if an error is thrown inside the progress callback', async function () {
-		const promise = this.db.backup(util.next(), { progress: () => { throw new SyntaxError('foo'); } });
-		await rejectsWith(SyntaxError, promise);
-	});
-	it('should be aborted if the progress callback returns a non-number', async function () {
-		const backup = x => this.db.backup(util.next(), { progress: () => x });
-		await rejectsWith(TypeError, backup(null));
-		await rejectsWith(TypeError, backup(new Number(1)));
-		await rejectsWith(TypeError, backup(() => 1));
-		await rejectsWith(TypeError, backup([1]));
-		await rejectsWith(TypeError, backup('1'));
-	});
-	it('should rollback an aborted backup file if it was not newly created', async function () {
-		const otherDb = new Database(util.next());
-		try {
-			otherDb.prepare('CREATE TABLE foo (bar)').run()
-			otherDb.prepare('INSERT INTO foo VALUES (2), (8)').run();
-		} finally {
-			otherDb.close();
-		}
-		let error;
-		let transferSize = 0;
-		const expected = [];
-		const actual = [];
-		const promise = this.db.backup(util.current(), { progress(state) {
-			actual.push(state);
-			if (error) throw error;
-			return transferSize;
-		} });
-		promise.catch(() => {});
-		expect(actual).to.deep.equal(expected);
-		while (!actual.length) await new Promise(setImmediate);
-		expected.push({ totalPages: 2, remainingPages: 2 });
-		expect(actual).to.deep.equal(expected);
-		transferSize = 1;
-		await new Promise(setImmediate);
-		expected.push({ totalPages: 2, remainingPages: 2 });
-		expect(actual).to.deep.equal(expected);
-		transferSize = 0;
-		await new Promise(setImmediate);
-		expected.push({ totalPages: 2, remainingPages: 1 });
-		expect(actual).to.deep.equal(expected);
-		error = new SyntaxError('foo');
-		await new Promise(setImmediate);
-		expected.push({ totalPages: 2, remainingPages: 1 });
-		expect(actual).to.deep.equal(expected);
-		await rejectsWith(SyntaxError, promise);
-		expect(actual).to.deep.equal(expected);
-		expect(existsSync(util.current())).to.be.true;
-		this.db.close();
-		this.db = new Database(util.current());
-		expect(this.db.prepare('SELECT bar FROM foo').pluck().all()).to.deep.equal([2, 8]);
-	});
-	it('should delete an aborted backup file if it was newly created', async function () {
-		let error;
-		let transferSize = 0;
-		const expected = [];
-		const actual = [];
-		const promise = this.db.backup(util.next(), { progress(state) {
-			actual.push(state);
-			if (error) throw error;
-			return transferSize;
-		} });
-		promise.catch(() => {});
-		expect(actual).to.deep.equal(expected);
-		while (!actual.length) await new Promise(setImmediate);
-		expected.push({ totalPages: 2, remainingPages: 2 });
-		expect(actual).to.deep.equal(expected);
-		transferSize = 1;
-		await new Promise(setImmediate);
-		expected.push({ totalPages: 2, remainingPages: 2 });
-		expect(actual).to.deep.equal(expected);
-		transferSize = 0;
-		await new Promise(setImmediate);
-		expected.push({ totalPages: 2, remainingPages: 1 });
-		expect(actual).to.deep.equal(expected);
-		error = new SyntaxError('foo');
-		await new Promise(setImmediate);
-		expected.push({ totalPages: 2, remainingPages: 1 });
-		expect(actual).to.deep.equal(expected);
-		await rejectsWith(SyntaxError, promise);
-		expect(actual).to.deep.equal(expected);
-		expect(existsSync(util.current())).to.be.false;
-	});
-	it('should be aborted if the connection is closed during a backup', async function () {
-		let transferSize = 0;
-		const calls = [];
-		const promise = this.db.backup(util.next(), { progress(state) {
-			calls.push(state);
-			return transferSize;
-		} });
-		promise.catch(() => {});
-		while (!calls.length) await new Promise(setImmediate);
-		transferSize = 1;
-		await new Promise(setImmediate);
-		await new Promise(setImmediate);
-		this.db.close();
-		expect(this.db.open).to.be.false;
-		await rejectsWith(TypeError, promise);
-		expect(calls).to.deep.equal([
-			{ totalPages: 2, remainingPages: 2 },
-			{ totalPages: 2, remainingPages: 2 },
-			{ totalPages: 2, remainingPages: 1 },
-		]);
-		expect(existsSync(util.current())).to.be.false;
-	});
-});

package/test/37.database.serialize.js

@@ -1,81 +0,0 @@
-'use strict';
-const Database = require('../.');
-
-describe('Database#serialize()', function () {
-	beforeEach(function () {
-		this.db = new Database(util.next());
-		this.db.prepare("CREATE TABLE entries (a TEXT, b INTEGER, c REAL, d BLOB, e TEXT)").run();
-		this.seed = () => {
-			this.db.prepare("INSERT INTO entries WITH RECURSIVE temp(a, b, c, d, e) AS (SELECT 'foo', 1, 3.14, x'dddddddd', NULL UNION ALL SELECT a, b + 1, c, d, e FROM temp LIMIT 1000) SELECT * FROM temp").run();
-		};
-	});
-	afterEach(function () {
-		this.db.close();
-	});
-
-	it('should serialize the database and return a buffer', async function () {
-		let buffer = this.db.serialize();
-		expect(buffer).to.be.an.instanceof(Buffer);
-		expect(buffer.length).to.be.above(1000);
-		const lengthBefore = buffer.length;
-		this.seed();
-		buffer = this.db.serialize();
-		expect(buffer).to.be.an.instanceof(Buffer);
-		expect(buffer.length).to.be.above(lengthBefore);
-	});
-	it('should return a buffer that can be used by the Database constructor', async function () {
-		this.seed();
-		const buffer = this.db.serialize();
-		expect(buffer).to.be.an.instanceof(Buffer);
-		expect(buffer.length).to.be.above(1000);
-		this.db.prepare('delete from entries').run();
-		this.db.close();
-		this.db = new Database(buffer);
-		const bufferCopy = this.db.serialize();
-		expect(buffer.length).to.equal(bufferCopy.length);
-		expect(buffer).to.deep.equal(bufferCopy);
-		this.db.prepare('insert into entries (rowid, a, b) values (?, ?, ?)').run(0, 'bar', -999);
-		expect(this.db.prepare('select a, b from entries order by rowid limit 2').all())
-			.to.deep.equal([{ a: 'bar', b: -999 }, { a: 'foo', b: 1 }]);
-	});
-	it('should accept the "attached" option', async function () {
-		const smallBuffer = this.db.serialize();
-		this.seed();
-		const bigBuffer = this.db.serialize();
-		this.db.close();
-		this.db = new Database();
-		this.db.prepare('attach ? as other').run(util.current());
-		const smallBuffer2 = this.db.serialize();
-		const bigBuffer2 = this.db.serialize({ attached: 'other' });
-		expect(bigBuffer.length === bigBuffer2.length);
-		expect(bigBuffer).to.deep.equal(bigBuffer2);
-		expect(smallBuffer.length < bigBuffer.length);
-		expect(smallBuffer2.length < bigBuffer.length);
-		expect(smallBuffer).to.not.deep.equal(smallBuffer2);
-	});
-	it('should return a buffer that can be opened with the "readonly" option', async function () {
-		this.seed();
-		const buffer = this.db.serialize();
-		expect(buffer).to.be.an.instanceof(Buffer);
-		expect(buffer.length).to.be.above(1000);
-		this.db.close();
-		this.db = new Database(buffer, { readonly: true });
-		expect(() => this.db.prepare('insert into entries (rowid, a, b) values (?, ?, ?)').run(0, 'bar', -999))
-			.to.throw(Database.SqliteError);
-		expect(this.db.prepare('select a, b from entries order by rowid limit 2').all())
-			.to.deep.equal([{ a: 'foo', b: 1 }, { a: 'foo', b: 2 }]);
-		const bufferCopy = this.db.serialize();
-		expect(buffer.length).to.equal(bufferCopy.length);
-		expect(buffer).to.deep.equal(bufferCopy);
-	});
-	it('should work with an empty database', async function () {
-		this.db.close();
-		this.db = new Database();
-		const buffer = this.db.serialize();
-		expect(buffer).to.be.an.instanceof(Buffer);
-		expect(buffer.length).to.equal(0);
-		this.db.close();
-		this.db = new Database(buffer);
-		expect(this.db.serialize().length).to.equal(0);
-	});
-});

package/test/40.bigints.js

@@ -1,145 +0,0 @@
-'use strict';
-const Database = require('../.');
-
-describe('BigInts', function () {
-	beforeEach(function () {
-		this.db = new Database(util.next());
-		this.db.prepare('CREATE TABLE entries (a INTEGER, b REAL, c TEXT)').run();
-	});
-	afterEach(function () {
-		this.db.close();
-	});
-
-	it('should bind to prepared statements', function () {
-		const int = BigInt('1006028374637854687');
-		this.db.prepare('INSERT INTO entries VALUES (?, ?, ?)').run(int, int, int);
-		this.db.prepare('INSERT INTO entries VALUES (?, ?, ?)').bind(int, int, int).run();
-
-		const db2 = new Database(util.next());
-		try {
-			db2.prepare('CREATE TABLE entries (a INTEGER, b REAL, c TEXT)').run();
-			db2.prepare('INSERT INTO entries VALUES (?, ?, ?)').run(int, int, int);
-			db2.prepare('INSERT INTO entries VALUES (?, ?, ?)').bind(int, int, int).run();
-		} finally {
-			db2.close();
-		}
-	});
-	it('should be allowed as a return value in user-defined functions', function () {
-		this.db.function('returnsInteger', a => BigInt(a + a));
-		expect(this.db.prepare('SELECT returnsInteger(?)').pluck().get(42)).to.equal(84);
-	});
-	it('should get returned by operations after setting .safeIntegers()', function () {
-		const int = BigInt('1006028374637854687');
-		this.db.prepare('INSERT INTO entries VALUES (?, ?, ?)').run(int, int, int);
-		this.db.prepare('INSERT INTO entries VALUES (?, ?, ?)').run(int, int, int);
-
-		let stmt = this.db.prepare('SELECT a FROM entries').pluck();
-		expect(stmt.get()).to.equal(1006028374637854700);
-		expect(stmt.safeIntegers().get()).to.deep.equal(int);
-		expect(stmt.get()).to.deep.equal(int);
-		expect(stmt.safeIntegers(false).get()).to.equal(1006028374637854700);
-		expect(stmt.get()).to.equal(1006028374637854700);
-		expect(stmt.safeIntegers(true).get()).to.deep.equal(int);
-		expect(stmt.get()).to.deep.equal(int);
-
-		stmt = this.db.prepare('SELECT b FROM entries').pluck();
-		expect(stmt.get()).to.equal(1006028374637854700);
-		expect(stmt.safeIntegers().get()).to.equal(1006028374637854700);
-
-		stmt = this.db.prepare('SELECT c FROM entries').pluck();
-		expect(stmt.get()).to.equal('1006028374637854687');
-		expect(stmt.safeIntegers().get()).to.equal('1006028374637854687');
-
-		let lastRowid = this.db.prepare('SELECT rowid FROM entries ORDER BY rowid DESC').pluck().get();
-		stmt = this.db.prepare('INSERT INTO entries VALUES (?, ?, ?)');
-		expect(stmt.run(int, int, int).lastInsertRowid).to.equal(++lastRowid);
-		expect(stmt.safeIntegers().run(int, int, int).lastInsertRowid).to.deep.equal(BigInt(++lastRowid));
-		expect(stmt.run(int, int, int).lastInsertRowid).to.deep.equal(BigInt(++lastRowid));
-		expect(stmt.safeIntegers(false).run(int, int, int).lastInsertRowid).to.equal(++lastRowid);
-	});
-	it('should get passed to functions defined with the "safeIntegers" option', function () {
-		this.db.function('customfunc', { safeIntegers: true }, (a) => { return (typeof a) + a; });
-		expect(this.db.prepare('SELECT customfunc(?)').pluck().get(2)).to.equal('number2');
-		expect(this.db.prepare('SELECT customfunc(?)').pluck().get(BigInt(2))).to.equal('bigint2');
-	});
-	it('should get passed to aggregates defined with the "safeIntegers" option', function () {
-		this.db.aggregate('customagg', { safeIntegers: true, step: (_, a) => { return (typeof a) + a; } });
-		expect(this.db.prepare('SELECT customagg(?)').pluck().get(2)).to.equal('number2');
-		expect(this.db.prepare('SELECT customagg(?)').pluck().get(BigInt(2))).to.equal('bigint2');
-	});
-	it('should get passed to virtual tables defined with the "safeIntegers" option', function () {
-		this.db.table('customvtab', { safeIntegers: true, columns: ['x'], *rows(a) { yield [(typeof a) + a]; } });
-		expect(this.db.prepare('SELECT * FROM customvtab(?)').pluck().get(2)).to.equal('number2');
-		expect(this.db.prepare('SELECT * FROM customvtab(?)').pluck().get(BigInt(2))).to.equal('bigint2');
-	});
-	it('should respect the default setting on the database', function () {
-		let arg;
-		const int = BigInt('1006028374637854687');
-		const customFunctionArg = (name, options, dontDefine) => {
-			dontDefine || this.db.function(name, options, (a) => { arg = a; });
-			this.db.prepare(`SELECT ${name}(?)`).get(int);
-			return arg;
-		};
-		const customAggregateArg = (name, options, dontDefine) => {
-			dontDefine || this.db.aggregate(name, { ...options, step: (_, a) => { arg = a; } });
-			this.db.prepare(`SELECT ${name}(?)`).get(int);
-			return arg;
-		};
-		const customTableArg = (name, options, dontDefine) => {
-			dontDefine || this.db.table(name, { ...options, columns: ['x'], *rows(a) { arg = a; } });
-			this.db.prepare(`SELECT * FROM ${name}(?)`).get(int);
-			return arg;
-		};
-		this.db.prepare('INSERT INTO entries VALUES (?, ?, ?)').run(int, int, int);
-		this.db.defaultSafeIntegers(true);
-
-		const stmt = this.db.prepare('SELECT a FROM entries').pluck();
-		expect(stmt.get()).to.deep.equal(int);
-		expect(stmt.safeIntegers(false).get()).to.equal(1006028374637854700);
-		expect(customFunctionArg('a1')).to.deep.equal(int);
-		expect(customFunctionArg('a2', { safeIntegers: false })).to.equal(1006028374637854700);
-		expect(customAggregateArg('a1')).to.deep.equal(int);
-		expect(customAggregateArg('a2', { safeIntegers: false })).to.equal(1006028374637854700);
-		expect(customTableArg('a1')).to.deep.equal(int);
-		expect(customTableArg('a2', { safeIntegers: false })).to.equal(1006028374637854700);
-
-		this.db.defaultSafeIntegers(false);
-
-		const stmt2 = this.db.prepare('SELECT a FROM entries').pluck();
-		expect(stmt2.get()).to.equal(1006028374637854700);
-		expect(stmt2.safeIntegers().get()).to.deep.equal(int);
-		expect(customFunctionArg('a3')).to.equal(1006028374637854700);
-		expect(customFunctionArg('a4', { safeIntegers: true })).to.deep.equal(int);
-		expect(customAggregateArg('a3')).to.equal(1006028374637854700);
-		expect(customAggregateArg('a4', { safeIntegers: true })).to.deep.equal(int);
-		expect(customTableArg('a3')).to.equal(1006028374637854700);
-		expect(customTableArg('a4', { safeIntegers: true })).to.deep.equal(int);
-
-		this.db.defaultSafeIntegers();
-
-		expect(stmt.get()).to.equal(1006028374637854700);
-		expect(stmt2.get()).to.deep.equal(int);
-		expect(customFunctionArg('a1', {}, true)).to.deep.equal(int);
-		expect(customFunctionArg('a2', {}, true)).to.equal(1006028374637854700);
-		expect(customFunctionArg('a3', {}, true)).to.equal(1006028374637854700);
-		expect(customFunctionArg('a4', {}, true)).to.deep.equal(int);
-		expect(customAggregateArg('a1', {}, true)).to.deep.equal(int);
-		expect(customAggregateArg('a2', {}, true)).to.equal(1006028374637854700);
-		expect(customAggregateArg('a3', {}, true)).to.equal(1006028374637854700);
-		expect(customAggregateArg('a4', {}, true)).to.deep.equal(int);
-		expect(customTableArg('a1', {}, true)).to.deep.equal(int);
-		expect(customTableArg('a2', {}, true)).to.equal(1006028374637854700);
-		expect(customTableArg('a3', {}, true)).to.equal(1006028374637854700);
-		expect(customTableArg('a4', {}, true)).to.deep.equal(int);
-
-		const stmt3 = this.db.prepare('SELECT a FROM entries').pluck();
-		expect(stmt3.get()).to.deep.equal(int);
-		expect(stmt3.safeIntegers(false).get()).to.equal(1006028374637854700);
-		expect(customFunctionArg('a5')).to.deep.equal(int);
-		expect(customFunctionArg('a6', { safeIntegers: false })).to.equal(1006028374637854700);
-		expect(customAggregateArg('a5')).to.deep.equal(int);
-		expect(customAggregateArg('a6', { safeIntegers: false })).to.equal(1006028374637854700);
-		expect(customTableArg('a5')).to.deep.equal(int);
-		expect(customTableArg('a6', { safeIntegers: false })).to.equal(1006028374637854700);
-	});
-});

package/test/41.at-exit.js

@@ -1,52 +0,0 @@
-'use strict';
-const { existsSync, writeFileSync } = require('fs');
-const { fork } = require('child_process');
-
-describe('node::AtExit()', function () {
-	this.slow(500);
-
-	const source = (filename1, filename2) => `
-		'use strict';
-		const Database = require('../.');
-		const db1 = new Database('${filename1.replace(/(?=\W)/g, '\\')}');
-		const db2 = new Database('${filename2.replace(/(?=\W)/g, '\\')}');
-		for (const db of [db1, db2]) {
-			db.pragma('journal_mode = WAL');
-			db.prepare('CREATE TABLE people (name TEXT)').run();
-			db.prepare('INSERT INTO people VALUES (\\'foobar\\')').run();
-		}
-		const interval = setInterval(() => {}, 60000);
-		const messageHandler = (message) => {
-			if (message !== 'bar') return;
-			clearInterval(interval);
-			process.removeListener('message', messageHandler);
-		};
-		process.on('message', messageHandler);
-		process.send('foo');
-	`;
-
-	it('should close all databases when the process exits gracefully', async function () {
-		const filename1 = util.next();
-		const filename2 = util.next();
-		const jsFile = filename1 + '.js';
-		writeFileSync(jsFile, source(filename1, filename2));
-		await new Promise((resolve, reject) => {
-			const child = fork(jsFile);
-			child.on('error', reject);
-			child.on('close', () => reject(new Error('Child process was closed prematurely')));
-			child.on('message', (message) => {
-				if (message !== 'foo') return;
-				expect(existsSync(filename1)).to.be.true;
-				expect(existsSync(filename1 + '-wal')).to.be.true;
-				expect(existsSync(filename2)).to.be.true;
-				expect(existsSync(filename2 + '-wal')).to.be.true;
-				child.on('exit', resolve);
-				child.send('bar');
-			});
-		});
-		expect(existsSync(filename1)).to.be.true;
-		expect(existsSync(filename1 + '-wal')).to.be.false;
-		expect(existsSync(filename2)).to.be.true;
-		expect(existsSync(filename2 + '-wal')).to.be.false;
-	});
-});