as-test 1.0.0 → 1.0.3

package/as-test.config.schema.json

@@ -99,24 +99,55 @@
           "properties": {
             "enabled": {
               "type": "boolean",
-              "default": true
+              "default": false
             },
             "includeSpecs": {
               "type": "boolean",
               "description": "Include *.spec.ts files in coverage collection.",
               "default": false
+            },
+            "include": {
+              "type": "array",
+              "description": "Only include matching source files in coverage reports when this list is not empty.",
+              "items": {
+                "type": "string"
+              },
+              "default": []
+            },
+            "exclude": {
+              "type": "array",
+              "description": "Exclude matching source files from coverage reports.",
+              "items": {
+                "type": "string"
+              },
+              "default": []
             }
           }
         }
       ],
-      "default": true
+      "default": false
     },
     "env": {
-      "type": "object",
-      "description": "Environment variables injected when building/running.",
-      "additionalProperties": {
-        "type": "string"
-      },
+      "description": "Environment variables injected when building/running. Accepts a .env file path, an array of KEY=value strings, or an object map.",
+      "oneOf": [
+        {
+          "type": "string",
+          "description": "Path to a .env file, resolved relative to the config file."
+        },
+        {
+          "type": "array",
+          "description": "Inline environment entries in KEY=value form.",
+          "items": {
+            "type": "string"
+          }
+        },
+        {
+          "type": "object",
+          "additionalProperties": {
+            "type": "string"
+          }
+        }
+      ],
       "default": {}
     },
     "buildOptions": {
@@ -137,14 +168,91 @@
         },
         "target": {
           "type": "string",
-          "enum": ["wasi", "bindings"],
+          "enum": ["wasi", "bindings", "web"],
           "default": "wasi"
+        },
+        "env": {
+          "description": "Build-only environment overrides. Merges with top-level env and mode env.",
+          "oneOf": [
+            {
+              "type": "string"
+            },
+            {
+              "type": "array",
+              "items": {
+                "type": "string"
+              }
+            },
+            {
+              "type": "object",
+              "additionalProperties": {
+                "type": "string"
+              }
+            }
+          ],
+          "default": {}
         }
       },
       "default": {
         "cmd": "",
         "args": [],
-        "target": "wasi"
+        "target": "wasi",
+        "env": {}
+      }
+    },
+    "fuzz": {
+      "type": "object",
+      "additionalProperties": false,
+      "description": "Fuzz target configuration used by `ast fuzz` and `ast test --fuzz`.",
+      "properties": {
+        "input": {
+          "type": "array",
+          "description": "Glob patterns for fuzz target files.",
+          "items": {
+            "type": "string"
+          },
+          "default": ["./assembly/__fuzz__/*.fuzz.ts"]
+        },
+        "runs": {
+          "type": "number",
+          "description": "Number of fuzz iterations per target.",
+          "default": 1000
+        },
+        "seed": {
+          "type": "number",
+          "description": "Base deterministic seed for input mutation.",
+          "default": 1337
+        },
+        "maxInputBytes": {
+          "type": "number",
+          "description": "Maximum generated input size in bytes.",
+          "default": 4096
+        },
+        "target": {
+          "type": "string",
+          "enum": ["bindings"],
+          "description": "Fuzz builds currently require bindings output.",
+          "default": "bindings"
+        },
+        "corpusDir": {
+          "type": "string",
+          "description": "Directory containing per-target seed corpus files.",
+          "default": "./.as-test/fuzz/corpus"
+        },
+        "crashDir": {
+          "type": "string",
+          "description": "Directory where crashing inputs and metadata are written.",
+          "default": "./.as-test/crashes"
+        }
+      },
+      "default": {
+        "input": ["./assembly/__fuzz__/*.fuzz.ts"],
+        "runs": 1000,
+        "seed": 1337,
+        "maxInputBytes": 4096,
+        "target": "bindings",
+        "corpusDir": "./.as-test/fuzz/corpus",
+        "crashDir": "./.as-test/crashes"
       }
     },
     "modes": {
@@ -210,7 +318,27 @@
               },
               "target": {
                 "type": "string",
-                "enum": ["wasi", "bindings"]
+                "enum": ["wasi", "bindings", "web"]
+              },
+              "env": {
+                "description": "Mode-specific build environment overrides.",
+                "oneOf": [
+                  {
+                    "type": "string"
+                  },
+                  {
+                    "type": "array",
+                    "items": {
+                      "type": "string"
+                    }
+                  },
+                  {
+                    "type": "object",
+                    "additionalProperties": {
+                      "type": "string"
+                    }
+                  }
+                ]
               }
             }
           },
