as-test 0.2.1 → 0.3.0

package/assembly/src/expectation.ts

@@ -1,19 +1,19 @@
-import { rainbow } from "as-rainbow";
-import { diff, visualize } from "../util/helpers";
-import { Node } from "./node";
-import { Verdict, after_each_callback, before_each_callback } from "..";
-
-export class Expectation<T> extends Node {
-  public verdict: Verdict = Verdict.Unreachable;
-  private left: T;
-  private _left: string | null = null;
-  private right: u64 = 0;
-  private _right: string | null = null;
+import { visualize } from "../util/helpers";
+import { Tests } from "./tests";
+import { after_each_callback, before_each_callback } from "..";
+
+
+@json
+export class Expectation<T> extends Tests {
+  public verdict: string = "none";
+  private _left: T;
+  // @ts-ignore
+  private _right: u64 = 0;
+  // @ts-ignore
   private _not: boolean = false;
-  private op: string = "=";
   constructor(left: T) {
     super();
-    this.left = left;
+    this._left = left;
   }
   get not(): Expectation<T> {
     this._not = true;
@@ -26,14 +26,17 @@ export class Expectation<T> extends Node {
    */
   toBeNull(): void {
     this.verdict =
-      isNullable<T>() && changetype<usize>(this.left)
-        ? Verdict.Ok
-        : Verdict.Fail;
+      isNullable<T>() && changetype<usize>(this._left) ? "ok" : "fail";
 
     // @ts-ignore
-    store<T>(changetype<usize>(this), null, offsetof<Expectation<T>>("right"));
+    store<T>(changetype<usize>(this), null, offsetof<Expectation<T>>("_right"));
+
+    this.instr = "toBeNull";
 
-    this.op = "=";
+    this.left = visualize<T>(this._left);
+    this.right = visualize<T>(
+      load<T>(changetype<usize>(this), offsetof<Expectation<T>>("_right")),
+    );
 
     // @ts-ignore
     if (after_each_callback) after_each_callback();
@@ -50,10 +53,19 @@ export class Expectation<T> extends Node {
     if (!isInteger<T>() && !isFloat<T>())
       ERROR("toBeGreaterThan() can only be used on number types!");
 
-    this.verdict = this.left > value ? Verdict.Ok : Verdict.Fail;
-    store<T>(changetype<usize>(this), value, offsetof<Expectation<T>>("right"));
+    this.verdict = this._left > value ? "ok" : "fail";
+    store<T>(
+      changetype<usize>(this),
+      value,
+      offsetof<Expectation<T>>("_right"),
+    );
 
-    this.op = ">";
+    this.instr = "toBeGreaterThan";
+
+    this.left = visualize<T>(this._left);
+    this.right = visualize<T>(
+      load<T>(changetype<usize>(this), offsetof<Expectation<T>>("_right")),
+    );
 
     // @ts-ignore
     if (after_each_callback) after_each_callback();
@@ -70,10 +82,19 @@ export class Expectation<T> extends Node {
     if (!isInteger<T>() && !isFloat<T>())
       ERROR("toBeGreaterOrEqualTo() can only be used on number types!");
 
-    this.verdict = this.left >= value ? Verdict.Ok : Verdict.Fail;
-    store<T>(changetype<usize>(this), value, offsetof<Expectation<T>>("right"));
+    this.verdict = this._left >= value ? "ok" : "fail";
+    store<T>(
+      changetype<usize>(this),
+      value,
+      offsetof<Expectation<T>>("_right"),
+    );
 
-    this.op = ">=";
+    this.instr = "toBeGreaterThanOrEqualTo";
+
+    this.left = visualize<T>(this._left);
+    this.right = visualize<T>(
+      load<T>(changetype<usize>(this), offsetof<Expectation<T>>("_right")),
+    );
 
     // @ts-ignore
     if (after_each_callback) after_each_callback();
@@ -90,10 +111,19 @@ export class Expectation<T> extends Node {
     if (!isInteger<T>() && !isFloat<T>())
       ERROR("toBeLessThan() can only be used on number types!");
 
-    this.verdict = this.left < value ? Verdict.Ok : Verdict.Fail;
-    store<T>(changetype<usize>(this), value, offsetof<Expectation<T>>("right"));
+    this.verdict = this._left < value ? "ok" : "fail";
+    store<T>(
+      changetype<usize>(this),
+      value,
+      offsetof<Expectation<T>>("_right"),
+    );
+
+    this.instr = "toBeLessThan";
 
-    this.op = "<";
+    this.left = visualize<T>(this._left);
+    this.right = visualize<T>(
+      load<T>(changetype<usize>(this), offsetof<Expectation<T>>("_right")),
+    );
 
     // @ts-ignore
     if (after_each_callback) after_each_callback();
@@ -110,10 +140,19 @@ export class Expectation<T> extends Node {
     if (!isInteger<T>() && !isFloat<T>())
       ERROR("toBeLessThanOrEqualTo() can only be used on number types!");
 
-    this.verdict = this.left <= value ? Verdict.Ok : Verdict.Fail;
-    store<T>(changetype<usize>(this), value, offsetof<Expectation<T>>("right"));
+    this.verdict = this._left <= value ? "ok" : "fail";
+    store<T>(
+      changetype<usize>(this),
+      value,
+      offsetof<Expectation<T>>("_right"),
+    );
+
+    this.instr = "toBeLessThanOrEqualTo";
 
-    this.op = "<=";
+    this.left = visualize<T>(this._left);
+    this.right = visualize<T>(
+      load<T>(changetype<usize>(this), offsetof<Expectation<T>>("_right")),
+    );
 
     // @ts-ignore
     if (after_each_callback) after_each_callback();
@@ -126,12 +165,12 @@ export class Expectation<T> extends Node {
    * @returns - void
    */
   toBeString(): void {
-    this.verdict = isString<T>() ? Verdict.Ok : Verdict.Fail;
+    this.verdict = isString<T>() ? "ok" : "fail";
 
-    this._left = nameof<T>();
-    this._right = "string";
+    this.left = nameof<T>();
+    this.right = "string";
 
-    this.op = "type";
+    this.instr = "toBeString";
 
     // @ts-ignore
     if (after_each_callback) after_each_callback();
@@ -144,12 +183,12 @@ export class Expectation<T> extends Node {
    * @returns - void
    */
   toBeBoolean(): void {
-    this.verdict = isBoolean<T>() ? Verdict.Ok : Verdict.Fail;
+    this.verdict = isBoolean<T>() ? "ok" : "fail";
 
-    this._left = nameof<T>();
-    this._right = "boolean";
+    this.left = nameof<T>();
+    this.right = "boolean";
 
-    this.op = "type";
+    this.instr = "toBeBoolean";
 
     // @ts-ignore
     if (after_each_callback) after_each_callback();
@@ -162,12 +201,12 @@ export class Expectation<T> extends Node {
    * @returns - void
    */
   toBeArray(): void {
-    this.verdict = isArray<T>() ? Verdict.Ok : Verdict.Fail;
+    this.verdict = isArray<T>() ? "ok" : "fail";
 
-    this._left = nameof<T>();
-    this._right = "Array<any>";
+    this.left = nameof<T>();
+    this.right = "Array<any>";
 
-    this.op = "type";
+    this.instr = "toBeArray";
 
     // @ts-ignore
     if (after_each_callback) after_each_callback();
@@ -180,12 +219,12 @@ export class Expectation<T> extends Node {
    * @returns - void
    */
   toBeNumber(): void {
-    this.verdict = isFloat<T>() || isInteger<T>() ? Verdict.Ok : Verdict.Fail;
+    this.verdict = isFloat<T>() || isInteger<T>() ? "ok" : "fail";
 
-    this._left = nameof<T>();
-    this._right = "number";
+    this.left = nameof<T>();
+    this.right = "number";
 
-    this.op = "type";
+    this.instr = "toBeNumber";
 
     // @ts-ignore
     if (after_each_callback) after_each_callback();
@@ -198,12 +237,12 @@ export class Expectation<T> extends Node {
    * @returns - void
    */
   toBeInteger(): void {
-    this.verdict = isInteger<T>() ? Verdict.Ok : Verdict.Fail;
+    this.verdict = isInteger<T>() ? "ok" : "fail";
 
-    this._left = nameof<T>();
-    this._right = "float";
+    this.left = nameof<T>();
+    this.right = "float";
 
-    this.op = "type";
+    this.instr = "toBeInteger";
 
     // @ts-ignore
     if (after_each_callback) after_each_callback();
@@ -216,12 +255,12 @@ export class Expectation<T> extends Node {
    * @returns - void
    */
   toBeFloat(): void {
-    this.verdict = isFloat<T>() ? Verdict.Ok : Verdict.Fail;
+    this.verdict = isFloat<T>() ? "ok" : "fail";
 
-    this._left = nameof<T>();
-    this._right = "integer";
+    this.left = nameof<T>();
+    this.right = "integer";
 
-    this.op = "type";
+    this.instr = "toBeFloat";
 
     // @ts-ignore
     if (after_each_callback) after_each_callback();
@@ -234,16 +273,14 @@ export class Expectation<T> extends Node {
    * @returns - void
    */
   toBeFinite(): void {
-    // @ts-ignore
     this.verdict =
-      (isFloat<T>() || isInteger<T>()) && isFinite(this.left)
-        ? Verdict.Ok
-        : Verdict.Fail;
+      // @ts-ignore
+      (isFloat<T>() || isInteger<T>()) && isFinite(this._left) ? "ok" : "fail";
 
-    this._left = "Infinity";
-    this._right = "Finite";
+    this.left = "Infinity";
+    this.right = "Finite";
 
-    this.op = "=";
+    this.instr = "toBeFinite";
 
     // @ts-ignore
     if (after_each_callback) after_each_callback();
@@ -258,15 +295,15 @@ export class Expectation<T> extends Node {
    * @returns - void
    */
   toHaveLength(value: i32): void {
-    // @ts-ignore
     this.verdict =
-      isArray<T>() && this.left.length == value ? Verdict.Ok : Verdict.Fail;
+      // @ts-ignore
+      isArray<T>() && this._left.length == value ? "ok" : "fail";
 
     // @ts-ignore
-    this._left = this.left.length.toString();
-    this._right = value.toString();
+    this.left = this._left.length.toString();
+    this.right = value.toString();
 
-    this.op = "length";
+    this.instr = "toHaveLength";
 
     // @ts-ignore
     if (after_each_callback) after_each_callback();
@@ -282,14 +319,14 @@ export class Expectation<T> extends Node {
    */
   // @ts-ignore
   toContain(value: valueof<T>): void {
-    // @ts-ignore
     this.verdict =
-      isArray<T>() && this.left.includes(value) ? Verdict.Ok : Verdict.Fail;
+      // @ts-ignore
+      isArray<T>() && this._left.includes(value) ? "ok" : "fail";
 
     // @ts-ignore
-    this._left = "includes value";
-    this._right = "does not include value";
-    this.op = "=";
+    this.left = "includes value";
+    this.right = "does not include value";
+    this.instr = "toContain";
 
     // @ts-ignore
     if (after_each_callback) after_each_callback();
@@ -306,60 +343,30 @@ export class Expectation<T> extends Node {
     store<T>(
       changetype<usize>(this),
       equals,
-      offsetof<Expectation<T>>("right"),
+      offsetof<Expectation<T>>("_right"),
     );
     if (isBoolean<T>()) {
-      this.verdict = this.left === equals ? Verdict.Ok : Verdict.Fail;
+      this.verdict = this._left === equals ? "ok" : "fail";
     } else if (isString<T>()) {
-      this.verdict = this.left === equals ? Verdict.Ok : Verdict.Fail;
+      this.verdict = this._left === equals ? "ok" : "fail";
     } else if (isInteger<T>() || isFloat<T>()) {
-      this.verdict = this.left === equals ? Verdict.Ok : Verdict.Fail;
+      this.verdict = this._left === equals ? "ok" : "fail";
     } else if (isArray<T>()) {
       // getArrayDepth<T>();
     } else {
-      this.verdict = Verdict.Unreachable;
+      this.verdict = "none";
     }
 
-    this.op = "=";
+    this.instr = "toBe";
+
+    this.left = visualize<T>(this._left);
+    this.right = visualize<T>(
+      load<T>(changetype<usize>(this), offsetof<Expectation<T>>("_right")),
+    );
 
     // @ts-ignore
     if (after_each_callback) after_each_callback();
     // @ts-ignore
     if (before_each_callback) before_each_callback();
   }
-
-  report(): string | null {
-    if (!this._not && this.verdict === Verdict.Ok) return null;
-
-    const left = this._left || visualize(this.left);
-    const right =
-      this._right ||
-      visualize(
-        load<T>(changetype<usize>(this), offsetof<Expectation<T>>("right")),
-      );
-
-    if (this._not) {
-      if (this.verdict === Verdict.Fail) return null;
-      const dif = diff(left, right, true);
-      return (
-        rainbow.red(" - Test failed") +
-        "\n" +
-        rainbow.italicMk(
-          `  ${rainbow.dimMk("(expected) ->")} ${dif.left.toString()}\n  ${rainbow.dimMk("[ !" + this.op + " ]")}\n  ${rainbow.dimMk("(recieved) ->")} ${dif.right.toString()}`,
-        )
-      );
-    }
-
-    if (left == right) return null;
-
-    const dif = diff(left, right);
-
-    return (
-      rainbow.red(" - Test failed") +
-      "\n" +
-      rainbow.italicMk(
-        `  ${rainbow.dimMk("(expected) ->")} ${dif.left.toString()}\n  ${rainbow.dimMk("[ " + this.op + " ]")}\n  ${rainbow.dimMk("(recieved) ->")} ${dif.right.toString()}`,
-      )
-    );
-  }
 }

package/assembly/src/log.ts

@@ -0,0 +1,19 @@
+import { rainbow } from "as-rainbow";
+import { term } from "../util/term";
+
+
+@json
+export class Log {
+  public order: i32 = 0;
+  public depth: i32 = 0;
+  public text: string;
+  constructor(text: string) {
+    this.text = text;
+  }
+  display(): void {
+    term.write(
+      "  ".repeat(this.depth + 1) +
+        `${rainbow.bgBlackBright(" LOG ")}${rainbow.dimMk(": " + this.text)}\n`,
+    );
+  }
+}

package/assembly/src/suite.ts

@@ -0,0 +1,99 @@
+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";
+
+
+@json
+export class Suite {
+  public file: string = "unknown";
+  public order: i32 = 0;
+  public time: Time = new Time();
+  public description: string;
+  public depth: i32 = 0;
+  public suites: Suite[] = [];
+  public tests: Tests[] = [];
+  public logs: Log[] = [];
+  public kind: string;
+
+  public verdict: string = "none";
+
+  public callback: () => void;
+  constructor(description: string, callback: () => void, kind: string) {
+    this.description = description;
+    this.callback = callback;
+    this.kind = kind;
+  }
+
+  addExpectation<T extends Expectation<unknown>>(test: T): void {
+    test.order = this.order++;
+    this.tests.push(test);
+  }
+  addSuite(suite: Suite): void {
+    suite.order = this.order++;
+    this.suites.push(suite);
+    suite.depth = this.depth + 1;
+    suite.file = this.file;
+  }
+  addLog(log: Log): void {
+    log.order = this.order++;
+    this.logs.push(log);
+    log.depth = this.depth + 1;
+    log.display();
+  }
+
+  run(): void {
+    // @ts-ignore
+    current_suite = this;
+    // @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");
+    this.callback();
+    this.time.end = performance.now();
+    // @ts-ignore
+    depth--;
+
+    let suiteNone = true;
+    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;
+      } else if (suite.verdict == "ok") {
+        suiteNone = false;
+      }
+    }
+    for (let i = 0; i < this.tests.length; i++) {
+      const test = unchecked(this.tests[i]);
+      if (test.verdict == "fail") {
+        this.verdict = "fail";
+        suiteNone = false;
+      } else if (test.verdict == "ok") {
+        suiteNone = false;
+      }
+    }
+
+    if (this.verdict == "fail") {
+      suiteLn.edit(
+        `${suiteDepth}${rainbow.bgRed(" FAIL ")} ${rainbow.dimMk(this.description)}\n`,
+      );
+    } else if (!suiteNone || this.tests.length) {
+      this.verdict = "ok";
+      suiteLn.edit(
+        `${suiteDepth}${rainbow.bgGreenBright(" PASS ")} ${rainbow.dimMk(this.description)}\n`,
+      );
+    } else {
+      suiteLn.edit(
+        `${suiteDepth}${rainbow.bgBlackBright(" EMPTY ")} ${rainbow.dimMk(this.description)}\n`,
+      );
+    }
+  }
+}

package/assembly/src/tests.ts

@@ -0,0 +1,10 @@
+
+@json
+export class Tests {
+  public order: i32 = 0;
+  public type!: string;
+  public verdict: string = "none";
+  public left: string = "";
+  public right: string = "";
+  public instr: string = "";
+}

package/assembly/tsconfig.json

@@ -1,6 +1,6 @@
 {
   "extends": "assemblyscript/std/assembly.json",
-  "include": ["./**/*.ts"],
+  "include": ["./**/*.ts", "../reporters/report.ts"],
   "compilerOptions": {
     /* Visit https://aka.ms/tsconfig to read more about this file */
     /* Projects */

package/assembly/util/helpers.ts

@@ -79,39 +79,6 @@ export function diff(left: string, right: string, not: boolean = false): Diff {
   };
 }
 
-class Unit {
-  name: string;
-  divisor: number;
-}
-
-export function formatTime(ms: number): string {
-  if (ms < 0) {
-    throw new Error("Time should be a non-negative number.");
-  }
-
-  // Convert milliseconds to microseconds
-  const us = ms * 1000;
-
-  const units: Unit[] = [
-    { name: "μs", divisor: 1 },
-    { name: "ms", divisor: 1000 },
-    { name: "s", divisor: 1000 * 1000 },
-    { name: "m", divisor: 60 * 1000 * 1000 },
-    { name: "h", divisor: 60 * 60 * 1000 * 1000 },
-    { name: "d", divisor: 24 * 60 * 60 * 1000 * 1000 },
-  ];
-
-  for (let i = units.length - 1; i >= 0; i--) {
-    const unit = units[i];
-    if (us >= unit.divisor) {
-      const value = Math.round((us / unit.divisor) * 1000) / 1000;
-      return `${value}${unit.name}`;
-    }
-  }
-
-  return `${us}us`;
-}
-
 // @ts-ignore
 @inline
 export function colorText(format: i32[], text: string): string {

package/assembly/util/term.ts

@@ -0,0 +1,55 @@
+// @ts-ignore
+@external("env", "process.stdout.write")
+declare function process_stdout_write(data: string): void;
+
+export class TermLine {
+  public start: i32 = 0;
+  public end: i32 = 0;
+  constructor(start: i32 = 0, end: i32 = 0) {
+    this.start = start;
+    this.end = end;
+  }
+  edit(data: string): TermLine {
+    let end = this.end;
+    while (--end >= this.start) {
+      term.clearLn(end);
+    }
+    writeRaw(data);
+    term.resetCursor();
+    return new TermLine(this.end);
+  }
+  clear(): void {
+    term.clearLn(this.start);
+  }
+}
+
+export namespace term {
+  export let lines: i32 = 0;
+  export function write(data: string): TermLine {
+    const start = term.lines;
+    for (let i = 0; i < data.length; i++) {
+      const code = data.charCodeAt(i);
+      if (code === 10) term.lines++;
+    }
+    writeRaw(data);
+    return new TermLine(start, term.lines);
+  }
+  export function clearLn(line: i32): void {
+    writeRaw(`\u001B[${term.lines - line}A`);
+    writeRaw("\x1B[2K");
+    writeRaw("\x1B[0G");
+  }
+  export function resetCursor(): void {
+    writeRaw("\x1B[999B");
+    writeRaw("\x1B[0G");
+  }
+}
+
+export function writeRaw(data: string): void {
+  // @ts-ignore
+  if (isDefined(ASC_WASI)) {
+    process.stdout.write(data);
+  } else {
+    process_stdout_write(data);
+  }
+}