add db resolve regression coverage

Author: BlobMaster41

package.json

@@ -80,7 +80,7 @@
     "prepublishOnly": "node scripts/build",
     "watch": "node scripts/build --watch",
     "coverage": "npx c8 -- npm test",
-    "test": "npm run test:parser && npm run test:compiler -- --parallel && npm run test:browser && npm run test:toilconfig && npm run test:transform && npm run test:cli && npm run test:json && npm run test:data && npm run test:dbstatic",
+    "test": "npm run test:parser && npm run test:compiler -- --parallel && npm run test:browser && npm run test:toilconfig && npm run test:transform && npm run test:cli && npm run test:json && npm run test:data && npm run test:dbresolve && npm run test:dbstatic && npm run test:streams",
     "test:parser": "node --enable-source-maps tests/parser",
     "test:compiler": "node --enable-source-maps --no-warnings tests/compiler",
     "test:browser": "node --enable-source-maps tests/browser",
@@ -91,7 +91,9 @@
     "test:cli": "node tests/cli/options.js",
     "test:json": "node tests/json/run.mjs",
     "test:data": "node tests/data/run.mjs",
+    "test:dbresolve": "node tests/dbresolve/run.mjs",
     "test:dbstatic": "node tests/dbstatic/run.mjs",
+    "test:streams": "node tests/streams/run.mjs && node tests/streams/catalog.mjs && node tests/streams/codegen.mjs",
     "asbuild": "npm run asbuild:debug && npm run asbuild:release",
     "asbuild:debug": "node bin/toilscript --config src/toilconfig.json --target debug",
     "asbuild:release": "node bin/toilscript --config src/toilconfig.json --target release",

std/assembly/toildb.ts

@@ -21,7 +21,8 @@ import { DataWriter } from "data";
 export function __toildbResolve(name: string): u32 {
   const nb = Uint8Array.wrap(String.UTF8.encode(name));
   const out = new Uint8Array(4);
-  toildbHost.resolveCollection(nb.dataStart, nb.byteLength, out.dataStart);
+  const status = toildbHost.resolveCollection(nb.dataStart, nb.byteLength, out.dataStart);
+  if (status < 0) abort("ToilDB collection resolve failed", "toildb", 0, 0);
   return load<u32>(out.dataStart);
 }
 

tests/dbmigrate/run.mjs

@@ -9,7 +9,7 @@
 //      (nothing imports them) and the weave INJECTS the cross-file imports into
 //      the value type's module. So each spec here is a value-type `app.ts` plus a
 //      separate `migrations/*.migration.ts`, compiled in an isolated dir.
