as-test 0.4.4 → 0.5.1

package/assembly/src/suite.ts

@@ -1,9 +1,9 @@
-import { rainbow } from "as-rainbow";
 import { Time } from "..";
 import { Expectation } from "./expectation";
 import { Tests } from "./tests";
-import { term } from "../util/term";
 import { Log } from "./log";
+import { after_each_callback, before_each_callback } from "..";
+import { sendSuiteEnd, sendSuiteStart } from "../util/wipc";
 
 
 @json
@@ -20,6 +20,10 @@ export class Suite {
   public logs: Log[] = [];
   public kind: string;
 
+
+  @omit
+  public parent: Suite | null = null;
+
   public verdict: string = "none";
 
   public callback: () => void;
@@ -38,6 +42,7 @@ export class Suite {
     this.suites.push(suite);
     suite.depth = this.depth + 1;
     suite.file = this.file;
+    suite.parent = this;
   }
   addLog(log: Log): void {
     log.order = this.order++;
@@ -52,50 +57,81 @@ export class Suite {
     // @ts-ignore
     depth++;
     this.time.start = performance.now();
-    const suiteDepth = "  ".repeat(this.depth + 1);
-    const suiteLn = term.write(
-      `${suiteDepth}${rainbow.bgBlackBright(" ... ")} ${rainbow.dimMk(this.description)}\n`,
-    );
-    term.write("\n");
+    sendSuiteStart(this.file, this.depth, this.kind, this.description);
+    const isSkippedCase =
+      this.kind == "xdescribe" ||
+      this.kind == "xtest" ||
+      this.kind == "xit";
+    const isTestCase =
+      this.kind == "test" ||
+      this.kind == "it" ||
+      this.kind == "xtest" ||
+      this.kind == "xit";
+
+    if (isSkippedCase) {
+      this.time.end = performance.now();
+      this.verdict = "skip";
+      // @ts-ignore
+      depth--;
+      sendSuiteEnd(
+        this.file,
+        this.depth,
+        this.kind,
+        this.description,
+        this.verdict,
+      );
+      return;
+    }
+
+    // @ts-ignore
+    if (isTestCase && before_each_callback) before_each_callback();
     this.callback();
+    // @ts-ignore
+    if (isTestCase && after_each_callback) after_each_callback();
     this.time.end = performance.now();
     // @ts-ignore
     depth--;
 
-    let suiteNone = true;
+    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 (suite.verdict == "fail") {
-        this.verdict = "fail";
-        suiteNone = false;
+        hasFail = true;
       } else if (suite.verdict == "ok") {
-        suiteNone = false;
+        hasOk = true;
+      } else if (suite.verdict == "skip") {
+        hasSkip = true;
       }
     }
     for (let i = 0; i < this.tests.length; i++) {
       const test = unchecked(this.tests[i]);
       if (test.verdict == "fail") {
-        this.verdict = "fail";
-        suiteNone = false;
+        hasFail = true;
       } else if (test.verdict == "ok") {
-        suiteNone = false;
+        hasOk = true;
+      } else if (test.verdict == "skip") {
+        hasSkip = true;
       }
     }
 
-    if (this.verdict == "fail") {
-      suiteLn.edit(
-        `${suiteDepth}${rainbow.bgRed(" FAIL ")} ${rainbow.dimMk(this.description)}\n`,
-      );
-    } else if (!suiteNone || this.tests.length) {
+    if (hasFail) {
+      this.verdict = "fail";
+    } else if (hasOk) {
       this.verdict = "ok";
-      suiteLn.edit(
-        `${suiteDepth}${rainbow.bgGreenBright(" PASS ")} ${rainbow.dimMk(this.description)}\n`,
-      );
+    } else if (hasSkip) {
+      this.verdict = "skip";
     } else {
-      suiteLn.edit(
-        `${suiteDepth}${rainbow.bgBlackBright(" EMPTY ")} ${rainbow.dimMk(this.description)}\n`,
-      );
+      this.verdict = "none";
     }
+    sendSuiteEnd(
+      this.file,
+      this.depth,
+      this.kind,
+      this.description,
+      this.verdict,
+    );
   }
 }

package/assembly/src/tests.ts

@@ -9,4 +9,6 @@ export class Tests {
   public left: JSON.Raw = JSON.Raw.from("");
   public right: JSON.Raw = JSON.Raw.from("");
   public instr: string = "";
+  public message: string = "";
+  public location: string = "";
 }

package/assembly/util/wipc.ts

@@ -0,0 +1,286 @@
+// @ts-ignore
+@external("env", "process.stdout.write")
+declare function process_stdout_write(data: ArrayBuffer): void;
+
+// @ts-ignore
+@external("env", "process.stdin.read")
+declare function process_stdin_read(max: i32): ArrayBuffer;
+
+// @ts-ignore
+@external("wasi_snapshot_preview1", "fd_write")
+declare function wasi_fd_write(
+  fd: i32,
+  iovs: usize,
+  iovsLen: i32,
+  written: usize,
+): i32;
+
+// @ts-ignore
+@external("wasi_snapshot_preview1", "fd_read")
+declare function wasi_fd_read(
+  fd: i32,
+  iovs: usize,
+  iovsLen: i32,
+  read: usize,
+): i32;
+
+const MAGIC_W: u8 = 0x57; // W
+const MAGIC_I: u8 = 0x49; // I
+const MAGIC_P: u8 = 0x50; // P
+const MAGIC_C: u8 = 0x43; // C
+const HEADER_SIZE: i32 = 9;
+const IOV_SIZE: usize = sizeof<usize>() * 2;
+const U32_SIZE: usize = sizeof<u32>();
+
+// @ts-ignore
+const IS_BINDINGS: bool = isDefined(AS_TEST_BINDINGS);
+
+enum MessageType {
+  OPEN = 0x00,
+  CLOSE = 0x01,
+  CALL = 0x02,
+  DATA = 0x03,
+}
+
+export class SnapshotReply {
+  public ok: bool = false;
+  public expected: string = "";
+}
+
+export function sendAssertionFailure(
+  key: string,
+  instr: string,
+  left: string,
+  right: string,
+  message: string,
+): void {
+  sendJson(
+    MessageType.CALL,
+    `{"kind":"event:assert-fail","key":${q(key)},"instr":${q(instr)},"left":${q(left)},"right":${q(right)},"message":${q(message)}}`,
+  );
+}
+
+export function sendFileStart(file: string): void {
+  sendJson(MessageType.CALL, `{"kind":"event:file-start","file":${q(file)}}`);
+}
+
+export function sendFileEnd(file: string, verdict: string, time: string): void {
+  sendJson(
+    MessageType.CALL,
+    `{"kind":"event:file-end","file":${q(file)},"verdict":${q(verdict)},"time":${q(time)}}`,
+  );
+}
+
+export function sendSuiteStart(
+  file: string,
+  depth: i32,
+  kind: string,
+  description: string,
+): void {
+  sendJson(
+    MessageType.CALL,
+    `{"kind":"event:suite-start","file":${q(file)},"depth":${depth.toString()},"suiteKind":${q(kind)},"description":${q(description)}}`,
+  );
+}
+
+export function sendSuiteEnd(
+  file: string,
+  depth: i32,
+  kind: string,
+  description: string,
+  verdict: string,
+): void {
+  sendJson(
+    MessageType.CALL,
+    `{"kind":"event:suite-end","file":${q(file)},"depth":${depth.toString()},"suiteKind":${q(kind)},"description":${q(description)},"verdict":${q(verdict)}}`,
+  );
+}
+
+export function snapshotAssert(key: string, actual: string): SnapshotReply {
+  sendJson(
+    MessageType.CALL,
+    `{"kind":"snapshot:assert","key":${q(key)},"actual":${q(actual)}}`,
+  );
+  const response = readFrame();
+  if (response == null || response.type != MessageType.CALL) {
+    return new SnapshotReply();
+  }
+  const body = String.UTF8.decode(response.payload);
+  if (!body.length) {
+    return new SnapshotReply();
+  }
+  const sep = body.indexOf("\n");
+  if (sep < 0) return new SnapshotReply();
+  const reply = new SnapshotReply();
+  reply.ok = body.slice(0, sep) == "1";
+  reply.expected = body.slice(sep + 1);
+  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"));
+}
+
+function sendJson(type: MessageType, body: string): void {
+  sendFrame(type, String.UTF8.encode(body));
+}
+
+function sendFrame(type: MessageType, payload: ArrayBuffer): void {
+  const payloadLen = payload.byteLength;
+  const out = new ArrayBuffer(HEADER_SIZE + payloadLen);
+  const ptr = changetype<usize>(out);
+
+  store<u8>(ptr, MAGIC_W, 0);
+  store<u8>(ptr, MAGIC_I, 1);
+  store<u8>(ptr, MAGIC_P, 2);
+  store<u8>(ptr, MAGIC_C, 3);
+  store<u8>(ptr, <u8>type, 4);
+  store<u32>(ptr, <u32>payloadLen, 5);
+
+  if (payloadLen) {
+    memory.copy(ptr + HEADER_SIZE, changetype<usize>(payload), payloadLen);
+  }
+
+  writeStdout(out);
+}
+
+class Frame {
+  constructor(
+    public type: MessageType,
+    public payload: ArrayBuffer,
+  ) {}
+}
+
+function readFrame(): Frame | null {
+  const header = readExact(HEADER_SIZE);
+  if (header.byteLength < HEADER_SIZE) return null;
+  const head = changetype<usize>(header);
+  if (
+    load<u8>(head, 0) != MAGIC_W ||
+    load<u8>(head, 1) != MAGIC_I ||
+    load<u8>(head, 2) != MAGIC_P ||
+    load<u8>(head, 3) != MAGIC_C
+  ) {
+    return null;
+  }
+  const type = <MessageType>load<u8>(head, 4);
+  const length = load<u32>(head, 5);
+  const payload = readExact(<i32>length);
+  if (payload.byteLength < <i32>length) return null;
+  return new Frame(type, payload);
+}
+
+function readExact(length: i32): ArrayBuffer {
+  const out = new ArrayBuffer(length);
+  let offset = 0;
+  while (offset < length) {
+    const chunk = readStdin(length - offset);
+    const size = chunk.byteLength;
+    if (!size) break;
+    memory.copy(
+      changetype<usize>(out) + offset,
+      changetype<usize>(chunk),
+      size,
+    );
+    offset += size;
+  }
+
+  if (offset == length) return out;
+
+  const partial = new ArrayBuffer(offset);
+  if (offset) {
+    memory.copy(changetype<usize>(partial), changetype<usize>(out), offset);
+  }
+  return partial;
+}
+
+function writeStdout(data: ArrayBuffer): void {
+  if (IS_BINDINGS) {
+    process_stdout_write(data);
+    return;
+  }
+  wasiWriteAll(data);
+}
+
+function readStdin(max: i32): ArrayBuffer {
+  if (max <= 0) return new ArrayBuffer(0);
+  if (IS_BINDINGS) {
+    return process_stdin_read(max);
+  }
+  return wasiRead(max);
+}
+
+function wasiWriteAll(data: ArrayBuffer): void {
+  const total = data.byteLength;
+  if (!total) return;
+
+  const iovec = new ArrayBuffer(<i32>IOV_SIZE);
+  const writtenBuf = new ArrayBuffer(<i32>U32_SIZE);
+  let offset: i32 = 0;
+  while (offset < total) {
+    const left = total - offset;
+    const ptr = changetype<usize>(data) + <usize>offset;
+    const iovPtr = changetype<usize>(iovec);
+    const writtenPtr = changetype<usize>(writtenBuf);
+    store<usize>(iovPtr, ptr, 0);
+    store<usize>(iovPtr, <usize>left, sizeof<usize>());
+    store<u32>(writtenPtr, 0, 0);
+    const errno = wasi_fd_write(1, iovPtr, 1, writtenPtr);
+    if (errno != 0) return;
+    const written = <i32>load<u32>(writtenPtr, 0);
+    if (written <= 0) return;
+    offset += written;
+  }
+}
+
+function wasiRead(max: i32): ArrayBuffer {
+  const out = new ArrayBuffer(max);
+  const iovec = new ArrayBuffer(<i32>IOV_SIZE);
+  const readBuf = new ArrayBuffer(<i32>U32_SIZE);
+  const iovPtr = changetype<usize>(iovec);
+  const readPtr = changetype<usize>(readBuf);
+
+  store<usize>(iovPtr, changetype<usize>(out), 0);
+  store<usize>(iovPtr, <usize>max, sizeof<usize>());
+  store<u32>(readPtr, 0, 0);
+
+  const errno = wasi_fd_read(0, iovPtr, 1, readPtr);
+  if (errno != 0) return new ArrayBuffer(0);
+
+  const size = <i32>load<u32>(readPtr, 0);
+  if (size <= 0) return new ArrayBuffer(0);
+  if (size == max) return out;
+
+  const partial = new ArrayBuffer(size);
+  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.js

@@ -1,82 +1,118 @@
-import { existsSync, readFileSync } from "fs";
+import { existsSync } from "fs";
 import { glob } from "glob";
 import chalk from "chalk";
 import { execSync } from "child_process";
 import * as path from "path";
-import { loadConfig } from "./util.js";
-const CONFIG_PATH = path.join(process.cwd(), "./as-test.config.json");
-const PKG_PATH = path.join(process.cwd(), "./package.json");
-export async function build() {
-    let config = loadConfig(CONFIG_PATH, true);
-    const ASCONFIG_PATH = path.join(process.cwd(), config.config);
-    if (config.config && config.config !== "none" && !existsSync(ASCONFIG_PATH)) {
-        console.log(`${chalk.bgMagentaBright(" WARN ")}${chalk.dim(":")} Could not locate asconfig.json file! If you do not want to provide a config, set "config": "none"`);
-    }
+import { getPkgRunner, loadConfig } from "./util.js";
+const DEFAULT_CONFIG_PATH = path.join(process.cwd(), "./as-test.config.json");
+export async function build(configPath = DEFAULT_CONFIG_PATH, selectors = []) {
+    const config = loadConfig(configPath, false);
     ensureDeps(config);
-    let pkgRunner = getPkgRunner();
-    const inputFiles = await glob(config.input);
-    let buildArgs = getBuildArgs(config);
+    const pkgRunner = getPkgRunner();
+    const inputPatterns = resolveInputPatterns(config.input, selectors);
+    const inputFiles = await glob(inputPatterns);
+    const buildArgs = getBuildArgs(config);
     for (const file of inputFiles) {
         let cmd = `${pkgRunner} asc ${file}${buildArgs}`;
         const outFile = `${config.outDir}/${file.slice(file.lastIndexOf("/") + 1).replace(".ts", ".wasm")}`;
         if (config.outDir) {
             cmd += " -o " + outFile;
         }
-        buildFile(cmd);
+        try {
+            buildFile(cmd);
+        }
+        catch (error) {
+            throw new Error(`Failed to build ${path.basename(file)} with ${getBuildStderr(error)}`);
+        }
+    }
+}
+function resolveInputPatterns(configured, selectors) {
+    const configuredInputs = Array.isArray(configured) ? configured : [configured];
+    if (!selectors.length)
+        return configuredInputs;
+    const patterns = new Set();
+    for (const selector of selectors) {
+        if (!selector)
+            continue;
+        if (isBareSuiteSelector(selector)) {
+            const base = stripSuiteSuffix(selector);
+            for (const configuredInput of configuredInputs) {
+                patterns.add(path.join(path.dirname(configuredInput), `${base}.spec.ts`));
+            }
+            continue;
+        }
+        patterns.add(selector);
     }
+    return [...patterns];
+}
+function isBareSuiteSelector(selector) {
+    return (!selector.includes("/") &&
+        !selector.includes("\\") &&
+        !/[*?[\]{}]/.test(selector));
+}
+function stripSuiteSuffix(selector) {
+    return selector.replace(/\.spec\.ts$/, "").replace(/\.ts$/, "");
 }
 function ensureDeps(config) {
-    const pkg = JSON.parse(readFileSync(PKG_PATH).toString());
     if (config.buildOptions.target == "wasi") {
         if (!existsSync("./node_modules/@assemblyscript/wasi-shim/asconfig.json")) {
             console.log(`${chalk.bgRed(" ERROR ")}${chalk.dim(":")} could not find @assemblyscript/wasi-shim! Add it to your dependencies to run with WASI!`);
             process.exit(1);
         }
-        if (pkg.dependencies &&
-            !Object.keys(pkg.dependencies).includes("@assemblyscript/wasi-shim") &&
-            pkg.devDependencies &&
-            !Object.keys(pkg.devDependencies).includes("@assemblyscript/wasi-shim") &&
-            pkg.peerDependencies &&
-            !Object.keys(pkg.peerDependencies).includes("@assemblyscript/wasi-shim") &&
-            existsSync("./node_modules/@assemblyscript/wasi-shim/asconfig.json")) {
-            console.log(`${chalk.bold.bgMagentaBright(" WARN ")}${chalk.dim(":")} @assemblyscript/wasi-shim is not included in project dependencies!"`);
-        }
     }
-}
-function getPkgRunner() {
-    switch (process.env.npm_config_user_agent) {
-        case "pnpm": {
-            return "pnpx";
-        }
-        case "yarn": {
-            return "yarn";
-        }
-        case "bun": {
-            return "bunx";
-        }
+    if (!hasJsonAsTransform()) {
+        console.log(`${chalk.bgRed(" ERROR ")}${chalk.dim(":")} could not find json-as. Install it to compile as-test suites.`);
+        process.exit(1);
     }
-    return "npx";
 }
 function buildFile(command) {
-    execSync(command, { stdio: "inherit" });
+    execSync(command, {
+        stdio: ["ignore", "pipe", "pipe"],
+        encoding: "utf8",
+    });
+}
+function getBuildStderr(error) {
+    const err = error;
+    const stderr = err?.stderr;
+    if (typeof stderr == "string") {
+        const trimmed = stderr.trim();
+        if (trimmed.length)
+            return trimmed;
+    }
+    else if (stderr instanceof Buffer) {
+        const trimmed = stderr.toString("utf8").trim();
+        if (trimmed.length)
+            return trimmed;
+    }
+    const message = typeof err?.message == "string" ? err.message.trim() : "";
+    return message || "unknown error";
 }
 function getBuildArgs(config) {
     let buildArgs = "";
-    buildArgs += " --transform as-test/transform --transform json-as/transform";
+    buildArgs += " --transform as-test/transform";
+    buildArgs += " --transform json-as/transform";
+    if (hasTryAsRuntime()) {
+        buildArgs += " --transform try-as/transform";
+    }
     if (config.config && config.config !== "none") {
         buildArgs += " --config " + config.config;
     }
+    if (hasTryAsRuntime()) {
+        buildArgs += " --use AS_TEST_TRY_AS=1";
+    }
     // Should also strip any bindings-enabling from asconfig
     if (config.buildOptions.target == "bindings") {
+        buildArgs += " --use AS_TEST_BINDINGS=1";
         buildArgs += " --bindings raw --exportRuntime --exportStart _start";
     }
     else if (config.buildOptions.target == "wasi") {
+        buildArgs += " --use AS_TEST_WASI=1";
         buildArgs +=
             " --config ./node_modules/@assemblyscript/wasi-shim/asconfig.json";
     }
     else {
-        console.log(`${chalk.bgRed(" ERROR ")}${chalk.dim(":")} could determine target in config! Set target to 'bindings' or 'wasi'`);
-        process.exit(0);
+        console.log(`${chalk.bgRed(" ERROR ")}${chalk.dim(":")} could not determine target in config! Set target to 'bindings' or 'wasi'`);
+        process.exit(1);
     }
     if (config.buildOptions.args.length &&
         config.buildOptions.args.find((v) => v.length > 0)) {
@@ -84,3 +120,12 @@ function getBuildArgs(config) {
     }
     return buildArgs;
 }
+function hasTryAsRuntime() {
+    return (existsSync(path.join(process.cwd(), "node_modules/try-as")) ||
+        existsSync(path.join(process.cwd(), "node_modules/try-as/package.json")));
+}
+function hasJsonAsTransform() {
+    return (existsSync(path.join(process.cwd(), "node_modules/json-as/transform.js")) ||
+        existsSync(path.join(process.cwd(), "node_modules/json-as/transform.ts")) ||
+        existsSync(path.join(process.cwd(), "node_modules/json-as/transform")));
+}