as-test 0.2.0 → 0.3.0

package/assembly/index.ts

@@ -1,25 +1,26 @@
 import { rainbow } from "as-rainbow";
-import { TestGroup } from "./src/group";
+import { Suite } from "./src/suite";
 import { Expectation } from "./src/expectation";
-import { formatTime } from "./util/helpers";
 import { stringify } from "as-console/stringify";
 import { __COVER, __HASHES, __POINTS } from "as-test/assembly/coverage";
-import { createTable } from "table-as";
+import { JSON } from "json-as";
+import { term, TermLine } from "./util/term";
+import { Log } from "./src/log";
 
-/**
- * Enumeration representing the verdict of a test case.
- */
-export enum Verdict {
-  Unreachable,
-  Ok,
-  Fail,
-}
+let entrySuites: Suite[] = [];
 
+// @ts-ignore
+const FILE = isDefined(ENTRY_FILE) ? ENTRY_FILE : "unknown";
 // Globals
-let current_group: TestGroup | null = null;
-let groups: TestGroup[] = [];
-
+// @ts-ignore
+@global let suites: Suite[] = [];
+// @ts-ignore
+@global let depth: i32 = -1;
+// @ts-ignore
+@global let current_suite: Suite | null = null;
+// @ts-ignore
 let before_all_callback: (() => void) | null = null;
+// @ts-ignore
 let after_all_callback: (() => void) | null = null;
 
 export let before_each_callback: (() => void) | null = null;
@@ -41,10 +42,21 @@ let __test_options!: RunOptions;
  * ```
  */
 export function describe(description: string, callback: () => void): void {
-  const group = new TestGroup(description, callback);
+  const suite = new Suite(description, callback, "describe");
 
-  current_group = group;
-  groups.push(group);
+  if (depth >= 0) {
+    const _suite = suites[depth];
+    if (_suite.depth == depth) {
+      _suite.addSuite(suite);
+    } else {
+      suite.depth = ++depth;
+      suites.push(suite);
+    }
+  } else {
+    suite.file = FILE;
+    entrySuites.push(suite);
+    suites.push(suite);
+  }
 }
 
 /**
@@ -62,10 +74,21 @@ export function describe(description: string, callback: () => void): void {
  * ```
  */
 export function test(description: string, callback: () => void): void {
-  const group = new TestGroup(description, callback);
+  const suite = new Suite(description, callback, "test");
 
-  current_group = group;
-  groups.push(group);
+  if (depth >= 0) {
+    const _suite = suites[depth];
+    if (_suite.depth == depth) {
+      _suite.addSuite(suite);
+    } else {
+      suite.depth = ++depth;
+      suites.push(suite);
+    }
+  } else {
+    suite.file = FILE;
+    entrySuites.push(suite);
+    suites.push(suite);
+  }
 }
 
 /**
@@ -83,10 +106,21 @@ export function test(description: string, callback: () => void): void {
  * ```
  */
 export function it(description: string, callback: () => void): void {
-  const group = new TestGroup(description, callback);
+  const suite = new Suite(description, callback, "it");
 
-  current_group = group;
-  groups.push(group);
+  if (depth >= 0) {
+    const _suite = suites[depth];
+    if (_suite.depth == depth) {
+      _suite.addSuite(suite);
+    } else {
+      suite.depth = ++depth;
+      suites.push(suite);
+    }
+  } else {
+    suite.file = FILE;
+    entrySuites.push(suite);
+    suites.push(suite);
+  }
 }
 
 /**
@@ -108,10 +142,13 @@ export function it(description: string, callback: () => void): void {
  * ```
  */
 export function expect<T>(value: T): Expectation<T> {
-  const result = new Expectation<T>(value);
-  current_group!.addExpectation(result);
+  const test = new Expectation<T>(value);
+
+  if (current_suite) {
+    current_suite!.addExpectation(test);
+  }
 
-  return result;
+  return test;
 }
 
 /**
@@ -133,9 +170,11 @@ export function log<T>(data: T): void {
     const lines = formatted.split("\n");
     for (let i = 0; i < lines.length; i++) {
       const line = unchecked(lines[i]);
-      console.log("  " + rainbow.bgYellow(" LOG ") + " " + line);
+      if (current_suite) {
+        current_suite!.addLog(new Log(line));
+      }
     }
-    console.log("");
+    term.write("\n");
   }
 }
 
@@ -176,7 +215,7 @@ export function afterEach(callback: () => void): void {
 }
 
 /**
- * Overrides all references to an existing function to instead point to this
+ * Overrides all references to an existing function in local scope to instead point to new function
  * @param {string} fn - name of function to override
  * @param {() => returnType} callback - the function to substitute it with
  */
