better-sqlite3-multiple-ciphers 7.4.7-beta.0 → 7.5.1-beta.0

package/test/42.integrity.js

@@ -1,531 +0,0 @@
-'use strict';
-const fs = require('fs');
-const path = require('path');
-const Database = require('../.');
-
-describe('integrity checks', function () {
-	beforeEach(function () {
-		let func = () => {};
-		this.useFunc = fn => { func = fn; };
-		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();
-		this.db.function('func', x => (func(), x));
-		this.iterator = this.db.prepare("SELECT func(b) from entries ORDER BY rowid");
-		this.reader = this.db.prepare("SELECT func(b) from entries ORDER BY rowid");
-		this.writer = this.db.prepare("UPDATE entries SET c = c + 2.718")
-	});
-	afterEach(function () {
-		this.db.close();
-	});
-
-	const allowed = fn => () => expect(fn).to.not.throw();
-	const blocked = fn => () => expect(fn).to.throw(TypeError);
-	const normally = fn => fn();
-	const whileIterating = (self, fn) => {
-		let count = 0;
-		for (const _ of self.iterator.iterate()) { count += 1; fn(); }
-		expect(count).to.equal(5);
-	};
-	const whileBusy = (self, fn) => {
-		let count = 0;
-		self.useFunc(() => { count += 1; fn(); });
-		self.iterator.all();
-		expect(count).to.equal(5);
-	};
-	const whileClosed = (self, fn) => {
-		self.db.close();
-		fn();
-	};
-
-	describe('Database#prepare()', function () {
-		specify('while iterating (allowed)', function () {
-			whileIterating(this, allowed(() => this.db.prepare('SELECT 555')));
-			whileIterating(this, allowed(() => this.db.prepare('DELETE FROM entries')));
-			normally(allowed(() => this.db.prepare('SELECT 555')));
-			normally(allowed(() => this.db.prepare('DELETE FROM entries')));
-		});
-		specify('while busy (blocked)', function () {
-			whileBusy(this, blocked(() => this.db.prepare('SELECT 555')));
-			whileBusy(this, blocked(() => this.db.prepare('DELETE FROM entries')));
-			normally(allowed(() => this.db.prepare('SELECT 555')));
-			normally(allowed(() => this.db.prepare('DELETE FROM entries')));
-		});
-		specify('while closed (blocked)', function () {
-			whileClosed(this, blocked(() => this.db.prepare('SELECT 555')));
-			whileClosed(this, blocked(() => this.db.prepare('DELETE FROM entries')));
-		});
-	});
-
-	describe('Database#exec()', function () {
-		specify('while iterating (blocked)', function () {
-			whileIterating(this, blocked(() => this.db.exec('SELECT 555')));
-			whileIterating(this, blocked(() => this.db.exec('DELETE FROM entries')));
-			normally(allowed(() => this.db.exec('SELECT 555')));
-			normally(allowed(() => this.db.exec('DELETE FROM entries')));
-		});
-		specify('while busy (blocked)', function () {
-			whileBusy(this, blocked(() => this.db.exec('SELECT 555')));
-			whileBusy(this, blocked(() => this.db.exec('DELETE FROM entries')));
-			normally(allowed(() => this.db.exec('SELECT 555')));
-			normally(allowed(() => this.db.exec('DELETE FROM entries')));
-		});
-		specify('while closed (blocked)', function () {
-			whileClosed(this, blocked(() => this.db.exec('SELECT 555')));
-			whileClosed(this, blocked(() => this.db.exec('DELETE FROM entries')));
-		});
-	});
-
-	describe('Database#pragma()', function () {
-		specify('while iterating (blocked)', function () {
-			whileIterating(this, blocked(() => this.db.pragma('cache_size')));
-			normally(allowed(() => this.db.pragma('cache_size')));
-		});
-		specify('while busy (blocked)', function () {
-			whileBusy(this, blocked(() => this.db.pragma('cache_size')));
-			normally(allowed(() => this.db.pragma('cache_size')));
-		});
-		specify('while closed (blocked)', function () {
-			whileClosed(this, blocked(() => this.db.pragma('cache_size')));
-		});
-	});
-
-	describe('Database#pragma(\'wal_checkpoint(RESTART)\')', function () {
-		specify('while iterating (blocked)', function () {
-			whileIterating(this, blocked(() => this.db.pragma('wal_checkpoint(RESTART)')));
-			normally(allowed(() => this.db.pragma('wal_checkpoint(RESTART)')));
-		});
-		specify('while busy (blocked)', function () {
-			whileBusy(this, blocked(() => this.db.pragma('wal_checkpoint(RESTART)')));
-			normally(allowed(() => this.db.pragma('wal_checkpoint(RESTART)')));
-		});
-		specify('while closed (blocked)', function () {
-			whileClosed(this, blocked(() => this.db.pragma('wal_checkpoint(RESTART)')));
-		});
-	});
-
-	describe('Database#backup()', function () {
-		specify('while iterating (allowed)', async function () {
-			const promises = [];
-			whileIterating(this, allowed(() => promises.push(this.db.backup(util.next()))));
-			expect(promises.length).to.equal(5);
-			return Promise.all(promises);
-		});
-		specify('while busy (allowed)', async function () {
-			const promises = [];
-			whileBusy(this, allowed(() => promises.push(this.db.backup(util.next()))));
-			expect(promises.length).to.equal(5);
-			return Promise.all(promises);
-		});
-		specify('while closed (blocked)', async function () {
-			const promises = [];
-			whileClosed(this, allowed(() => promises.push(this.db.backup(util.next()))));
-			expect(promises.length).to.equal(1);
-			return Promise.all(promises.map(p =>
-				p.then(() => { throw new Error('Promise should have been rejected'); }, () => {})
-			));
-		});
-	});
-
-	describe('Database#function()', function () {
-		specify('while iterating (blocked)', function () {
-			let i = 0;
-			whileIterating(this, blocked(() => this.db.function(`fn_${++i}`, () => {})));
-			expect(i).to.equal(5);
-			normally(allowed(() => this.db.function(`fn_${++i}`, () => {})));
-		});
-		specify('while busy (blocked)', function () {
-			let i = 0;
-			whileBusy(this, blocked(() => this.db.function(`fn_${++i}`, () => {})));
-			expect(i).to.equal(5);
-			normally(allowed(() => this.db.function(`fn_${++i}`, () => {})));
-		});
-		specify('while closed (blocked)', function () {
-			let i = 0;
-			whileClosed(this, blocked(() => this.db.function(`fn_${++i}`, () => {})));
-			expect(i).to.equal(1);
-		});
-	});
-
-	describe('Database#aggregate()', function () {
-		specify('while iterating (blocked)', function () {
-			let i = 0;
-			whileIterating(this, blocked(() => this.db.aggregate(`agg_${++i}`, { step: () => {} })));
-			expect(i).to.equal(5);
-			normally(allowed(() => this.db.aggregate(`agg_${++i}`, { step: () => {} })));
-		});
-		specify('while busy (blocked)', function () {
-			let i = 0;
-			whileBusy(this, blocked(() => this.db.aggregate(`agg_${++i}`, { step: () => {} })));
-			expect(i).to.equal(5);
-			normally(allowed(() => this.db.aggregate(`agg_${++i}`, { step: () => {} })));
-		});
-		specify('while closed (blocked)', function () {
-			let i = 0;
-			whileClosed(this, blocked(() => this.db.aggregate(`agg_${++i}`, { step: () => {} })));
-			expect(i).to.equal(1);
-		});
-	});
-
-	describe('Database#table()', function () {
-		specify('while iterating (blocked)', function () {
-			let i = 0;
-			whileIterating(this, blocked(() => this.db.table(`tbl_${++i}`, { columns: ['x'], *rows() {} })));
-			expect(i).to.equal(5);
-			normally(allowed(() => this.db.table(`tbl_${++i}`, { columns: ['x'], *rows() {} })));
-		});
-		specify('while busy (blocked)', function () {
-			let i = 0;
-			whileBusy(this, blocked(() => this.db.table(`tbl_${++i}`, { columns: ['x'], *rows() {} })));
-			expect(i).to.equal(5);
-			normally(allowed(() => this.db.table(`tbl_${++i}`, { columns: ['x'], *rows() {} })));
-		});
-		specify('while closed (blocked)', function () {
-			let i = 0;
-			whileClosed(this, blocked(() => this.db.table(`tbl_${++i}`, { columns: ['x'], *rows() {} })));
-			expect(i).to.equal(1);
-		});
-	});
-
-	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;
-			}
-		});
-
-		specify('while iterating (blocked)', function () {
-			whileIterating(this, blocked(() => this.db.loadExtension(filepath)));
-			normally(allowed(() => this.db.loadExtension(filepath)));
-		});
-		specify('while busy (blocked)', function () {
-			whileBusy(this, blocked(() => this.db.loadExtension(filepath)));
-			normally(allowed(() => this.db.loadExtension(filepath)));
-		});
-		specify('while closed (blocked)', function () {
-			whileClosed(this, blocked(() => this.db.loadExtension(filepath)));
-		});
-	});
-
-	describe('Database#close()', function () {
-		specify('while iterating (blocked)', function () {
-			whileIterating(this, blocked(() => this.db.close()));
-			normally(allowed(() => this.db.close()));
-		});
-		specify('while busy (blocked)', function () {
-			whileBusy(this, blocked(() => this.db.close()));
-			normally(allowed(() => this.db.close()));
-		});
-		specify('while closed (allowed)', function () {
-			whileClosed(this, allowed(() => this.db.close()));
-		});
-	});
-
-	describe('Database#defaultSafeIntegers()', function () {
-		specify('while iterating (allowed)', function () {
-			let bool = true;
-			whileIterating(this, allowed(() => this.db.defaultSafeIntegers(bool = !bool)));
-		});
-		specify('while busy (allowed)', function () {
-			let bool = true;
-			whileBusy(this, allowed(() => this.db.defaultSafeIntegers(bool = !bool)));
-		});
-		specify('while closed (allowed)', function () {
-			let bool = true;
-			whileClosed(this, allowed(() => this.db.defaultSafeIntegers(bool = !bool)));
-		});
-	});
-
-	describe('Database#open', function () {
-		specify('while iterating (allowed)', function () {
-			whileIterating(this, allowed(() => expect(this.db.open).to.be.true));
-		});
-		specify('while busy (allowed)', function () {
-			whileBusy(this, allowed(() => expect(this.db.open).to.be.true));
-		});
-		specify('while closed (allowed)', function () {
-			whileClosed(this, allowed(() => expect(this.db.open).to.be.false));
-		});
-	});
-
-	describe('Database#inTransaction', function () {
-		specify('while iterating (allowed)', function () {
-			this.db.exec('BEGIN');
-			whileIterating(this, allowed(() => expect(this.db.inTransaction).to.be.true));
-		});
-		specify('while busy (allowed)', function () {
-			this.db.exec('BEGIN');
-			whileBusy(this, allowed(() => expect(this.db.inTransaction).to.be.true));
-		});
-		specify('while closed (allowed)', function () {
-			this.db.exec('BEGIN');
-			whileClosed(this, allowed(() => expect(this.db.inTransaction).to.be.false));
-		});
-	});
-
-	describe('Statement#run()', function () {
-		specify('while iterating (blocked)', function () {
-			whileIterating(this, blocked(() => this.writer.run()));
-			normally(allowed(() => this.writer.run()));
-		});
-		specify('while busy (blocked)', function () {
-			whileBusy(this, blocked(() => this.writer.run()));
-			normally(allowed(() => this.writer.run()));
-		});
-		specify('while closed (blocked)', function () {
-			whileClosed(this, blocked(() => this.writer.run()));
-		});
-	});
-
-	describe('Statement#get()', function () {
-		specify('while iterating (allowed)', function () {
-			whileIterating(this, allowed(() => this.reader.get()));
-			normally(allowed(() => this.reader.get()));
-		});
-		specify('while self-iterating (blocked)', function () {
-			whileIterating(this, blocked(() => this.iterator.get()));
-			normally(allowed(() => this.iterator.get()));
-		});
-		specify('while busy (blocked)', function () {
-			whileBusy(this, blocked(() => this.reader.get()));
-			normally(allowed(() => this.reader.get()));
-		});
-		specify('while closed (blocked)', function () {
-			whileClosed(this, blocked(() => this.reader.get()));
-		});
-	});
-
-	describe('Statement#all()', function () {
-		specify('while iterating (allowed)', function () {
-			whileIterating(this, allowed(() => this.reader.all()));
-			normally(allowed(() => this.reader.all()));
-		});
-		specify('while self-iterating (blocked)', function () {
-			whileIterating(this, blocked(() => this.iterator.all()));
-			normally(allowed(() => this.iterator.all()));
-		});
-		specify('while busy (blocked)', function () {
-			whileBusy(this, blocked(() => this.reader.all()));
-			normally(allowed(() => this.reader.all()));
-		});
-		specify('while closed (blocked)', function () {
-			whileClosed(this, blocked(() => this.reader.all()));
-		});
-	});
-
-	describe('Statement#iterate()', function () {
-		specify('while iterating (allowed)', function () {
-			whileIterating(this, allowed(() => Array.from(this.reader.iterate())));
-			normally(allowed(() => Array.from(this.reader.iterate())));
-		});
-		specify('while self-iterating (blocked)', function () {
-			whileIterating(this, blocked(() => Array.from(this.iterator.iterate())));
-			normally(allowed(() => Array.from(this.iterator.iterate())));
-		});
-		specify('while busy (blocked)', function () {
-			whileBusy(this, blocked(() => Array.from(this.reader.iterate())));
-			normally(allowed(() => Array.from(this.reader.iterate())));
-		});
-		specify('while closed (blocked)', function () {
-			whileClosed(this, blocked(() => Array.from(this.reader.iterate())));
-		});
-	});
-
-	describe('Statement#bind()', function () {
-		const bind = (stmt) => {
-			if (!stmt.__bound) {
-				stmt.bind();
-				stmt.__bound = true;
-			}
-		};
-		specify('while iterating (allowed)', function () {
-			whileIterating(this, allowed(() => bind(this.reader)));
-		});
-		specify('while self-iterating (blocked)', function () {
-			whileIterating(this, blocked(() => bind(this.iterator)));
-			normally(allowed(() => bind(this.iterator)));
-		});
-		specify('while busy (blocked)', function () {
-			whileBusy(this, blocked(() => bind(this.reader)));
-			normally(allowed(() => bind(this.reader)));
-		});
-		specify('while closed (blocked)', function () {
-			whileClosed(this, blocked(() => bind(this.reader)));
-		});
-	});
-
-	describe('Statement#pluck()', function () {
-		specify('while iterating (allowed)', function () {
-			whileIterating(this, allowed(() => this.reader.pluck()));
-			normally(allowed(() => this.reader.pluck()));
-		});
-		specify('while self-iterating (blocked)', function () {
-			whileIterating(this, blocked(() => this.iterator.pluck()));
-			normally(allowed(() => this.iterator.pluck()));
-		});
-		specify('while busy (blocked)', function () {
-			whileBusy(this, blocked(() => this.reader.pluck()));
-			normally(allowed(() => this.reader.pluck()));
-		});
-		specify('while closed (allowed)', function () {
-			whileClosed(this, allowed(() => this.reader.pluck()));
-		});
-	});
-
-	describe('Statement#expand()', function () {
-		specify('while iterating (allowed)', function () {
-			whileIterating(this, allowed(() => this.reader.expand()));
-			normally(allowed(() => this.reader.expand()));
-		});
-		specify('while self-iterating (blocked)', function () {
-			whileIterating(this, blocked(() => this.iterator.expand()));
-			normally(allowed(() => this.iterator.expand()));
-		});
-		specify('while busy (blocked)', function () {
-			whileBusy(this, blocked(() => this.reader.expand()));
-			normally(allowed(() => this.reader.expand()));
-		});
-		specify('while closed (allowed)', function () {
-			whileClosed(this, allowed(() => this.reader.expand()));
-		});
-	});
-
-	describe('Statement#raw()', function () {
-		specify('while iterating (allowed)', function () {
-			whileIterating(this, allowed(() => this.reader.raw()));
-			normally(allowed(() => this.reader.raw()));
-		});
-		specify('while self-iterating (blocked)', function () {
-			whileIterating(this, blocked(() => this.iterator.raw()));
-			normally(allowed(() => this.iterator.raw()));
-		});
-		specify('while busy (blocked)', function () {
-			whileBusy(this, blocked(() => this.reader.raw()));
-			normally(allowed(() => this.reader.raw()));
-		});
-		specify('while closed (allowed)', function () {
-			whileClosed(this, allowed(() => this.reader.raw()));
-		});
-	});
-
-	describe('Statement#safeIntegers()', function () {
-		specify('while iterating (allowed)', function () {
-			whileIterating(this, allowed(() => this.reader.safeIntegers()));
-			normally(allowed(() => this.reader.safeIntegers()));
-		});
-		specify('while self-iterating (blocked)', function () {
-			whileIterating(this, blocked(() => this.iterator.safeIntegers()));
-			normally(allowed(() => this.iterator.safeIntegers()));
-		});
-		specify('while busy (blocked)', function () {
-			whileBusy(this, blocked(() => this.reader.safeIntegers()));
-			normally(allowed(() => this.reader.safeIntegers()));
-		});
-		specify('while closed (allowed)', function () {
-			whileClosed(this, allowed(() => this.reader.safeIntegers()));
-		});
-	});
-
-	describe('Statement#columns()', function () {
-		specify('while iterating (allowed)', function () {
-			whileIterating(this, allowed(() => this.reader.columns()));
-			normally(allowed(() => this.reader.columns()));
-		});
-		specify('while self-iterating (allowed)', function () {
-			whileIterating(this, allowed(() => this.iterator.columns()));
-			normally(allowed(() => this.iterator.columns()));
-		});
-		specify('while busy (blocked)', function () {
-			whileBusy(this, blocked(() => this.reader.columns()));
-			normally(allowed(() => this.reader.columns()));
-		});
-		specify('while closed (blocked)', function () {
-			whileClosed(this, blocked(() => this.reader.columns()));
-		});
-	});
-
-	describe('StatementIterator#next()', function () {
-		specify('while iterating (allowed)', function () {
-			const iterator = this.reader.iterate();
-			try {
-				whileIterating(this, allowed(() => iterator.next()));
-				normally(allowed(() => iterator.next()));
-			} finally {
-				iterator.return();
-			}
-		});
-		specify('while self-iterating (allowed)', function () {
-			const iterator = this.iterator.iterate();
-			try {
-				let count = 0;
-				for (const _ of iterator) {
-					count += 1;
-					iterator.next();
-				}
-				expect(count).to.equal(3);
-			} finally {
-				iterator.return();
-			}
-		});
-		specify('while busy (blocked)', function () {
-			const iterator = this.reader.iterate();
-			try {
-				whileBusy(this, blocked(() => iterator.next()));
-				normally(allowed(() => iterator.next()));
-			} finally {
-				iterator.return();
-			}
-		});
-		specify('while closed (allowed)', function () {
-			const iterator = this.reader.iterate();
-			iterator.return();
-			whileClosed(this, allowed(() => iterator.next()));
-		});
-	});
-
-	describe('StatementIterator#return()', function () {
-		specify('while iterating (allowed)', function () {
-			const iterator = this.reader.iterate();
-			try {
-				whileIterating(this, allowed(() => iterator.return()));
-				normally(allowed(() => iterator.return()));
-			} finally {
-				iterator.return();
-			}
-		});
-		specify('while self-iterating (allowed)', function () {
-			const iterator = this.iterator.iterate();
-			try {
-				let count = 0;
-				for (const _ of iterator) {
-					count += 1;
-					iterator.return();
-				}
-				expect(count).to.equal(1);
-			} finally {
-				iterator.return();
-			}
-		});
-		specify('while busy (blocked)', function () {
-			const iterator = this.reader.iterate();
-			try {
-				whileBusy(this, blocked(() => iterator.return()));
-				normally(allowed(() => iterator.return()));
-			} finally {
-				iterator.return();
-			}
-		});
-		specify('while closed (allowed)', function () {
-			const iterator = this.reader.iterate();
-			iterator.return();
-			whileClosed(this, allowed(() => iterator.return()));
-		});
-	});
-});

