as-test 1.0.1 → 1.0.3

package/assembly/src/log.ts

@@ -1,13 +1,18 @@
 import { quote } from "../util/json";
 
+import { sendLog } from "../util/wipc";
+
 export class Log {
   public order: i32 = 0;
   public depth: i32 = 0;
+  public file: string = "unknown";
   public text: string;
   constructor(text: string) {
     this.text = text;
   }
-  display(): void {}
+  display(): void {
+    sendLog(this.file, this.depth, this.text);
+  }
 
   serialize(): string {
     return (

package/assembly/src/suite.ts

@@ -12,6 +12,7 @@ export class Suite {
   public time: Time = new Time();
   public description: string;
   public depth: i32 = 0;
+  public snapshotCount: i32 = 0;
   public suites: Suite[] = [];
   public tests: Tests[] = [];
   public logs: Log[] = [];
@@ -43,6 +44,7 @@ export class Suite {
     log.order = this.order++;
     this.logs.push(log);
     log.depth = this.depth + 1;
+    log.file = this.file;
     log.display();
   }
 
@@ -54,12 +56,19 @@ export class Suite {
     this.time.start = performance.now();
     sendSuiteStart(this.file, this.depth, this.kind, this.description);
     const isSkippedCase =
-      this.kind == "xdescribe" || this.kind == "xtest" || this.kind == "xit";
+      this.kind == "xdescribe" ||
+      this.kind == "xtest" ||
+      this.kind == "xit" ||
+      this.kind == "xonly" ||
+      this.kind == "todo";
     const isTestCase =
       this.kind == "test" ||
       this.kind == "it" ||
+      this.kind == "only" ||
       this.kind == "xtest" ||
-      this.kind == "xit";
+      this.kind == "xit" ||
+      this.kind == "xonly" ||
+      this.kind == "todo";
 
     if (isSkippedCase) {
       this.time.end = performance.now();
@@ -85,12 +94,18 @@ export class Suite {
     // @ts-ignore
     depth--;
 
+    const hasOnlyChildren = this.hasOnlyChildren();
+
     let hasFail = false;
     let hasOk = false;
     let hasSkip = false;
     for (let i = 0; i < this.suites.length; i++) {
       const suite = unchecked(this.suites[i]);
-      suite.run();
+      if (hasOnlyChildren && suite.kind != "only") {
+        suite.skip();
+      } else {
+        suite.run();
+      }
       if (suite.verdict == "fail") {
         hasFail = true;
       } else if (suite.verdict == "ok") {
@@ -128,6 +143,33 @@ export class Suite {
     );
   }
 
+  skip(): void {
+    // @ts-ignore
+    current_suite = this;
+    // @ts-ignore
+    depth++;
+    this.time.start = performance.now();
+    this.time.end = this.time.start;
+    this.verdict = "skip";
+    sendSuiteStart(this.file, this.depth, this.kind, this.description);
+    // @ts-ignore
+    depth--;
+    sendSuiteEnd(
+      this.file,
+      this.depth,
+      this.kind,
+      this.description,
+      this.verdict,
+    );
+  }
+
+  private hasOnlyChildren(): bool {
+    for (let i = 0; i < this.suites.length; i++) {
+      if (unchecked(this.suites[i]).kind == "only") return true;
+    }
+    return false;
+  }
+
   serialize(): string {
     let out = "{";
     if (this.depth <= 0) {

package/assembly/util/json.ts

@@ -31,6 +31,11 @@ export function stringifyValue<T>(value: T): string {
     return stringifyArray<valueof<T>>(value as valueof<T>[]);
   }
 
+  if (isManaged<T>()) {
+    // @ts-expect-error: method exists
+    return value.__as_test_json();
+  }
+
   const formatted = stringify<T>(value);
   if (formatted != "none") {
     return quote(formatted);
@@ -39,6 +44,10 @@ export function stringifyValue<T>(value: T): string {
   return quote(nameof<T>());
 }
 
+export function __as_test_json_value<T>(value: T): string {
+  return stringifyValue<T>(value);
+}
+
 function stringifyArray<T>(values: T[]): string {
   if (!values.length) return "[]";
 
@@ -59,6 +68,10 @@ function escape(value: string): string {
       out += '\\"';
     } else if (ch == 92) {
       out += "\\\\";
+    } else if (ch == 8) {
+      out += "\\b";
+    } else if (ch == 12) {
+      out += "\\f";
     } else if (ch == 10) {
       out += "\\n";
     } else if (ch == 13) {
@@ -66,13 +79,34 @@ function escape(value: string): string {
     } else if (ch == 9) {
       out += "\\t";
     } else if (ch < 32) {
-      out += "\\u00";
-      const hex = ch.toString(16);
-      if (hex.length < 2) out += "0";
-      out += hex;
+      out += unicodeEscape(ch);
+    } else if (ch >= 0xd800 && ch <= 0xdfff) {
+      if (ch <= 0xdbff && i + 1 < value.length) {
+        const next = value.charCodeAt(i + 1);
+        if (next >= 0xdc00 && next <= 0xdfff) {
+          out += value.charAt(i);
+          out += value.charAt(i + 1);
+          i++;
+          continue;
+        }
+      }
+      out += unicodeEscape(ch);
     } else {
       out += value.charAt(i);
     }
   }
   return out;
 }
+
+function unicodeEscape(code: i32): string {
+  let out = "\\u";
+  out += hexNibble((code >> 12) & 0xf);
+  out += hexNibble((code >> 8) & 0xf);
+  out += hexNibble((code >> 4) & 0xf);
+  out += hexNibble(code & 0xf);
+  return out;
+}
+
+function hexNibble(value: i32): string {
+  return String.fromCharCode(value < 10 ? 48 + value : 87 + value);
+}

package/assembly/util/wipc.ts

@@ -1,3 +1,5 @@
+import { quote as q } from "./json";
+
 // @ts-ignore
 @external("env", "process.stdout.write")
 declare function process_stdout_write(data: ArrayBuffer): void;
@@ -47,6 +49,11 @@ export class SnapshotReply {
   public expected: string = "";
 }
 
+export class FuzzConfigReply {
+  public runs: i32 = 1000;
+  public seed: u64 = 1337;
+}
+
 export function sendAssertionFailure(
   key: string,
   instr: string,
@@ -96,6 +103,13 @@ export function sendSuiteEnd(
   );
 }
 
+export function sendLog(file: string, depth: i32, text: string): void {
+  sendJson(
+    MessageType.CALL,
+    `{"kind":"event:log","file":${q(file)},"depth":${depth.toString()},"text":${q(text)}}`,
+  );
+}
+
 export function snapshotAssert(key: string, actual: string): SnapshotReply {
   sendJson(
     MessageType.CALL,
@@ -117,12 +131,32 @@ export function snapshotAssert(key: string, actual: string): SnapshotReply {
   return reply;
 }
 
+export function requestFuzzConfig(): FuzzConfigReply {
+  sendJson(MessageType.CALL, `{"kind":"fuzz:config"}`);
+  const response = readFrame();
+  if (response == null || response.type != MessageType.CALL) {
+    return new FuzzConfigReply();
+  }
+  const body = String.UTF8.decode(response.payload);
+  if (!body.length) {
+    return new FuzzConfigReply();
+  }
+  const sep = body.indexOf("\n");
+  if (sep < 0) return new FuzzConfigReply();
+  const reply = new FuzzConfigReply();
+  const runs = body.slice(0, sep);
+  const seed = body.slice(sep + 1);
+  if (runs.length) reply.runs = I32.parseInt(runs);
+  if (seed.length) reply.seed = U64.parseInt(seed);
+  return reply;
+}
+
 export function sendReport(report: string): void {
   sendFrame(MessageType.DATA, String.UTF8.encode(report));
 }
 
 export function sendWarning(message: string): void {
-  writeStdout(String.UTF8.encode("[WARN] " + message + "\n"));
+  sendJson(MessageType.CALL, `{"kind":"event:warn","message":${q(message)}}`);
 }
 
 function sendJson(type: MessageType, body: string): void {
@@ -259,28 +293,3 @@ function wasiRead(max: i32): ArrayBuffer {
   memory.copy(changetype<usize>(partial), changetype<usize>(out), size);
   return partial;
 }
-
-function q(value: string): string {
-  return '"' + escape(value) + '"';
-}
-
-function escape(value: string): string {
-  let out = "";
-  for (let i = 0; i < value.length; i++) {
-    const ch = value.charCodeAt(i);
-    if (ch == 34) {
-      out += '\\"';
-    } else if (ch == 92) {
-      out += "\\\\";
-    } else if (ch == 10) {
-      out += "\\n";
-    } else if (ch == 13) {
-      out += "\\r";
-    } else if (ch == 9) {
-      out += "\\t";
-    } else {
-      out += String.fromCharCode(ch);
-    }
-  }
-  return out;
-}

package/bin/build-worker-pool.js

@@ -0,0 +1,149 @@
+import { spawn } from "child_process";
+import { fileURLToPath } from "url";
+export class BuildWorkerPool {
+    constructor(size) {
+        this.pools = new Map();
+        this.nextId = 1;
+        this.closed = false;
+        this.size = Math.max(1, size);
+    }
+    buildFileMode(args) {
+        if (this.closed) {
+            return Promise.reject(new Error("build worker pool is closed"));
+        }
+        const featureToggles = args.featureToggles ?? {};
+        const overrides = args.overrides ?? {};
+        const signature = buildSignature(args.modeName, featureToggles, overrides);
+        const pool = this.getPool(signature);
+        return new Promise((resolve, reject) => {
+            pool.queue.push({
+                id: this.nextId++,
+                configPath: args.configPath,
+                file: args.file,
+                modeName: args.modeName,
+                featureToggles,
+                overrides,
+                resolve,
+                reject,
+            });
+            this.pump(pool);
+        });
+    }
+    async close() {
+        this.closed = true;
+        const waits = [];
+        for (const pool of this.pools.values()) {
+            while (pool.queue.length) {
+                const task = pool.queue.shift();
+                task.reject(new Error("build worker pool closed"));
+            }
+            for (const worker of pool.workers) {
+                waits.push(new Promise((resolve) => {
+                    if (worker.child.exitCode != null || worker.child.killed) {
+                        resolve();
+                        return;
+                    }
+                    worker.child.once("exit", () => resolve());
+                    worker.child.kill();
+                }));
+            }
+        }
+        await Promise.all(waits);
+    }
+    getPool(signature) {
+        let pool = this.pools.get(signature);
+        if (pool)
+            return pool;
+        pool = {
+            workers: Array.from({ length: this.size }, () => this.spawnWorker(signature)),
+            queue: [],
+        };
+        this.pools.set(signature, pool);
+        return pool;
+    }
+    spawnWorker(signature) {
+        const workerPath = fileURLToPath(new URL("./build-worker.js", import.meta.url));
+        const child = spawn(process.execPath, [workerPath], {
+            stdio: ["ignore", "ignore", "ignore", "ipc"],
+        });
+        const worker = {
+            child,
+            busy: false,
+            task: null,
+        };
+        child.on("message", (message) => {
+            this.onMessage(signature, worker, message);
+        });
+        child.on("exit", () => {
+            const pool = this.pools.get(signature);
+            const failedTask = worker.task;
+            worker.busy = false;
+            worker.task = null;
+            if (failedTask) {
+                failedTask.reject(new Error("build worker exited unexpectedly"));
+            }
+            if (!pool || this.closed)
+                return;
+            const index = pool.workers.indexOf(worker);
+            if (index >= 0) {
+                pool.workers[index] = this.spawnWorker(signature);
+            }
+            this.pump(pool);
+        });
+        return worker;
+    }
+    onMessage(signature, worker, message) {
+        const pool = this.pools.get(signature);
+        const task = worker.task;
+        if (!pool || !task || task.id !== message.id)
+            return;
+        worker.busy = false;
+        worker.task = null;
+        if (message.type == "done") {
+            task.resolve();
+        }
+        else {
+            task.reject(deserializeError(message.error));
+        }
+        this.pump(pool);
+    }
+    pump(pool) {
+        for (const worker of pool.workers) {
+            if (worker.busy)
+                continue;
+            const task = pool.queue.shift();
+            if (!task)
+                return;
+            worker.busy = true;
+            worker.task = task;
+            worker.child.send({
+                type: "build-file",
+                id: task.id,
+                configPath: task.configPath,
+                file: task.file,
+                modeName: task.modeName,
+                featureToggles: task.featureToggles,
+                overrides: task.overrides,
+            });
+        }
+    }
+}
+function buildSignature(modeName, featureToggles, overrides) {
+    return JSON.stringify({
+        modeName: modeName ?? "default",
+        featureToggles,
+        overrides,
+    });
+}
+function deserializeError(payload) {
+    const error = new Error(typeof payload.message == "string" ? payload.message : "unknown error");
+    error.name = typeof payload.name == "string" ? payload.name : "Error";
+    if (typeof payload.stack == "string")
+        error.stack = payload.stack;
+    for (const [key, value] of Object.entries(payload)) {
+        if (key == "name" || key == "message" || key == "stack")
+            continue;
+        error[key] = value;
+    }
+    return error;
+}

package/bin/build-worker.js

@@ -0,0 +1,43 @@
+import { build } from "./commands/build-core.js";
+process.env.AS_TEST_BUILD_API = "1";
+process.on("message", async (message) => {
+    if (!message || message.type != "build-file")
+        return;
+    try {
+        await build(message.configPath, [message.file], message.modeName, message.featureToggles, message.overrides);
+        send({
+            type: "done",
+            id: message.id,
+        });
+    }
+    catch (error) {
+        send({
+            type: "error",
+            id: message.id,
+            error: serializeError(error),
+        });
+    }
+});
+function send(message) {
+    if (!process.send)
+        return;
+    process.send(message);
+}
+function serializeError(error) {
+    if (!(error instanceof Error)) {
+        return {
+            name: "Error",
+            message: typeof error == "string" ? error : "unknown error",
+        };
+    }
+    const out = {
+        name: error.name,
+        message: error.message,
+        stack: error.stack,
+    };
+    const errorRecord = error;
+    for (const key of Object.keys(error)) {
+        out[key] = errorRecord[key];
+    }
+    return out;
+}