as-test 1.4.1 → 1.5.1

package/lib/src/index.ts

@@ -247,7 +247,11 @@ async function instantiateRawInstance(
   if (typeof helper.instantiate != "function") {
     throw new Error("bindings helper missing instantiate export");
   }
-  const mergedImports = mergeImports(withNodeIo({}), imports);
+  const mergedImports = stubMissingImports(
+    module,
+    mergeImports(withNodeIo({}), imports),
+    ["wasi_snapshot_preview1"],
+  );
   const instance = await captureHelperInstance(async () => {
     await helper.instantiate!(module, mergedImports);
   });
@@ -268,6 +272,10 @@ async function instantiateEsmInstance(
       "esm bindings do not support custom imports in as-test/lib; pass {} or switch to raw bindings",
     );
   }
+  // The esm helper auto-instantiates at import time and writes the WIPC report
+  // by calling the global process.stdout.write with an ArrayBuffer. Patch node
+  // IO before importing so that write (and stdin.read) accept the raw buffer.
+  patchNodeIo();
   const instance = await captureHelperInstance(async () => {
     await import(`${pathToFileURL(helperPath).href}?t=${Date.now()}`);
   });
@@ -347,6 +355,8 @@ async function instantiateWebInstance(
     let ready = false;
     let wsSocket: Duplex | null = null;
     let wsBuffer = Buffer.alloc(0);
+    let wsFragmentOpcode = 0;
+    let wsFragments: Buffer[] = [];
     let stdinBuffer = Buffer.alloc(0);
     let browserProcess: ChildProcess | null = null;
     let browserStderr = "";
@@ -488,15 +498,33 @@ async function instantiateWebInstance(
           payload = Buffer.from(payload);
         }
         wsBuffer = wsBuffer.subarray(offset + maskLength + length);
-        if (opcode == 0x8) {
+        // Reassemble fragmented messages: a non-final data frame (0x1/0x2 with
+        // FIN=0) starts a sequence continued by 0x0 frames until FIN=1. Chromium
+        // fragments large (64KB) frames, so without this the wipc stream
+        // desyncs and the report payload is corrupted.
+        const fin = (first & 0x80) !== 0;
+        let effectiveOpcode = opcode;
+        if (opcode == 0x0) {
+          wsFragments.push(payload);
+          if (!fin) continue;
+          payload = Buffer.concat(wsFragments);
+          wsFragments = [];
+          effectiveOpcode = wsFragmentOpcode;
+          wsFragmentOpcode = 0;
+        } else if ((opcode == 0x1 || opcode == 0x2) && !fin) {
+          wsFragmentOpcode = opcode;
+          wsFragments = [payload];
+          continue;
+        }
+        if (effectiveOpcode == 0x8) {
           finish(0);
           return;
         }
-        if (opcode == 0x1) {
+        if (effectiveOpcode == 0x1) {
           onControl(payload.toString("utf8"));
           continue;
         }
-        if (opcode == 0x2) {
+        if (effectiveOpcode == 0x2) {
           process.stdout.write(payload);
         }
       }
@@ -703,20 +731,33 @@ function createWasmImports(
   module: WebAssembly.Module,
   imports: AnyImports,
 ): AnyImports {
-  const mergedImports = mergeImports(withNodeIo({}), imports);
-  if (!mergedImports.env || typeof mergedImports.env != "object") {
-    mergedImports.env = {};
-  }
+  return stubMissingImports(module, mergeImports(withNodeIo({}), imports));
+}
+
+// Fills any function import the module declares but the caller didn't provide
+// with a no-op stub, so instantiation never fails on a missing import. This
+// covers imports an unmocked `mockImport` target reintroduces (which keep
+// their real binding but have no host implementation in tests). `skipModules`
+// leaves bindings-helper-owned modules (env / wasi) for the helper to fill.
+function stubMissingImports(
+  module: WebAssembly.Module,
+  imports: AnyImports,
+  skipModules: readonly string[] = [],
+): AnyImports {
+  const skip = new Set(skipModules);
+  const bag = imports as Record<string, Record<string, unknown>>;
   for (const entry of WebAssembly.Module.imports(module)) {
-    if (
-      entry.module == "env" &&
-      entry.kind == "function" &&
-      !(entry.name in mergedImports.env)
-    ) {
-      mergedImports.env[entry.name] = () => 0;
+    if (entry.kind != "function" || skip.has(entry.module)) continue;
+    let mod = bag[entry.module];
+    if (!mod || typeof mod != "object") {
+      mod = {};
+      bag[entry.module] = mod;
+    }
+    if (!(entry.name in mod)) {
+      mod[entry.name] = () => 0;
     }
   }
-  return mergedImports;
+  return imports;
 }
 
 let patchedWasiWarning = false;
@@ -1306,6 +1347,16 @@ async function captureHelperInstance(
     source: BufferSource | WebAssembly.Module,
     importObject?: WebAssembly.Imports,
   ) => {
+    // Stub any import the bindings helper left unprovided (e.g. an unmocked
+    // mockImport target with no host implementation), so esm/raw bindings
+    // instantiate instead of failing with a LinkError. env/wasi stay with the
+    // helper.
+    if (source instanceof WebAssembly.Module && importObject) {
+      stubMissingImports(source, importObject as AnyImports, [
+        "env",
+        "wasi_snapshot_preview1",
+      ]);
+    }
     const result = await originalInstantiate(source, importObject);
     if (result instanceof WebAssembly.Instance) {
       instance = result;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "as-test",
-  "version": "1.4.1",
+  "version": "1.5.1",
   "author": "Jairus Tanaka",
   "repository": {
     "type": "git",
@@ -74,30 +74,31 @@
     "access": "public"
   },
   "scripts": {
-    "test": "npm run test:as && npm run test:integration",
-    "test:as": "node ./bin/index.js test --parallel --enable try-as",
-    "test:integration": "npm run build:cli && npm run build:lib && node --test tests/*.test.mjs",
-    "test:ci": "node ./bin/index.js test --parallel --tap --enable try-as --config ./as-test.ci.config.json",
+    "build": "npm run build:cli && npm run build:lib && npm run build:transform",
+    "build:cli": "rm -rf ./bin/ && tsc -p cli && prettier -w ./cli/ && chmod +x ./bin/index.js",
+    "build:lib": "tsc -p ./tsconfig.lib.json",
+    "build:transform": "rm -rf ./transform/lib && tsc -p ./transform && prettier -w ./transform/",
+    "test": "node ./bin/index.js test --parallel",
+    "test:integration": "node --test tests/*.test.mjs",
+    "test:modes": "npm run test -- --mode node:bindings,node:bindings:raw,node:bindings:esm,node:wasi,wasmtime,wasmer,wazero,firefox,chromium,webkit,firefox:headless,chromium:headless,webkit:headless",
+    "test:examples": "npm --prefix ./examples run test",
+    "test:all": "npm run build && npm run test:modes && npm run test:integration && npm run test:examples",
+    "test:ci": "npm run test -- --mode node:bindings,node:wasi,wasmtime",
     "fuzz": "node ./bin/index.js fuzz",
     "bench:seed": "node ./bin/index.js fuzz --config ./as-test.bench.config.json --clean",
     "bench:seed:compare": "bash ./tools/bench-seed-compare.sh 7",
-    "test:examples": "npm --prefix ./examples run test",
-    "ci:act": "bash ./tools/act.sh push",
-    "ci:act:pr": "bash ./tools/act.sh pull_request",
-    "ci:act:tests": "act push -W .github/workflows/as-test.yml",
-    "ci:act:examples": "act push -W .github/workflows/examples.yml",
     "typecheck": "tsc -p cli --noEmit && tsc -p tsconfig.lib.json --noEmit && tsc -p transform --noEmit",
     "lint": "eslint transform/src/**/*.ts tools/**/*.js eslint.config.js",
-    "build:lib": "tsc -p ./tsconfig.lib.json",
-    "build:transform": "rm -rf ./transform/lib && tsc -p ./transform && prettier -w ./transform/",
-    "build:cli": "rm -rf ./bin/ && tsc -p cli && prettier -w ./cli/ && chmod +x ./bin/index.js",
-    "build:run": "npm run build:cli",
+    "format": "prettier -w .",
     "docs:dev": "vitepress dev docs",
     "docs:build": "vitepress build docs",
     "docs:preview": "vitepress preview docs",
-    "format": "prettier -w .",
-    "release:check": "npm run build:cli && npm run build:lib && npm run build:transform && npm run test && npm run test:examples && npm pack --dry-run --cache /tmp/as-test-npm-cache",
-    "prepublishOnly": "npm run build:cli && npm run build:lib && npm run build:transform && npm run test && npm run format",
+    "release:check": "npm run build && npm run test && npm run test:examples && npm pack --dry-run --cache /tmp/as-test-npm-cache",
+    "prepublishOnly": "npm run build && npm run test && npm run format",
+    "ci:act": "bash ./tools/act.sh push",
+    "ci:act:pr": "bash ./tools/act.sh pull_request",
+    "ci:act:tests": "act push -W .github/workflows/as-test.yml",
+    "ci:act:examples": "act push -W .github/workflows/examples.yml",
     "commitmsg:verify": "bash ./scripts/commit-msg.sh",
     "precommit:verify": "bash ./scripts/pre-commit.sh",
     "prepare": "husky"

package/transform/lib/equals.js

@@ -4,7 +4,7 @@ import { readFileSync } from "fs";
 import { join } from "path";
 import { SimpleParser, isStdlib } from "./util.js";
 const EQUALS_METHOD = "__AS_TEST_EQUALS";
-const TOJSON_METHOD = "toJSON";
+const GENERATED_TOJSON_METHOD = "__AS_TEST_TO_JSON";
 const REFLECT_LOCAL = "__AS_TEST_REFLECT_EQUALS_INTERNAL";
 const STRINGIFY_LOCAL = "__AS_TEST_STRINGIFY_INTERNAL";
 const ALREADY_INJECTED_EQUALS = new WeakSet();
@@ -165,7 +165,7 @@ export class EqualsTransform {
     injectToJSONMethod(klass) {
         if (ALREADY_INJECTED_TOJSON.has(klass))
             return false;
-        if (declaresMethod(klass, TOJSON_METHOD))
+        if (declaresMethod(klass, GENERATED_TOJSON_METHOD))
             return false;
         if (hasAnyDecorator(klass, JSON_DECORATORS))
             return false;
@@ -189,7 +189,7 @@ export class EqualsTransform {
         const body = parts.length
             ? `return "{" + ${parts.join(" + ")} + "}";`
             : `return "{}";`;
-        const code = `toJSON(): string { ${body} }`;
+        const code = `${GENERATED_TOJSON_METHOD}(): string { ${body} }`;
         try {
             const method = SimpleParser.parseClassMember(code, klass);
             klass.members.push(method);

package/transform/lib/index.js

@@ -37,6 +37,10 @@ export default class Transformer extends Transform {
         for (const target of mockedImportTargets) {
             mock.importMocked.add(target);
         }
+        const unmockedImportTargets = collectUnmockImportTargets(sources);
+        for (const target of unmockedImportTargets) {
+            mock.importUnmocked.add(target);
+        }
         for (const source of sources) {
             const sourceInfo = analyzeSourceText(source.text);
             const shouldInjectRunCall = source.sourceKind == 1 &&
@@ -110,8 +114,13 @@ function patchModeName(parser, modeName) {
     }
 }
 function collectMockImportTargets(sources) {
+    return collectImportTargets(sources, /\bmockImport\s*\(\s*["']([^"']+)["']/g);
+}
+function collectUnmockImportTargets(sources) {
+    return collectImportTargets(sources, /\bunmockImport\s*\(\s*["']([^"']+)["']/g);
+}
+function collectImportTargets(sources, pattern) {
     const out = new Set();
-    const pattern = /\bmockImport\s*\(\s*["']([^"']+)["']/g;
     for (const source of sources) {
         const text = stripComments(source.text);
         for (const match of text.matchAll(pattern)) {

package/transform/lib/mock.js

@@ -6,8 +6,11 @@ export class MockTransform extends Visitor {
     globalStatements = [];
     mocked = new Set();
     importMocked = new Set();
-    visitCallExpression(node) {
-        super.visitCallExpression(node);
+    importUnmocked = new Set();
+    pendingHoist = [];
+    pendingRemoval = [];
+    visitCallExpression(node, ref = null) {
+        super.visitCallExpression(node, ref);
         const name = normalizeName(expressionName(node.expression));
         if (this.mocked.has(name + "_mock")) {
             node.expression = Node.createIdentifierExpression(name + "_mock", node.expression.range);
@@ -25,6 +28,7 @@ export class MockTransform extends Visitor {
             if (!oldFn)
                 return;
             this.mocked.delete(normalizeName(expressionName(oldFn)) + "_mock");
+            this.scheduleRemoval(node, ref);
             return;
         }
         if (name == "unmockImport") {
@@ -34,26 +38,21 @@ export class MockTransform extends Visitor {
             return;
         const oldValue = node.args[0];
         const callback = node.args[1];
-        if (!oldValue || !callback)
+        if (!oldValue || !callback || !callback.declaration)
             return;
-        const newName = normalizeName(expressionName(oldValue));
-        const newFn = Node.createFunctionDeclaration(Node.createIdentifierExpression(newName + "_mock", callback.range), callback.declaration.decorators, 0, callback.declaration.typeParameters, callback.declaration.signature, callback.declaration.body, callback.declaration.arrowKind, callback.range);
-        const currentSource = this.srcCurrent;
-        if (!currentSource)
-            return;
-        const stmts = currentSource.statements;
-        let index = -1;
-        for (let i = 0; i < stmts.length; i++) {
-            const stmt = stmts[i];
-            if (stmt.range.start != node.range.start)
-                continue;
-            index = i;
-            break;
-        }
-        if (index === -1)
+        const mockName = normalizeName(expressionName(oldValue)) + "_mock";
+        const newFn = Node.createFunctionDeclaration(Node.createIdentifierExpression(mockName, callback.range), callback.declaration.decorators, 0, callback.declaration.typeParameters, callback.declaration.signature, callback.declaration.body, callback.declaration.arrowKind, callback.range);
+        this.pendingHoist.push(newFn);
+        this.mocked.add(mockName);
+        this.scheduleRemoval(node, ref);
+    }
+    scheduleRemoval(node, ref) {
+        const container = asStatementContainer(ref);
+        if (!container)
             return;
-        stmts.splice(index, 1, newFn);
-        this.mocked.add(newFn.name.text);
+        const stmt = container.statements.find((s) => s.expression === node);
+        if (stmt)
+            this.pendingRemoval.push({ container, stmt });
     }
     visitFunctionDeclaration(node, isDefault) {
         if (this.mocked.has(node.name.text))
@@ -62,11 +61,23 @@ export class MockTransform extends Visitor {
     }
     visitSource(node) {
         this.mocked = new Set();
+        this.pendingHoist = [];
+        this.pendingRemoval = [];
         this.srcCurrent = node;
         super.visitSource(node);
         const currentSource = this.srcCurrent;
         if (!currentSource)
             return;
+        for (const { container, stmt } of this.pendingRemoval) {
+            const i = container.statements.indexOf(stmt);
+            if (i !== -1)
+                container.statements.splice(i, 1);
+        }
+        this.pendingRemoval = [];
+        if (this.pendingHoist.length) {
+            currentSource.statements.unshift(...this.pendingHoist);
+            this.pendingHoist = [];
+        }
         const stmts = currentSource.statements;
         for (let index = 0; index < stmts.length; index++) {
             const node = stmts[index];
@@ -98,6 +109,17 @@ export class MockTransform extends Visitor {
                 index++;
                 continue;
             }
+            if (this.importUnmocked.has(path) && node.signature.returnType) {
+                const realName = "__as_test_real_" + node.name.text;
+                const r = node.range;
+                const wrapper = buildFallbackWrapper(node, path, realName, r);
+                const mutable = node;
+                mutable.name = Node.createIdentifierExpression(realName, r);
+                mutable.flags &= ~2;
+                stmts.splice(index + 1, 0, wrapper);
+                index++;
+                continue;
+            }
             const args = [
                 Node.createCallExpression(Node.createPropertyAccessExpression(Node.createIdentifierExpression("__mock_import", node.range), Node.createIdentifierExpression("get", node.range), node.range), null, [Node.createStringLiteralExpression(path, node.range)], node.range),
             ];
@@ -120,6 +142,27 @@ function isBodylessTopLevelFunction(node) {
         "signature" in candidate &&
         candidate.body == null);
 }
+function buildFallbackWrapper(node, path, realName, range) {
+    const mockImportGet = Node.createCallExpression(Node.createPropertyAccessExpression(Node.createIdentifierExpression("__mock_import", range), Node.createIdentifierExpression("get", range), range), null, [Node.createStringLiteralExpression(path, range)], range);
+    const indirectArgs = [mockImportGet];
+    const forwardArgs = [];
+    for (const param of node.signature.parameters) {
+        indirectArgs.push(Node.createIdentifierExpression(param.name.text, range));
+        forwardArgs.push(Node.createIdentifierExpression(param.name.text, range));
+    }
+    const ifMocked = Node.createIfStatement(Node.createCallExpression(Node.createPropertyAccessExpression(Node.createIdentifierExpression("__mock_import", range), Node.createIdentifierExpression("has", range), range), null, [Node.createStringLiteralExpression(path, range)], range), Node.createReturnStatement(Node.createCallExpression(Node.createIdentifierExpression("call_indirect", range), null, indirectArgs, range), range), null, range);
+    const callReal = Node.createReturnStatement(Node.createCallExpression(Node.createIdentifierExpression(realName, range), null, forwardArgs, range), range);
+    const signature = Node.createFunctionType(node.signature.parameters, node.signature.returnType, node.signature.explicitThisType, node.signature.isNullable, range);
+    const exported = (node.flags & 2) != 0;
+    return Node.createFunctionDeclaration(Node.createIdentifierExpression(node.name.text, range), null, exported ? 2 : 0, node.typeParameters, signature, Node.createBlockStatement([ifMocked, callReal], range), 0, range);
+}
+function asStatementContainer(ref) {
+    const candidate = ref;
+    if (candidate && Array.isArray(candidate.statements)) {
+        return candidate;
+    }
+    return null;
+}
 function normalizeName(value) {
     return value
         .replaceAll(".", "_")