as-test 0.5.1 → 0.5.3

package/assembly/index.ts

@@ -8,20 +8,38 @@ import {
   __ALL_POINTS,
   CoverPoint,
 } from "as-test/assembly/coverage";
-import { JSON } from "json-as";
 import { Log } from "./src/log";
 import { sendFileEnd, sendFileStart, sendReport } from "./util/wipc";
+import { quote } from "./util/json";
 
 let entrySuites: Suite[] = [];
 
 // @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
+>();
+// @ts-ignore
 @global let suites: Suite[] = [];
 // @ts-ignore
 @global let depth: i32 = -1;
@@ -231,13 +249,63 @@ export function afterEach(callback: () => void): void {
  * @param {Function} oldFn - name of function to mock
  * @param {Function} newFn - the function to substitute it with
  */
-export function mockFn(oldFn: Function, newFn: Function): void {}
+export function mockFn<T extends Function, U extends Function>(
+  oldFn: T,
+  newFn: U,
+): void {}
+
+/**
+ * Restore references previously mocked with `mockFn`.
+ * This applies to calls that appear after `unmockFn` in source order.
+ */
+export function unmockFn<T extends Function>(oldFn: T): void {}
 
 export function mockImport<T extends Function>(oldFn: string, newFn: T): void {
   __mock_import.set(oldFn, newFn.index);
   // mocks.set(oldFn, new MockFn(oldFn, newFn).enable());
 }
 
+export function unmockImport(oldFn: string): void {
+  __mock_import.delete(oldFn);
+}
+
+/**
+ * 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.
+ */
+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);
+  }
+}
+
 /**
  * Class defining options that can be passed to the `run` function.
  *
@@ -303,7 +371,7 @@ export function run(options: RunOptions = new RunOptions()): void {
   const report = new FileReport();
   report.suites = entrySuites;
   report.coverage = collectCoverage();
-  sendReport(JSON.stringify(report));
+  sendReport(report.serialize());
 }
 
 function registerSuite(
@@ -328,18 +396,30 @@ function registerSuite(
   suites.push(suite);
 }
 
-
-@json
 class CoverageReport {
   total: i32 = 0;
   covered: i32 = 0;
   uncovered: i32 = 0;
   percent: f64 = 100.0;
   points: CoveragePointReport[] = [];
-}
 
+  serialize(): string {
+    return (
+      '{"total":' +
+      this.total.toString() +
+      ',"covered":' +
+      this.covered.toString() +
+      ',"uncovered":' +
+      this.uncovered.toString() +
+      ',"percent":' +
+      this.percent.toString() +
+      ',"points":' +
+      serializeCoveragePoints(this.points) +
+      "}"
+    );
+  }
+}
 
-@json
 class CoveragePointReport {
   hash: string = "";
   file: string = "";
@@ -347,13 +427,61 @@ class CoveragePointReport {
   column: i32 = 0;
   type: string = "";
   executed: bool = false;
-}
 
+  serialize(): string {
+    return (
+      '{"hash":' +
+      quote(this.hash) +
+      ',"file":' +
+      quote(this.file) +
+      ',"line":' +
+      this.line.toString() +
+      ',"column":' +
+      this.column.toString() +
+      ',"type":' +
+      quote(this.type) +
+      ',"executed":' +
+      (this.executed ? "true" : "false") +
+      "}"
+    );
+  }
+}
 
-@json
 class FileReport {
   suites: Suite[] = [];
   coverage: CoverageReport = new CoverageReport();
+
+  serialize(): string {
+    return (
+      '{"suites":' +
+      serializeSuites(this.suites) +
+      ',"coverage":' +
+      this.coverage.serialize() +
+      "}"
+    );
+  }
+}
+
+function serializeSuites(values: Suite[]): string {
+  if (!values.length) return "[]";
+  let out = "[";
+  for (let i = 0; i < values.length; i++) {
+    if (i) out += ",";
+    out += unchecked(values[i]).serialize();
+  }
+  out += "]";
+  return out;
+}
+
+function serializeCoveragePoints(values: CoveragePointReport[]): string {
+  if (!values.length) return "[]";
+  let out = "[";
+  for (let i = 0; i < values.length; i++) {
+    if (i) out += ",";
+    out += unchecked(values[i]).serialize();
+  }
+  out += "]";
+  return out;
 }
 
 function collectCoverage(): CoverageReport {
@@ -399,6 +527,46 @@ function snapshotKey(): string {
   return FILE + "::" + path + "::" + suite.tests.length.toString();
 }
 
+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 "";
+}
+
+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 class Result {
   public name: string;
   public arg1: i32;
@@ -420,18 +588,34 @@ export class Result {
     return out;
   }
   serialize(): string {
-    return JSON.stringify(this);
+    return (
+      '{"name":' +
+      quote(this.name) +
+      ',"arg1":' +
+      this.arg1.toString() +
+      ',"arg2":' +
+      this.arg2.toString() +
+      "}"
+    );
   }
 }
 
-
-@json
 export class Time {
   start: f64 = 0;
   end: f64 = 0;
   format(): string {
     return formatTime(this.end - this.start);
   }
+
+  serialize(): string {
+    return (
+      '{"start":' +
+      this.start.toString() +
+      ',"end":' +
+      this.end.toString() +
+      "}"
+    );
+  }
 }
 
 class Unit {

package/assembly/src/expectation.ts

@@ -1,6 +1,6 @@
 import { visualize } from "../util/helpers";
 import { Tests } from "./tests";
-import { JSON } from "json-as";
+import { quote, stringifyValue } from "../util/json";
 import {
   sendAssertionFailure,
   sendWarning,
@@ -9,41 +9,26 @@ import {
 
 let warnedToThrowDisabled = false;
 
-
-@json
 export class Expectation<T> extends Tests {
   public verdict: string = "none";
-  public right: JSON.Raw = JSON.Raw.from("");
-  public left: JSON.Raw = JSON.Raw.from("");
-
+  public right: string = "null";
+  public left: string = "null";
 
-  @omit
   private _left: T;
 
-
-  @omit
   // @ts-ignore
   private _right: u64 = 0;
 
-
-  @omit
   // @ts-ignore
   private _not: boolean = false;
 
-  @omit
   // @ts-ignore
   private _skip: boolean = false;
 
-
-  @omit
   private _message: string = "";
 
-
-  @omit
   private _snapshotKey: string = "";
 
-
-  @omit
   private _location: string = "";
 
   constructor(
@@ -79,8 +64,8 @@ export class Expectation<T> extends Tests {
     if (this._skip) {
       this.verdict = "skip";
       this.instr = instr;
-      this.left.set(left);
-      this.right.set(right);
+      this.left = left;
+      this.right = right;
       this.message = "";
       this._not = false;
       return;
@@ -88,8 +73,8 @@ export class Expectation<T> extends Tests {
     const isFail = this._not ? passed : !passed;
     this.verdict = isFail ? "fail" : "ok";
     this.instr = instr;
-    this.left.set(left);
-    this.right.set(right);
+    this.left = left;
+    this.right = right;
     this.message = isFail ? this._message : "";
     if (isFail) {
       sendAssertionFailure(this._snapshotKey, instr, left, right, this.message);
@@ -317,7 +302,8 @@ export class Expectation<T> extends Tests {
    * Tests if a string starts with the provided prefix.
    */
   toStartWith(value: string): void {
-    if (!isString<T>()) ERROR("toStartWith() can only be used on string types!");
+    if (!isString<T>())
+      ERROR("toStartWith() can only be used on string types!");
     // @ts-ignore
     const left = this._left as string;
     const passed = left.indexOf(value) == 0;
@@ -369,7 +355,7 @@ export class Expectation<T> extends Tests {
     let key = this._snapshotKey;
     if (name.length) key += "::" + name;
 
-    const actual = JSON.stringify<T>(this._left);
+    const actual = stringifyValue<T>(this._left);
     const res = snapshotAssert(key, actual);
     this._resolve(res.ok, "toMatchSnapshot", actual, res.expected);
   }
@@ -417,21 +403,21 @@ export class Expectation<T> extends Tests {
       passed = this._left === equals;
     } else {
       // Fallback for reference/value types where strict equality is not enough.
-      passed = JSON.stringify<T>(this._left) == JSON.stringify<T>(equals);
+      passed = stringifyValue<T>(this._left) == stringifyValue<T>(equals);
     }
 
     this._resolve(
       passed,
       "toBe",
-      JSON.stringify<T>(this._left),
-      JSON.stringify<T>(equals),
+      stringifyValue<T>(this._left),
+      stringifyValue<T>(equals),
     );
   }
 }
 
 function arrayEquals<T extends any[]>(a: T, b: T): boolean {
   if (a.length != b.length) return false;
-  return JSON.stringify(a) == JSON.stringify(b);
+  return stringifyValue(a) == stringifyValue(b);
 }
 
 function isTruthy<T>(value: T): bool {
@@ -455,5 +441,5 @@ function isTruthy<T>(value: T): bool {
 }
 
 function q(value: string): string {
-  return JSON.stringify<string>(value);
+  return quote(value);
 }

package/assembly/src/log.ts

@@ -1,5 +1,5 @@
+import { quote } from "../util/json";
 
-@json
 export class Log {
   public order: i32 = 0;
   public depth: i32 = 0;
@@ -8,4 +8,16 @@ export class Log {
     this.text = text;
   }
   display(): void {}
+
+  serialize(): string {
+    return (
+      '{"order":' +
+      this.order.toString() +
+      ',"depth":' +
+      this.depth.toString() +
+      ',"text":' +
+      quote(this.text) +
+      "}"
+    );
+  }
 }

package/assembly/src/suite.ts

@@ -4,12 +4,9 @@ import { Tests } from "./tests";
 import { Log } from "./log";
 import { after_each_callback, before_each_callback } from "..";
 import { sendSuiteEnd, sendSuiteStart } from "../util/wipc";
+import { quote } from "../util/json";
 
-
-@json
 export class Suite {
-
-  @omitif((self: Suite) => self.depth > 0)
   public file: string = "unknown";
   public order: i32 = 0;
   public time: Time = new Time();
@@ -20,8 +17,6 @@ export class Suite {
   public logs: Log[] = [];
   public kind: string;
 
-
-  @omit
   public parent: Suite | null = null;
 
   public verdict: string = "none";
@@ -59,9 +54,7 @@ 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";
     const isTestCase =
       this.kind == "test" ||
       this.kind == "it" ||
@@ -134,4 +127,55 @@ export class Suite {
       this.verdict,
     );
   }
+
+  serialize(): string {
+    let out = "{";
+    if (this.depth <= 0) {
+      out += '"file":' + quote(this.file) + ",";
+    }
+    out += '"order":' + this.order.toString();
+    out += ',"time":' + this.time.serialize();
+    out += ',"description":' + quote(this.description);
+    out += ',"depth":' + this.depth.toString();
+    out += ',"suites":' + serializeSuites(this.suites);
+    out += ',"tests":' + serializeTests(this.tests);
+    out += ',"logs":' + serializeLogs(this.logs);
+    out += ',"kind":' + quote(this.kind);
+    out += ',"verdict":' + quote(this.verdict);
+    out += "}";
+    return out;
+  }
+}
+
+function serializeSuites(values: Suite[]): string {
+  if (!values.length) return "[]";
+  let out = "[";
+  for (let i = 0; i < values.length; i++) {
+    if (i) out += ",";
+    out += unchecked(values[i]).serialize();
+  }
+  out += "]";
+  return out;
+}
+
+function serializeTests(values: Tests[]): string {
+  if (!values.length) return "[]";
+  let out = "[";
+  for (let i = 0; i < values.length; i++) {
+    if (i) out += ",";
+    out += unchecked(values[i]).serialize();
+  }
+  out += "]";
+  return out;
+}
+
+function serializeLogs(values: Log[]): string {
+  if (!values.length) return "[]";
+  let out = "[";
+  for (let i = 0; i < values.length; i++) {
+    if (i) out += ",";
+    out += unchecked(values[i]).serialize();
+  }
+  out += "]";
+  return out;
 }

package/assembly/src/tests.ts

@@ -1,14 +1,34 @@
-import { JSON } from "json-as";
+import { quote, rawOrNull } from "../util/json";
 
-
-@json
 export class Tests {
   public order: i32 = 0;
   public type: string = "";
   public verdict: string = "none";
-  public left: JSON.Raw = JSON.Raw.from("");
-  public right: JSON.Raw = JSON.Raw.from("");
+  public left: string = "null";
+  public right: string = "null";
   public instr: string = "";
   public message: string = "";
   public location: string = "";
+
+  serialize(): string {
+    return (
+      '{"order":' +
+      this.order.toString() +
+      ',"type":' +
+      quote(this.type) +
+      ',"verdict":' +
+      quote(this.verdict) +
+      ',"left":' +
+      rawOrNull(this.left) +
+      ',"right":' +
+      rawOrNull(this.right) +
+      ',"instr":' +
+      quote(this.instr) +
+      ',"message":' +
+      quote(this.message) +
+      ',"location":' +
+      quote(this.location) +
+      "}"
+    );
+  }
 }

package/assembly/util/helpers.ts

@@ -1,5 +1,4 @@
 import { rainbow } from "as-rainbow";
-import { JSON } from "json-as";
 
 export function visualize<T>(value: T): string {
   if (isNullable<T>() && changetype<usize>(value) == <usize>0) {

package/assembly/util/json.ts

@@ -0,0 +1,78 @@
+import { stringify } from "as-console/stringify";
+
+export function quote(value: string): string {
+  return '"' + escape(value) + '"';
+}
+
+export function rawOrNull(value: string): string {
+  return value.length ? value : "null";
+}
+
+export function stringifyValue<T>(value: T): string {
+  if (isNullable<T>() && changetype<usize>(value) == <usize>0) {
+    return "null";
+  }
+
+  if (isBoolean<T>()) {
+    return (value as bool) ? "true" : "false";
+  }
+
+  if (isInteger<T>() || isFloat<T>()) {
+    // @ts-expect-error: type
+    return value.toString();
+  }
+
+  if (isString<T>()) {
+    return quote(value as string);
+  }
+
+  if (isArray<T>()) {
+    // @ts-expect-error: type
+    return stringifyArray<valueof<T>>(value as valueof<T>[]);
+  }
+
+  const formatted = stringify<T>(value);
+  if (formatted != "none") {
+    return quote(formatted);
+  }
+
+  return quote(nameof<T>());
+}
+
+function stringifyArray<T>(values: T[]): string {
+  if (!values.length) return "[]";
+
+  let out = "[";
+  for (let i = 0; i < values.length; i++) {
+    if (i) out += ",";
+    out += stringifyValue<T>(unchecked(values[i]));
+  }
+  out += "]";
+  return out;
+}
+
+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 if (ch < 32) {
+      out += "\\u00";
+      const hex = ch.toString(16);
+      if (hex.length < 2) out += "0";
+      out += hex;
+    } else {
+      out += value.charAt(i);
+    }
+  }
+  return out;
+}