@@ -185,6 +224,18 @@ export function mockFn<returnType>(
   callback: (...args: any[]) => returnType,
 ): void {}
 
+/**
+ * Unmock all references to an existing function to instead point to the original function
+ * @param {string} fn - name of function to override
+ */
+export function unmockFn(fn: string): void {}
+
+/**
+ * Re-mock all references to an existing function to instead point to the declared function
+ * @param {string} fn - name of function to override
+ */
+export function remockFn(fn: string): void {}
+
 /**
  * Class defining options that can be passed to the `run` function.
  *
@@ -218,153 +269,118 @@ class RunOptions {
  * ```
  */
 export function run(options: RunOptions = new RunOptions()): void {
+  // const buf = new ArrayBuffer(20);
+  // const bytes = process.stdin.read(buf);
+  // const stdinLn = term.write(String.UTF8.decodeUnsafe(changetype<usize>(buf), bytes) + "\n");
   __test_options = options;
-  console.log(
-    rainbow.boldMk(
-      rainbow.blueBright(` _____  _____      _____  _____  _____  _____ `),
-    ),
-  );
-  console.log(
-    rainbow.boldMk(
-      rainbow.blueBright(`|  _  ||   __| ___|_   _||   __||   __||_   _|`),
-    ),
+  const time = new Time();
+  const fileLn = term.write(
+    `${rainbow.bgCyanBright(" FILE ")} ${rainbow.dimMk(FILE)}\n`,
   );
-  console.log(
-    rainbow.boldMk(
-      rainbow.blueBright(`|     ||__   ||___| | |  |   __||__   |  | |  `),
-    ),
-  );
-  console.log(
-    rainbow.boldMk(
-      rainbow.blueBright(`|__|__||_____|      |_|  |_____||_____|  |_|  `),
-    ),
-  );
-  console.log(
-    rainbow.dimMk("\n------------------- v0.2.0 -------------------\n"),
+  term.write("\n");
+  time.start = performance.now();
+  for (let i = 0; i < entrySuites.length; i++) {
+    // @ts-ignore
+    const suite = unchecked(entrySuites[i]);
+    suites = [suite];
+
+    current_suite = suite;
+    depth = -1;
+    current_suite = null;
+
+    suite.run();
+
+    suites = [];
+    depth = -1;
+    current_suite = null;
+  }
+  time.end = performance.now();
+  fileLn.edit(
+    `${rainbow.bgCyanBright(" FILE ")} ${rainbow.dimMk(FILE)} ${rainbow.dimMk(time.format())}`,
   );
-  // @ts-ignore
-  if (isDefined(COVERAGE_USE)) {
-    console.log(
-      rainbow.bgBlueBright(" PLUGIN ") +
-        " " +
-        rainbow.dimMk("Using Code Coverage") +
-        "\n",
-    );
+  const reportText = JSON.stringify(entrySuites);
+  const chunk_size = 48;
+  let chunks = reportText.length / chunk_size;
+  let index = 0;
+  term.write("\x1B[8m\n").clear(); // Hide text (so that the cursor doesn't flash for a moment)
+  while (chunks--) {
+    term
+      .write(
+        "READ_LINE" +
+          reportText.slice(index, (index += chunk_size)) +
+          "END_LINE\n",
+      )
+      .clear(); // Write a line and then clear it, making it invisible
   }
-  const suites = groups.length;
-  let failed = 0;
-  let tests = 0;
-  let failed_tests = 0;
-  let failed_suite_logs = "";
-  const start = performance.now();
-  for (let i = 0; i < groups.length; i++) {
-    if (before_all_callback) before_all_callback();
-    const suite = unchecked(groups[i]);
-    suite.run();
-    for (let i = 0; i < suite.results.length; i++) {
-      const expectation = unchecked(suite.results[i]);
-      const verdict = expectation.verdict;
-      tests++;
-      if (verdict == Verdict.Ok) {
-        suite.passed++;
-      } else if (verdict == Verdict.Fail) {
-        suite.verdict = Verdict.Fail;
-        suite.failed++;
-        failed_tests++;
-      }
-    }
-    if (suite.verdict == Verdict.Unreachable) {
-      suite.verdict = Verdict.Ok;
-      console.log(
-        rainbow.bgGreenBright(" PASS ") +
-          " " +
-          rainbow.dimMk(suite.description) +
-          "\n",
-      );
-    } else {
-      failed++;
-      const txt =
-        rainbow.bgRed(" FAIL ") + " " + rainbow.dimMk(suite.description) + "\n";
-      failed_suite_logs += txt;
-      console.log(txt);
-    }
+  if (index < reportText.length) {
+    term.write("READ_LINE" + reportText.slice(index) + "END_LINE\n").clear();
+  }
+  term.write("\x1B[0m\n").clear(); // Un-hide text
+}
 
-    const report = suite.getLogs();
-    if (report) {
-      if (report.passed) console.log(report.passed!);
-      if (report.failed) failed_suite_logs += report.failed!;
+export class Result {
+  public name: string;
+  public arg1: i32;
+  public arg2: i32;
+  constructor(name: string, arg1: i32, arg2: i32) {
+    this.name = name;
+    this.arg1 = arg1;
+    this.arg2 = arg2;
+  }
+  display(): string {
+    let out = "";
+    out += `${rainbow.boldMk(this.name)} `;
+    if (this.arg1) {
+      out += `${rainbow.boldMk(rainbow.red(this.arg1.toString() + " " + "failed"))}`;
+    } else {
+      out += `${rainbow.boldMk(rainbow.green("0 failed"))}`;
     }
-    if (after_all_callback) after_all_callback();
+    out += ` ${this.arg1 + this.arg2} total\n`;
+    return out;
+  }
+  serialize(): string {
+    return JSON.stringify(this);
   }
+}
+
 
-  if (failed) {
-    console.log(
-      rainbow.red("------------------ [FAILED] ------------------\n"),
-    );
-    console.log(failed_suite_logs);
+@json
+export class Time {
+  start: f64 = 0;
+  end: f64 = 0;
+  format(): string {
+    return formatTime(this.end - this.start);
   }
+}
+
+class Unit {
+  name: string;
+  divisor: number;
+}
+
+function formatTime(time: f64): string {
+  if (time < 0) return "0.00μs";
+
+  const us = time * 1000;
 
-  // @ts-ignore
-  if (isDefined(COVERAGE_USE) && isDefined(COVERAGE_SHOW) && __HASHES().size) {
-    console.log(
-      rainbow.dimMk("----------------- [COVERAGE] -----------------\n"),
-    );
-    const points = __HASHES().values();
-
-    const table: string[][] = [["Location", "Type", "Hash"]];
-
-    for (let i = 0; i < points.length; i++) {
-      const point = unchecked(points[i]);
-      const file = point.file;
-      const reference =
-        point.file +
-        ":" +
-        point.line.toString() +
-        ":" +
-        point.column.toString();
-      const type = point.type;
-      const hash = point.hash;
-      table.push([rainbow.underlineMk(reference), type, "#" + hash]);
+  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) * 100) / 100).toString();
+      return `${value}${unit.name}`;
     }
-    console.log(rainbow.dimMk(createTable(table)) + "\n");
   }
 
-  console.log(
-    rainbow.dimMk("----------------- [RESULTS] ------------------\n"),
-  );
-  const ms = performance.now() - start;
-  console.log(
-    rainbow.boldMk("Test Suites: ") +
-      (failed
-        ? rainbow.boldMk(rainbow.red(failed.toString() + " failed"))
-        : rainbow.boldMk(rainbow.green("0 failed"))) +
-      ", " +
-      suites.toString() +
-      " total",
-  );
-  console.log(
-    rainbow.boldMk("Tests:       ") +
-      (failed_tests
-        ? rainbow.boldMk(rainbow.red(failed_tests.toString() + " failed"))
-        : rainbow.boldMk(rainbow.green("0 failed"))) +
-      ", " +
-      tests.toString() +
-      " total",
-  );
-  // @ts-ignore
-  if (isDefined(COVERAGE_USE))
-    console.log(
-      rainbow.boldMk("Coverage:    ") +
-        (__HASHES().size
-          ? rainbow.boldMk(rainbow.red(__HASHES().size.toString() + " failed"))
-          : rainbow.boldMk(rainbow.green("0 failed"))) +
-        ", " +
-        __POINTS().toString() +
-        " total",
-    );
-  console.log(rainbow.boldMk("Snapshots:   ") + "0 total");
-  console.log(rainbow.boldMk("Time:        ") + formatTime(ms));
-  if (failed) {
-    process.exit(1);
-  }
+  const _us = (Math.round(us * 100) / 100).toString();
+
+  return `${_us}μs`;
 }