package/test/43.verbose.js

@@ -1,100 +0,0 @@
-'use strict';
-const Database = require('../.');
-
-describe('verbose mode', function () {
-	afterEach(function () {
-		if (this.db) this.db.close();
-	});
-
-	it('should throw when not given a function or null/undefined', function () {
-		expect(() => (this.db = new Database(util.next(), { verbose: false }))).to.throw(TypeError);
-		expect(() => (this.db = new Database(util.next(), { verbose: true }))).to.throw(TypeError);
-		expect(() => (this.db = new Database(util.next(), { verbose: 123 }))).to.throw(TypeError);
-		expect(() => (this.db = new Database(util.next(), { verbose: 'null' }))).to.throw(TypeError);
-		expect(() => (this.db = new Database(util.next(), { verbose: {} }))).to.throw(TypeError);
-		expect(() => (this.db = new Database(util.next(), { verbose: [] }))).to.throw(TypeError);
-	});
-	it('should allow explicit null or undefined as a no-op', function () {
-		for (const verbose of [undefined, null]) {
-			const db = this.db = new Database(util.next(), { verbose });
-			db.exec('select 5');
-			db.close();
-		}
-	});
-	it('should invoke the given function with all executed SQL', function () {
-		let calls = [];
-		function verbose(...args) {
-			calls.push([this, ...args]);
-		}
-		const db = this.db = new Database(util.next(), { verbose });
-		const stmt = db.prepare('select ?');
-		db.exec('select 5');
-		db.prepare('create table data (x)').run();
-		stmt.get(BigInt(10));
-		stmt.all(BigInt(15));
-		stmt.iterate(BigInt(20)).return();
-		for (const x of stmt.iterate(BigInt(25))) {}
-		db.pragma('cache_size');
-		db.prepare("insert into data values ('hi')").run();
-		db.prepare("insert into data values ('bye')").run();
-		expect(Array.from(db.prepare('select x from data order by rowid').pluck().iterate()))
-			.to.deep.equal(['hi', 'bye']);
-		expect(calls).to.deep.equal([
-			[undefined, 'select 5'],
-			[undefined, 'create table data (x)'],
-			[undefined, 'select 10'],
-			[undefined, 'select 15'],
-			[undefined, 'select 25'],
-			[undefined, 'PRAGMA cache_size'],
-			[undefined, "insert into data values ('hi')"],
-			[undefined, "insert into data values ('bye')"],
-			[undefined, 'select x from data order by rowid'],
-		]);
-	});
-	it('should not fully expand very long bound parameter', function () {
-		let calls = [];
-		function verbose(...args) {
-			calls.push([this, ...args]);
-		}
-		const db = this.db = new Database(util.next(), { verbose });
-		const stmt = db.prepare('select ?');
-		stmt.get('this is a fairly short parameter');
-		stmt.get('this is a slightly longer parameter');
-		stmt.get('this is surely a very long bound parameter value that doesnt need to be logged in its entirety');
-		expect(calls).to.deep.equal([
-			[undefined, "select 'this is a fairly short parameter'"],
-			[undefined, "select 'this is a slightly longer parame'/*+3 bytes*/"],
-			[undefined, "select 'this is surely a very long bound'/*+62 bytes*/"],
-		]);
-	});
-	it('should abort the execution if the logger function throws', function () {
-		let fail = false;
-		let failures = 0;
-		const err = new Error('foo');
-		const db = this.db = new Database(util.next(), { verbose: () => { if (fail) throw err; } });
-		db.prepare('create table data (x)').run();
-		db.function('fn', (value) => {
-			if (fail) failures += 1;
-			return value;
-		});
-		const shouldThrow = (fn) => {
-			expect(fn).to.not.throw();
-			expect(fn).to.not.throw();
-			fail = true;
-			try {
-				expect(fn).to.throw(err);
-			} finally {
-				fail = false;
-			}
-			expect(fn).to.not.throw();
-			expect(failures).to.equal(0);
-		};
-		const use = (stmt, fn) => () => fn(stmt);
-		shouldThrow(() => db.exec('select fn(5)'));
-		shouldThrow(use(db.prepare('insert into data values (fn(5))'), stmt => stmt.run()));
-		shouldThrow(use(db.prepare('insert into data values (fn(?))'), stmt => stmt.run(5)));
-		shouldThrow(use(db.prepare('select fn(?)'), stmt => stmt.get(5)));
-		shouldThrow(use(db.prepare('select fn(?)'), stmt => stmt.all(5)));
-		shouldThrow(use(db.prepare('select fn(?)'), stmt => Array.from(stmt.iterate(5))));
-	});
-});