@@ -225,6 +353,10 @@
                   "cmd": {
                     "type": "string",
                     "description": "Mode-specific runtime command."
+                  },
+                  "browser": {
+                    "type": "string",
+                    "description": "Mode-specific browser for web targets. Use chrome, chromium, firefox, webkit, or an executable path."
                   }
                 }
               },
@@ -257,15 +389,48 @@
                     "required": ["name"]
                   }
                 ]
+              },
+              "env": {
+                "description": "Mode-specific runtime environment overrides.",
+                "oneOf": [
+                  {
+                    "type": "string"
+                  },
+                  {
+                    "type": "array",
+                    "items": {
+                      "type": "string"
+                    }
+                  },
+                  {
+                    "type": "object",
+                    "additionalProperties": {
+                      "type": "string"
+                    }
+                  }
+                ]
               }
             }
           },
           "env": {
-            "type": "object",
-            "description": "Environment variables injected when building/running this mode.",
-            "additionalProperties": {
-              "type": "string"
-            }
+            "description": "Mode-wide environment variables merged before build/run-specific env.",
+            "oneOf": [
+              {
+                "type": "string"
+              },
+              {
+                "type": "array",
+                "items": {
+                  "type": "string"
+                }
+              },
+              {
+                "type": "object",
+                "additionalProperties": {
+                  "type": "string"
+                }
+              }
+            ]
           }
         }
       },
@@ -283,10 +448,16 @@
               "type": "string",
               "description": "Runtime command; supports placeholders like <file> and <name>.",
               "default": "node ./.as-test/runners/default.wasi.js <file>"
+            },
+            "browser": {
+              "type": "string",
+              "description": "Browser for web targets. Use chrome, chromium, firefox, webkit, or an executable path.",
+              "default": ""
             }
           },
           "default": {
-            "cmd": "node ./.as-test/runners/default.wasi.js <file>"
+            "cmd": "node ./.as-test/runners/default.wasi.js <file>",
+            "browser": ""
           }
         },
         "reporter": {
@@ -324,13 +495,35 @@
             }
           ],
           "default": ""
+        },
+        "env": {
+          "description": "Run-only environment overrides. Merges with top-level env and mode env.",
+          "oneOf": [
+            {
+              "type": "string"
+            },
+            {
+              "type": "array",
+              "items": {
+                "type": "string"
+              }
+            },
+            {
+              "type": "object",
+              "additionalProperties": {
+                "type": "string"
+              }
+            }
+          ],
+          "default": {}
         }
       },
       "default": {
         "runtime": {
           "cmd": "node ./.as-test/runners/default.wasi.js <file>"
         },
-        "reporter": ""
+        "reporter": "",
+        "env": {}
       }
     }
   }

package/assembly/__fuzz__/array.fuzz.ts

@@ -0,0 +1,10 @@
+import { expect, fuzz, FuzzSeed } from "as-test";
+
+fuzz("index windows stay ordered", (start: i32, end: i32): bool => {
+  expect(start <= end).toBe(true);
+  return end - start <= 64;
+}).generate((seed: FuzzSeed, run: (start: i32, end: i32) => bool): void => {
+  const start = seed.i32({ min: 0, max: 64 });
+  const width = seed.i32({ min: 0, max: 64 });
+  run(start, start + width);
+});