-import { readFileSync, mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { readFileSync, mkdtempSync, mkdirSync, writeFileSync, rmSync, openSync, closeSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -35,17 +35,30 @@ function build(files, { expectFail = false } = {}) {
         writeFileSync(fp, files[rel]);
     }
     const out = join(tmp, "out.wasm");
-    const r = spawnSync("node", [bin, "app.ts", "-o", out, "--runtime", "stub"], {
+    const log = join(tmp, "compile.log");
+    let logFd = -1;
+    const stdio = expectFail
+        ? (logFd = openSync(log, "w"), ["ignore", logFd, logFd])
+        : ["ignore", "ignore", "inherit"];
+    const r = spawnSync("node", ["--enable-source-maps", bin, "app.ts", "-o", out, "--runtime", "stub"], {
         cwd: tmp,
-        stdio: ["ignore", "ignore", expectFail ? "pipe" : "inherit"],
+        stdio,
     });
+    if (logFd >= 0) closeSync(logFd);
+    const output = expectFail ? readFileSync(log, "utf8") : "";
     let buf = null;
     if (!expectFail) {
         if (r.status !== 0) { rmSync(tmp, { recursive: true, force: true }); fail("COMPILE FAILED"); }
         buf = readFileSync(out);
     }
     rmSync(tmp, { recursive: true, force: true });
-    return { status: r.status, stderr: String(r.stderr || ""), buf };
+    return {
+        status: r.status,
+        stderr: output,
+        error: r.error,
+        signal: r.signal,
+        buf,
+    };
 }
 
 // The value-type module shared by the migrating specs: current `User` (exported so
@@ -180,11 +193,11 @@ export class UserId { id: u64 = 0; }
 @data
 export class User { id: u64 = 0; }
 @database
-class App { @collection users: Documents<UserId, User>; }
+export class App { @collection users: Documents<UserId, User>; }
 export function probe(): u64 { return App.users.require(new UserId()).id; }
 `,
     "migrations/User.migration.ts": `
-import { User, UserId } from "../app";
+import { App, User, UserId } from "../app";
 @data
 export class UserV1 { id: u32 = 0; }
 @migrate
@@ -197,7 +210,7 @@ export function up(old: UserV1): User {
 }, { expectFail: true });
 if (bad.status === 0) fail("a @migrate that touches the database must be a compile error");
 if (!bad.stderr.includes("migrate"))
-    fail(`expected a @migrate diagnostic, got: ${bad.stderr.slice(0, 200)}`);
+    fail(`expected a @migrate diagnostic, got: status=${bad.status} signal=${bad.signal} error=${bad.error ?? ""} output=${bad.stderr.slice(0, 200)}`);
 
 // --- (d2) a @migrate OUTSIDE a migrations/*.migration.ts file must NOT compile ---
 const misplaced = build({

tests/dbresolve/run.mjs

@@ -0,0 +1,95 @@
+// Compile a tiny ToilDB program and instantiate it against a host that rejects
+// collection resolution. The generated binding must trap immediately instead of
+// reading the zeroed output buffer as handle 0 and calling request-time DB ops.
+import { mkdtempSync, writeFileSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawnSync } from "node:child_process";
+
+const here = dirname(fileURLToPath(import.meta.url));
+const root = join(here, "..", "..");
+const tmp = mkdtempSync(join(tmpdir(), "dbresolve-"));
+const app = join(tmp, "app.ts");
+const out = join(tmp, "out.wasm");
+
+function fail(msg) {
+    console.error(`ToilDB resolve test suite: ${msg}`);
+    rmSync(tmp, { recursive: true, force: true });
+    process.exit(1);
+}
+
+writeFileSync(app, `
+@data
+class Key {
+  id: string = "";
+  constructor(id: string = "") { this.id = id; }
+}
+
+@data
+class User {
+  name: string = "";
+}
+
+@database
+class App {
+  @collection static users: Documents<Key, User>;
+}
+
+export function probe(): i32 {
+  return App.users.exists(new Key("alice")) ? 1 : 0;
+}
+`);
+
+const compile = spawnSync(
+    "node",
+    [join(root, "bin", "toilscript.js"), app, "-o", out, "--runtime", "stub"],
+    { stdio: "inherit" },
+);
+if (compile.status !== 0) fail("COMPILE FAILED");
+
+let memory = null;
+let existsCalls = 0;
+function readString(ptr) {
+    if (!ptr || !memory) return "";
+    const u32 = new Uint32Array(memory.buffer);
+    const len = u32[(ptr - 4) >>> 2];
+    const u16 = new Uint16Array(memory.buffer, ptr, len >>> 1);
+    return String.fromCharCode.apply(null, u16);
+}
+
+const imports = {
+    env: {
+        abort(msgPtr, filePtr, line, col) {
+            const msg = readString(msgPtr);
+            const file = readString(filePtr);
+            throw new Error(`abort ${file}:${line}:${col}${msg ? " (" + msg + ")" : ""}`);
+        },
+        "data.resolve_collection"() {
+            return -1007;
+        },
+        "data.exists"(handle) {
+            existsCalls++;
+            if (handle === 0) throw new Error("BUG: request-time DB op used handle 0");
+            return 0;
+        },
+    },
+};
+
+try {
+    const { instance } = await WebAssembly.instantiate(readFileSync(out), imports);
+    memory = instance.exports.memory;
+    instance.exports.probe();
+    fail("probe unexpectedly returned after resolve_collection failed");
+} catch (e) {
+    const msg = String(e && e.message ? e.message : e);
+    if (!msg.includes("ToilDB collection resolve failed")) {
+        fail(`expected resolve failure abort, got: ${msg}`);
+    }
+    if (existsCalls !== 0) {
+        fail(`request-time DB op was called ${existsCalls} time(s) after failed resolve`);
+    }
+}
+
+rmSync(tmp, { recursive: true, force: true });
+console.log("ToilDB resolve test suite: ALL PASS");