package/test/44.worker-threads.js

@@ -1,66 +0,0 @@
-'use strict';
-if (parseInt(process.versions.node) >= 12) {
-	const threads = require('worker_threads');
-	const Database = require('../.');
-
-	if (threads.isMainThread) {
-		describe('Worker Threads', function () {
-			afterEach(function () {
-				if (this.db) this.db.close();
-				return this.cleanup;
-			});
-			it('are properly supported', function () {
-				this.slow(1000);
-				return new Promise((resolve, reject) => {
-					const db = this.db = Database(util.next()).defaultSafeIntegers();
-					expect(db.prepare('select 555').constructor.foo).to.be.undefined;
-					db.prepare('select 555').constructor.foo = 5;
-					expect(db.prepare('select 555').constructor.foo).to.equal(5);
-					const worker = new threads.Worker(__filename);
-					worker.on('exit', code => reject(new Error(`worker exited with code ${code}`)));
-					worker.on('error', reject);
-					worker.on('message', ({ msg, info, data }) => {
-						try {
-							if (msg === 'hello') {
-								db.exec('create table data (a, b)');
-								worker.postMessage({ msg: 'hello', filename: util.current() });
-							} else if (msg === 'success') {
-								const checkedData = db.prepare("select * from data").all();
-								expect(info.changes).to.equal(checkedData.length);
-								expect(data).to.not.equal(checkedData);
-								expect(data).to.deep.equal(checkedData);
-								expect(db.prepare('select 555').constructor.foo).to.equal(5);
-								resolve();
-								this.cleanup = worker.terminate();
-							} else {
-								throw new Error('unexpected message from worker');
-							}
-						} catch (err) {
-							reject(err);
-							this.cleanup = worker.terminate();
-						}
-					});
-				});
-			});
-		});
-	} else {
-		const { expect } = require('chai');
-		threads.parentPort.on('message', ({ msg, filename }) => {
-			if (msg === 'hello') {
-				const db = Database(filename).defaultSafeIntegers();
-				expect(db.prepare('select 555').constructor.foo).to.be.undefined;
-				db.prepare('select 555').constructor.foo = 27;
-				expect(db.prepare('select 555').constructor.foo).to.equal(27);
-				const info = db.prepare("insert into data values (1, 2), ('foo', 5.5)").run();
-				const data = db.prepare("select * from data").all();
-				expect(info.changes).to.be.a('number');
-				expect(info.lastInsertRowid).to.be.a('bigint');
-				expect(data.length).to.equal(2);
-				threads.parentPort.postMessage({ msg: 'success', info, data });
-			} else {
-				throw new Error('unexpected message from main thread');
-			}
-		});
-		threads.parentPort.postMessage({ msg: 'hello' });
-	}
-}