package/assembly/__fuzz__/bytes.fuzz.ts

@@ -0,0 +1,8 @@
+import { expect, fuzz, FuzzSeed } from "..";
+
+fuzz("byte-sized integers stay within range", (value: i32): bool => {
+  expect(value >= 0).toBe(true);
+  return value <= 255;
+}).generate((seed: FuzzSeed, run: (value: i32) => bool): void => {
+  run(seed.i32({ min: 0, max: 255 }));
+});

package/assembly/__fuzz__/math.fuzz.ts

@@ -0,0 +1,9 @@
+import { expect, fuzz, FuzzSeed } from "as-test";
+
+fuzz("bounded integer addition", (left: i32, right: i32): bool => {
+  const sum = left + right;
+  expect(sum - right).toBe(left);
+  return sum >= i32.MIN_VALUE; // Fails if an expectation fails or false is returned
+}).generate((seed: FuzzSeed, run: (left: i32, right: i32) => bool): void => {
+  run(seed.i32({ min: -1000, max: 1000 }), seed.i32({ min: -1000, max: 1000 }));
+});

package/assembly/__fuzz__/string.fuzz.ts

@@ -0,0 +1,21 @@
+import { expect, fuzz, FuzzSeed } from "as-test";
+
+fuzz(
+  "ascii strings survive concatenation boundaries",
+  (input: string): bool => {
+    const wrapped = "[" + input + "]";
+    const restored = wrapped.substr(1, input.length);
+
+    expect(restored).toBe(input);
+    return input.length <= 40;
+  },
+).generate((seed: FuzzSeed, run: (input: string) => bool): void => {
+  run(
+    seed.string({
+      charset: "ascii",
+      min: 0,
+      max: 40,
+      exclude: [0x00, 0x0a, 0x0d],
+    }),
+  );
+});

package/assembly/index.ts

@@ -9,32 +9,48 @@ import {
   CoverPoint,
 } from "as-test/assembly/coverage";
 import { Log } from "./src/log";
-import { sendFileEnd, sendFileStart, sendReport } from "./util/wipc";
+import {
+  requestFuzzConfig as requestHostFuzzConfig,
+  sendFileEnd,
+  sendFileStart,
+  sendReport,
+} from "./util/wipc";
 import { quote } from "./util/json";
+import {
+  createFuzzer,
+  FuzzerBase,
+  FuzzerResult,
+  prepareFuzzIteration,
+} from "./src/fuzz";
+export {
+  ArrayOptions,
+  BytesOptions,
+  FloatOptions,
+  Fuzzer0,
+  Fuzzer1,
+  Fuzzer2,
+  Fuzzer3,
+  FuzzerBase,
+  FuzzerResult,
+  FuzzSeed,
+  IntegerOptions,
+  StringOptions,
+} from "./src/fuzz";
+export { __as_test_deep_equal } from "./src/expectation";
+export { __as_test_json_value } from "./util/json";
 
 let entrySuites: Suite[] = [];
+let entryFuzzers: FuzzerBase[] = [];
 
 // @ts-ignore
 const FILE = isDefined(ENTRY_FILE) ? ENTRY_FILE : "unknown";
 
-class ImportSnapshot {
-  hasValue: bool = false;
-  value: u32 = 0;
-}
-
-const DEFAULT_IMPORT_SNAPSHOT_VERSION = "default";
-
 // Globals
 // @ts-ignore
 @global let __mock_global: Map<string, u32> = new Map<string, u32>();
 // @ts-ignore
 @global let __mock_import: Map<string, u32> = new Map<string, u32>();
 // @ts-ignore
-@global let __mock_import_snapshots: Map<string, ImportSnapshot> = new Map<
-  string,
-  ImportSnapshot
->();
-// @ts-ignore
 @global let __mock_import_target_by_index: Map<u32, string> = new Map<
   u32,
   string
@@ -108,6 +124,27 @@ export function it(description: string, callback: () => void): void {
   registerSuite(description, callback, "it");
 }
 
