Implement accretion.runMigrations() and wrappings of node-sqlite3

3 files changed, 203 insertions, 3 deletions

diff --git a/tests/js/accretion.mjs b/tests/js/accretion.mjs
new file mode 100644
index 0000000..3ea90c3
--- /dev/null
+++ b/tests/js/accretion.mjs
@@ -0,0 +1,35 @@
+import assert from "node:assert/strict";
+
+import sqlite from "../../src/sqlite.cjs";
+
+import { runTests }          from "../runner.mjs";
+import { promisifyDb, open } from "../../src/db.mjs";
+import { runMigrations }     from "../../src/accretion.mjs";
+
+
+const test_runMigrations = t => {
+	t.start("runMigrations()");
+
+	t.test("running twice is a noop", async () => {
+		const db = await open(":memory:");
+		const migrationsFn = () => db.all("SELECT filename FROM migrations;");
+
+		assert.rejects(
+			migrationsFn,
+			{ message: "SQLITE_ERROR: no such table: migrations" },
+		);
+
+		await runMigrations(db);
+		const filled = await migrationsFn();
+
+		await runMigrations(db);
+		const unchanged = await migrationsFn();
+
+		assert.deepEqual(filled, unchanged);
+	});
+};
+
+
+await runTests([
+	test_runMigrations,
+]);
diff --git a/tests/js/db.mjs b/tests/js/db.mjs
index e4a8a51..372f64a 100644
--- a/tests/js/db.mjs
+++ b/tests/js/db.mjs
@@ -1,15 +1,135 @@
+import assert from "node:assert/strict";
+
+import sqlite from "../../src/sqlite.cjs";
+
 import { runTests } from "../runner.mjs";
-import { init }     from "../../src/db.mjs";
+import { promisify, promisifyDb, open, db, init } from "../../src/db.mjs";
+
+
+const test_promisify = t => {
+	t.start("promisify()");
+
+	t.test("we wrap the callbacky function", async () => {
+		const okFn1  = (a, b, cb) =>
+			setTimeout(() => cb(null, { a, b, ok: true }));
+		const errFn1 = (a, b, c, cb) =>
+			setTimeout(() => cb({ err: true, a }, "ignored"));
+
+		const okFn2  = promisify(okFn1);
+		const errFn2 = promisify(errFn1);
+
+		assert.deepEqual(
+			await okFn2("a-value", "b-value"),
+			{
+				a: "a-value",
+				b: "b-value",
+				ok: true,
+			},
+		);
+
+		assert.rejects(
+			async () => await errFn2("aa", "bb", "cc"),
+			{
+				err: true,
+				a: "aa",
+			},
+		);
+	});
+};
+const test_promisifyDb = t => {
+	t.start("promisifyDb()");
+
+	const createTable = "CREATE TABLE table_ (column INTEGER NOT NULL PRIMARY KEY);";
+
+	t.test("we can access the underlying database and statement ref", async () => {
+		const db = await open(":memory:");
+		assert.ok(db.ref instanceof sqlite.Database);
+
+		const stmt = await db.prepare("SELECT 1;");
+		assert.ok(stmt.ref instanceof sqlite.Statement);
+	});
+
+	t.test("we can run the wrapped fns", async () => {
+		const db = await open(":memory:");
+
+		await db.exec(createTable);
 
+		const stmt = await db.prepare("INSERT INTO table_ (column) VALUES ($column)");
+		await stmt.run({ $column: 3 });
+		await stmt.run({ $column: 1 });
+		await stmt.finalize();
+		assert.rejects(
+			async () => await stmt.run({ $column: 2 }),
+			{
+				message: "SQLITE_MISUSE: Statement is already finalized",
+				code: "SQLITE_MISUSE",
+			},
+		);
+
+		const selectAll = "SELECT column FROM table_ ORDER BY column;";
+
+		const all = await db.all(selectAll);
+		assert.deepEqual(all, [{ column: 1 }, { column: 3 }]);
+
+		const contents = [];
+		const cb = row => contents.push(row);
+		await db.each(selectAll, cb);
+		assert.deepEqual(contents, [{ column: 1 }, { column: 3 }]);
+	});
+};
+
+const test_open = t => {
+	t.start("open()");
+
+	t.test("we must provide a name", () => {
+		assert.rejects(
+			async () => await open(),
+			assert.AssertionError,
+		);
+
+		assert.rejects(
+			async () => await open(undefined),
+			assert.AssertionError,
+		);
+
+		assert.rejects(
+			async () => await open(null),
+			assert.AssertionError,
+		);
+
+		assert.rejects(
+			async () => await open(""),
+			assert.AssertionError,
+		);
+	});
+
+	t.test("failure to open causes a promise rejection", () => {
+		assert.rejects(
+			async () => await open("tests/non/existing/directory/and/file"),
+			{
+				message: "SQLITE_CANTOPEN: unable to open database file",
+				code: "SQLITE_CANTOPEN",
+			},
+		);
+	});
+};
 
 const test_init = t => {
 	t.start("init()");
-	t.test("FIXME", () => {
-		// init();
+	t.test("we only know how to deal with 1 database", async () => {
+		await init();
+		const ref1 = db;
+		await init();
+		const ref2 = db;
+
+		assert.notDeepEqual(ref1, ref2);
 	});
 };
 
 
 await runTests([
+	test_promisify,
+	test_promisifyDb,
+	test_open,
 	test_init,
 ]);
diff --git a/tests/js/utils.mjs b/tests/js/utils.mjs
index 1875ce5..94e8eae 100644
--- a/tests/js/utils.mjs
+++ b/tests/js/utils.mjs
@@ -4,6 +4,7 @@ import { runTests } from "../runner.mjs";
 import {
 	eq,
 	keys,
+	difference,
 	assocIn,
 	getIn,
 	first,
@@ -126,6 +127,49 @@ const test_keys = t => {
 	});
 };
 
+const test_difference = t => {
+	t.start("difference()");
+
+	t.test("empty values", () => {
+		assert.deepEqual(
+			difference(new Set(), new Set()),
+			new Set(),
+		);
+
+		assert.deepEqual(
+			difference(new Set(), new Set([1, 2])),
+			new Set(),
+		);
+
+		assert.deepEqual(
+			difference(new Set([1, 2]), new Set()),
+			new Set([1, 2]),
+		);
+	});
+
+	t.test("different subsets", () => {
+		assert.deepEqual(
+			difference(new Set([1, 2]), new Set([3, 4])),
+			new Set([1, 2]),
+		);
+
+		assert.deepEqual(
+			difference(new Set([1, 2, 3]), new Set([2, 4, 5])),
+			new Set([1, 3]),
+		);
+
+		assert.deepEqual(
+			difference(new Set([1]), new Set([1, 2, 3, 4, 5])),
+			new Set(),
+		);
+
+		assert.deepEqual(
+			difference(new Set([1, 2, 3]), new Set([1, 2, 3])),
+			new Set(),
+		);
+	});
+};
+
 const test_assocIn = t => {
 	t.start("assocIn()");
 
@@ -218,6 +262,7 @@ const test_log = t => {
 await runTests([
 	test_eq,
 	test_keys,
+	test_difference,
 	test_assocIn,
 	test_getIn,
 	test_first,