+/**
+ * Creates a focused test case.
+ */
+export function only(description: string, callback: () => void): void {
+  registerSuite(description, callback, "only");
+}
+
+/**
+ * Creates a skipped focused test case.
+ */
+export function xonly(description: string, callback: () => void): void {
+  registerSuite(description, callback, "xonly");
+}
+
+/**
+ * Creates a todo test case placeholder.
+ */
+export function todo(description: string): void {
+  registerSuite(description, (): void => {}, "todo");
+}
+
 /**
  * Creates a skipped test group.
  */
@@ -129,6 +166,24 @@ export function xit(description: string, callback: () => void): void {
   registerSuite(description, callback, "xit");
 }
 
+export function fuzz<T extends Function>(
+  description: string,
+  callback: T,
+): FuzzerBase {
+  const entry = createFuzzer(description, callback);
+  entryFuzzers.push(entry);
+  return entry;
+}
+
+export function xfuzz<T extends Function>(
+  description: string,
+  callback: T,
+): FuzzerBase {
+  const entry = createFuzzer(description, callback, true);
+  entryFuzzers.push(entry);
+  return entry;
+}
+
 /**
  * Creates an expectation object for making assertions within a test case.
  *
@@ -270,40 +325,12 @@ export function unmockImport(oldFn: string): void {
 }
 
 /**
- * Save a single import mock value for the given version.
- *
- * Accepts either:
- * - `snapshotImport(importOrPath, version)`
- * - `snapshotImport(importOrPath, () => { ... })` (uses default version)
- *
- * `imp` accepts either a string import path (e.g. "mock.foo") or the imported function.
+ * Capture the current return value of a zero-arg callback and return a new function
+ * that always returns the captured value.
  */
-export function snapshotImport<T, V>(imp: T, versionOrCapture: V): void {
-  const importKey = resolveImportKey<T>(imp);
-  if (isFunction<V>(versionOrCapture)) {
-    // @ts-ignore
-    versionOrCapture();
-    saveImportSnapshot(importKey, DEFAULT_IMPORT_SNAPSHOT_VERSION);
-    return;
-  }
-  saveImportSnapshot(importKey, versionKey<V>(versionOrCapture));
-}
-
-/**
- * Restore a single import mock value for the given version.
- *
- * Accepts either a string import path (e.g. "mock.foo") or the imported function.
- */
-export function restoreImport<T, V>(imp: T, version: V): void {
-  const importKey = resolveImportKey<T>(imp);
-  const snapshotKey = importSnapshotKey(importKey, versionKey<V>(version));
-  if (!__mock_import_snapshots.has(snapshotKey)) return;
-  const snapshot = __mock_import_snapshots.get(snapshotKey);
-  if (snapshot.hasValue) {
-    __mock_import.set(importKey, snapshot.value);
-  } else {
-    __mock_import.delete(importKey);
-  }
+export function snapshotFn<T>(callback: () => T): () => T {
+  const value = callback();
+  return (): T => value;
 }
 
 /**
@@ -339,9 +366,15 @@ class RunOptions {
  * ```
  */
 export function run(options: RunOptions = new RunOptions()): void {
+  // @ts-ignore
+  if (isDefined(AS_TEST_FUZZ)) {
+    runFuzzers();
+    return;
+  }
   __test_options = options;
   const time = new Time();
   let fileVerdict = "none";
+  const hasTopLevelOnly = containsOnlySuites(entrySuites);
   sendFileStart(FILE);
   time.start = performance.now();
   for (let i = 0; i < entrySuites.length; i++) {
@@ -353,7 +386,11 @@ export function run(options: RunOptions = new RunOptions()): void {
     depth = -1;
     current_suite = null;
 
-    suite.run();
+    if (hasTopLevelOnly && suite.kind != "only") {
+      suite.skip();
+    } else {
+      suite.run();
+    }
     if (suite.verdict == "fail") {
       fileVerdict = "fail";
     } else if (fileVerdict != "fail" && suite.verdict == "ok") {
@@ -374,6 +411,53 @@ export function run(options: RunOptions = new RunOptions()): void {
   sendReport(report.serialize());
 }
 
+function containsOnlySuites(values: Suite[]): bool {
+  for (let i = 0; i < values.length; i++) {
+    if (unchecked(values[i]).kind == "only") return true;
+  }
+  return false;
+}
+
+class FuzzConfig {
+  runs: i32 = 1000;
+  seed: u64 = 1337;
+}
+
+class FuzzReport {
+  fuzzers: FuzzerResult[] = [];
+
+  serialize(): string {
+    let out = '{"fuzzers":[';
+    for (let i = 0; i < this.fuzzers.length; i++) {
+      if (i) out += ",";
+      out += unchecked(this.fuzzers[i]).serialize();
+    }
+    out += "]}";
+    return out;
+  }
+}
+
+function runFuzzers(): void {
+  __test_options = new RunOptions();
+  const config = requestFuzzConfig();
+  const report = new FuzzReport();
+  for (let i = 0; i < entryFuzzers.length; i++) {
+    const fuzzer = unchecked(entryFuzzers[i]);
+    prepareFuzzIteration();
+    const result = fuzzer.run(config.seed, config.runs);
+    report.fuzzers.push(result);
+  }
+  sendReport(report.serialize());
+}
+
+function requestFuzzConfig(): FuzzConfig {
+  const out = new FuzzConfig();
+  const reply = requestHostFuzzConfig();
+  out.runs = reply.runs;
+  out.seed = reply.seed;
+  return out;
+}
+
 function registerSuite(
   description: string,
   callback: () => void,
@@ -515,7 +599,7 @@ function toCoveragePointReport(point: CoverPoint): CoveragePointReport {
 }
 
 function snapshotKey(): string {
-  if (!current_suite) return FILE + "::global::0";
+  if (!current_suite) return FILE + "::global";
   const suite = current_suite!;
   const parts = new Array<string>();
   let cursor: Suite | null = suite;
@@ -523,48 +607,19 @@ function snapshotKey(): string {
     parts.unshift(cursor.description);
     cursor = cursor.parent;
   }
-  const path = parts.join(" > ");
-  return FILE + "::" + path + "::" + suite.tests.length.toString();
+  return FILE + "::" + parts.join(" > ");
 }
 
-function resolveImportKey<T>(imp: T): string {
-  if (isString<T>()) {
-    // @ts-ignore
-    return imp as string;
-  }
-  // @ts-ignore
-  const index = imp.index as u32;
-  if (__mock_import_target_by_index.has(index)) {
-    return __mock_import_target_by_index.get(index);
-  }
-  return index.toString();
-}
-
-function importSnapshotKey(importKey: string, version: string): string {
-  return importKey + "::" + version;
-}
-
-function versionKey<V>(version: V): string {
-  if (isString<V>()) {
-    // @ts-ignore
-    return version as string;
-  }
-  if (isInteger<V>()) {
-    // @ts-ignore
-    return (<i64>version).toString();
-  }
-  ERROR("snapshot/restore version must be string or integer");
-  return "";
+export function nextUnnamedSnapshotKey(baseKey: string): string {
+  if (!current_suite) return baseKey;
+  const suite = current_suite!;
+  suite.snapshotCount++;
+  if (suite.snapshotCount <= 1) return baseKey;
+  return baseKey + " #" + suite.snapshotCount.toString();
 }
 
-function saveImportSnapshot(importKey: string, version: string): void {
-  const snapshotKey = importSnapshotKey(importKey, version);
-  const snapshot = new ImportSnapshot();
-  if (__mock_import.has(importKey)) {
-    snapshot.hasValue = true;
-    snapshot.value = __mock_import.get(importKey);
-  }
-  __mock_import_snapshots.set(snapshotKey, snapshot);
+export function namedSnapshotKey(baseKey: string, name: string): string {
+  return baseKey + " [" + name + "]";
 }
 
 export class Result {