as-test 0.2.1 → 0.3.1

package/cli/init.ts

@@ -1,47 +1,248 @@
 import chalk from "chalk";
-import { existsSync, writeFileSync } from "fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import * as path from "path";
-import { createInterface } from "readline";
-import { Config } from "./types.js";
-
-export function init(args: string[]): void {
+import { createInterface, Interface } from "readline";
+import { loadConfig } from "./util.js";
+const TARGETS = ["wasi", "bindings"];
+export async function init(args: string[]) {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+  console.log(chalk.bold("as-test init v0.3.1") + "\n");
+  console.log(chalk.dim("[1/3]") + " select a target [wasi/bindings]");
+  const target = await ask(chalk.dim(" -> "), rl);
+  if (!TARGETS.includes(target)) {
+    console.log("Invalid target " + target + ". Exiting.");
+    process.exit(0);
+  }
+  process.stdout.write(`\u001B[1A`);
+  process.stdout.write("\x1B[2K");
+  process.stdout.write("\x1B[0G");
   console.log(
-    chalk.bold("This command will make sure that the following files exist") +
-      "\n",
+    "\n" +
+      chalk.dim("[2/3]") +
+      " attempting to create the following files. Continue? [y/n]\n",
   );
   console.log(
-    "  " +
-      chalk.bold.blueBright("./as-test.config.json") +
-      chalk.dim(" - The core config file for as-test") +
-      "\n",
+    chalk.dim(
+      `  ├── 📂 assembly/
+  │    └── 📂 __tests__/
+  │         └── 🧪 example.spec.ts
+  ├── 📂 build/
+  ├── 📂 logs/
+  ├── 📂 tests/
+  │    └── 📃 as-test.run.js   
+  ├── ⚙️  as-test.config.json
+  └── ⚙️  package.json\n`,
+    ),
   );
 
-  console.log(
-    "This command will attempt to update files to match the correct configuration.\n",
+  const cont = (await ask(chalk.dim(" -> "), rl)).toLowerCase().trim();
+
+  if (cont == "n" || cont == "no") {
+    console.log("Exiting.");
+    process.exit(0);
+  }
+
+  let config = loadConfig(path.join(process.cwd(), "./as-test.config.json"));
+  if (target == "wasi" && config.buildOptions.target != "wasi") {
+    config.buildOptions.target = "wasi";
+    config.runOptions.runtime.name = "wasmtime";
+    config.runOptions.runtime.run = "wasmtime <file>";
+  } else if (target == "bindings" && config.buildOptions.target != "bindings") {
+    config.buildOptions.target = "bindings";
+    config.runOptions.runtime.name = "node";
+    config.runOptions.runtime.run = "node ./tests/<name>.run.js";
+  }
+
+  writeFile("./as-test.config.json", JSON.stringify(config, null, 2));
+
+  writeFile(
+    "./assembly/__tests__/example.spec.ts",
+    `import {
+    describe,
+    expect,
+    test,
+    beforeAll,
+    afterAll,
+    mockFn,
+    log,
+    run,
+    it
+} from "as-test";
+
+beforeAll(() => {
+    log("Setting up test environment...");
+});
+
+afterAll(() => {
+    log("Tearing down test environment...");
+});
+
+// Mock/override the function console.log
+mockFn<void>("console.log", (data: string): void => {
+    console.log("[MOCKED]: " + data + "\\n");
+});
+
+describe("Should sleep", () => {
+    test("1ms", () => {
+        const start = Date.now();
+        sleep(1);
+        expect(Date.now() - start).toBeGreaterOrEqualTo(1);
+    });
+    test("10ms", () => {
+        const start = Date.now();
+        sleep(10);
+        expect(Date.now() - start).toBeGreaterOrEqualTo(10);
+    });
+    test("1s", () => {
+        const start = Date.now();
+        sleep(1000);
+        expect(Date.now() - start).toBeGreaterOrEqualTo(1000);
+    });
+    test("5s", () => {
+        const start = Date.now();
+        log("Sleeping...");
+        sleep(5000);
+        log("Done!");
+        expect(Date.now() - start).toBeGreaterOrEqualTo(5000);
+    });
+});
+
+describe("Math operations", () => {
+    test("Addition", () => {
+        expect(1 + 2).toBe(3);
+    });
+
+    test("Subtraction", () => {
+        expect(1 - 2).toBe(-1);
+    });
+
+    test("Comparison", () => {
+        expect(5).toBeGreaterThan(3);
+        expect(2).toBeLessThan(4);
+    });
+
+    test("Type checking", () => {
+        expect("hello").toBeString();
+        expect(true).toBeBoolean();
+        expect(10.5).toBeNumber();
+    });
+});
+
+let myArray: i32[] = [1, 2, 3];
+
+describe("Array manipulation", () => {
+    test("Array length", () => {
+        expect(myArray).toHaveLength(3);
+    });
+
+    test("Array inclusion", () => {
+        expect(myArray).toContain(2);
+    });
+
+    it("should be empty", () => { });
+});
+
+run();
+
+function sleep(ms: i64): void {
+    const target = Date.now() + ms;
+    while (target > Date.now()) { }
+}`,
   );
-  console.log("Do you want to proceed? [Y/n] ");
-  createInterface({
-    input: process.stdin,
-    output: process.stdout,
-  }).question("", (answer) => {
-    if (answer.toLowerCase() === "y") {
-      initialize();
-    } else {
-      console.log("Exiting...");
-      process.exit(0);
-    }
+
+  writeDir("./build/");
+  writeDir("./logs/");
+
+  if (target == "bindings") {
+    writeFile(
+      "./tests/example.run.js",
+      `import { readFileSync } from "fs";
+import { instantiate } from "../build/example.spec.js";
+
+const binary = readFileSync("./build/example.spec.wasm");
+const module = new WebAssembly.Module(binary);
+
+const exports = instantiate(module, {});`,
+    );
+  }
+
+  const PKG_PATH = path.join(process.cwd(), "./package.json");
+  if (!hasDep(PKG_PATH, "assemblyscript")) {
+    console.log(
+      chalk.dim(
+        "AssemblyScript is not included in dependencies.\nInstall it with " +
+          (process.env.npm_config_user_agent == "yarn"
+            ? process.env.npm_config_user_agent + " add assemblyscript"
+            : process.env.npm_config_user_agent + " install assemblyscript"),
+      ),
+    );
+  }
+  const pkg = JSON.parse(
+    existsSync(PKG_PATH) ? readFileSync(PKG_PATH).toString() : "{}",
+  );
+  if (!pkg["scripts"]) pkg["scripts"] = {};
+  if (pkg.scripts["test"]) process.exit(0);
+  if (!pkg.scripts["pretest"]) {
+    pkg.scripts["pretest"] = "as-test build";
+    pkg.scripts["test"] = "as-test run";
+  } else {
+    pkg.scripts["test"] = "as-test test";
+  }
+  if (!pkg["devDependencies"]) pkg["devDependencies"] = {};
+  if (!pkg["devDependencies"]["as-test"])
+    pkg["devDependencies"]["as-test"] = "^0.3.1";
+  if (target == "bindings") {
+    pkg["type"] = "module";
+  }
+  writeFileSync(PKG_PATH, JSON.stringify(pkg, null, 2));
+  process.exit(0);
+}
+
+function ask(question: string, face: Interface): Promise<string> {
+  return new Promise<string>((res, _) => {
+    face.question(question, (answer) => {
+      res(answer);
+    });
   });
 }
 
-function initialize(): void {
-  const CONFIG_PATH = path.join(process.cwd(), "./as-test.config.json");
-  if (existsSync(CONFIG_PATH)) {
-    console.log("Found ./as-test.config.json. Updating...");
-    process.exit(0);
-  } else {
-    console.log("Wrote ./as-test.config.json");
-    writeFileSync(CONFIG_PATH, JSON.stringify(new Config(), null, 2));
-    console.log(JSON.stringify(new Config(), null, 2));
-    process.exit(0);
+function writeFile(pth: string, data: string) {
+  const fmtPath = path.join(process.cwd(), pth);
+  if (existsSync(fmtPath)) return;
+  if (!existsSync(path.dirname(fmtPath)))
+    mkdirSync(path.dirname(fmtPath), { recursive: true });
+  writeFileSync(fmtPath, data);
+}
+
+function writeDir(pth: string) {
+  const fmtPath = path.join(process.cwd(), pth);
+  if (existsSync(fmtPath)) return;
+  mkdirSync(fmtPath);
+}
+
+function hasDep(PKG_PATH: string, dep: string): boolean {
+  const pkg = JSON.parse(
+    existsSync(PKG_PATH) ? readFileSync(PKG_PATH).toString() : "{}",
+  ) as {
+    dependencies: string[] | null;
+    devDependencies: string[] | null;
+    peerDependencies: string[] | null;
+  };
+
+  if (existsSync(path.join(process.cwd(), "./node_modules/", dep))) return true;
+
+  if (
+    pkg.dependencies &&
+    !Object.keys(pkg.dependencies).includes(dep) &&
+    pkg.devDependencies &&
+    !Object.keys(pkg.devDependencies).includes(dep) &&
+    pkg.peerDependencies &&
+    !Object.keys(pkg.peerDependencies).includes(dep)
+  ) {
+    return false;
   }
+  return true;
 }

package/cli/reporter.ts

@@ -0,0 +1 @@
+export function report(): void {}

package/cli/run.ts

@@ -1,79 +1,288 @@
-import { existsSync, readFileSync, readdirSync } from "fs";
-import { Config } from "./types.js";
 import chalk from "chalk";
 import { exec } from "child_process";
 import { glob } from "glob";
 
-const installScripts = new Map<string, string>([
-  ["wasmtime", "curl https://wasmtime.dev/install.sh -sSf | bash"],
-  ["wasmer", "curl https://get.wasmer.io -sSfL | sh"],
-]);
+import { formatTime, getExec, loadConfig } from "./util.js";
+import * as path from "path";
+import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { diff } from "typer-diff";
+
+const CONFIG_PATH = path.join(process.cwd(), "./as-test.config.json");
+
 export async function run() {
-  const config = Object.assign(
-    new Config(),
-    JSON.parse(readFileSync("./as-test.config.json").toString()),
-  ) as Config;
+  const reports: any[] = [];
+  const config = loadConfig(CONFIG_PATH);
   const inputFiles = await glob(config.input);
 
   console.log(
     chalk.dim("Running tests using " + config.runOptions.runtime.name + ""),
   );
 
-  let execPath = "";
-  const PATH = process.env["PATH"]?.split(":")!;
-  for (const bin of PATH) {
-    if (bin.startsWith("/mnt/")) continue; // WSL
-    if (!existsSync(bin)) continue;
-    for (const file of readdirSync(bin)) {
-      if (
-        file == config.runOptions.runtime.run.split(" ")[0] ||
-        file == config.runOptions.runtime.run.split(" ")[0] + ".exe"
-      ) {
-        execPath = bin + "/" + file;
+  const command = config.runOptions.runtime.run.split(" ")[0];
+  let execPath = getExec(command);
+
+  if (!execPath) {
+    console.log(
+      `${chalk.bgRed(" ERROR ")}${chalk.dim(":")} could not locate ${command} in PATH variable!`,
+    );
+    process.exit(0);
+  }
+
+  if (inputFiles.length) {
+    console.log(
+      chalk.bold.blueBright(` _____  _____      _____  _____  _____  _____ `),
+    );
+    console.log(
+      chalk.bold.blueBright(`|  _  ||   __| ___|_   _||   __||   __||_   _|`),
+    );
+    console.log(
+      chalk.bold.blueBright(`|     ||__   ||___| | |  |   __||__   |  | |  `),
+    );
+    console.log(
+      chalk.bold.blueBright(`|__|__||_____|      |_|  |_____||_____|  |_|  `),
+    );
+    console.log(
+      chalk.dim("\n------------------- v0.3.1 -------------------\n"),
+    );
+  }
+
+  for (const plugin of Object.keys(config.plugins)) {
+    if (!config.plugins[plugin]) continue;
+    console.log(
+      chalk.bgBlueBright(" PLUGIN ") +
+        " " +
+        chalk.dim(
+          "Using " + plugin.slice(0, 1).toUpperCase() + plugin.slice(1),
+        ) +
+        "\n",
+    );
+  }
+
+  for (let i = 0; i < inputFiles.length; i++) {
+    const file = inputFiles[i];
+    const outFile = path.join(
+      config.outDir,
+      file.slice(file.lastIndexOf("/") + 1).replace(".ts", ".wasm"),
+    );
+
+    let cmd = config.runOptions.runtime.run.replace(command, execPath);
+    if (config.buildOptions.target == "bindings") {
+      cmd = config.runOptions.runtime.run.replace(command, execPath);
+
+      if (cmd.includes("<name>")) {
+        cmd = cmd.replace(
+          "<name>",
+          file
+            .slice(file.lastIndexOf("/") + 1)
+            .replace(".ts", "")
+            .replace(".spec", ""),
+        );
+      } else {
+        cmd = cmd.replace(
+          "<file>",
+          outFile
+            .replace("build", "tests")
+            .replace(".spec", "")
+            .replace(".wasm", ".run.js"),
+        );
       }
+    } else {
+      cmd = cmd.replace("<file>", outFile);
     }
+
+    const report = JSON.parse(
+      await (() => {
+        return new Promise<string>((res, _) => {
+          let stdout = "";
+          const io = exec(cmd);
+          io.stdout.pipe(process.stdout);
+          io.stderr.pipe(process.stderr);
+          io.stdout.on("data", (data: string) => {
+            stdout += readData(data);
+          });
+          io.stdout.on("close", () => {
+            res(stdout);
+          });
+        });
+      })(),
+    );
+    reports.push(report);
   }
 
-  if (!execPath) {
-    console.log(
-      chalk.bgRed(" ERROR ") +
-        chalk.dim(":") +
-        " could not locate " +
-        config.runOptions.runtime.run.split(" ")[0] +
-        " in your PATH variable. Either set it, or install it" +
-        (config.runOptions.runtime.run.split(" ")[0]
-          ? "using " +
-            chalk.dim(
-              installScripts.get(config.runOptions.runtime.run.split(" ")[0]),
-            )
-          : "."),
+  if (config.logs && config.logs != "none") {
+    if (!existsSync(path.join(process.cwd(), config.logs))) {
+      mkdirSync(path.join(process.cwd(), config.logs));
+    }
+    writeFileSync(
+      path.join(process.cwd(), config.logs, "test.log.json"),
+      JSON.stringify(reports, null, 2),
     );
   }
+  const reporter = new Reporter(reports);
+
+  if (reporter.failed.length) {
+    console.log(chalk.dim("----------------- [FAILED] -------------------\n"));
+    for (const failed of reporter.failed) {
+      console.log(
+        `${chalk.bgRed(" FAIL ")} ${chalk.dim(failed.description)}\n`,
+      );
+      for (const test of failed.tests) {
+        const diffResult = diff(
+          JSON.stringify(test._left),
+          JSON.stringify(test._right),
+        );
+        let expected = chalk.dim(JSON.stringify(test._left));
+        let received = "";
+        for (const res of diffResult.diff) {
+          switch (res.type) {
+            case "correct": {
+              received += chalk.dim(res.value);
+              continue;
+            }
+            case "extra": {
+              received += chalk.red.strikethrough(res.value);
+              continue;
+            }
+            case "missing": {
+              received += chalk.bgBlack(res.value);
+              continue;
+            }
+            case "wrong": {
+              received += chalk.bgRed(res.value);
+              continue;
+            }
+            case "untouched": {
+              //received += chalk.bgBlackBright(res.value);
+              continue;
+            }
+            case "spacer": {
+              //received += chalk.bgBlackBright(res.value);
+              continue;
+            }
+          }
+        }
+        if (test.verdict == "fail") {
+          console.log(`${chalk.dim("(expected) ->")} ${expected}`);
+          console.log(`${chalk.dim("(received) ->")} ${received}\n`);
+        }
+      }
+    }
+  }
+
+  console.log(chalk.dim("----------------- [RESULTS] ------------------\n"));
+
+  process.stdout.write(chalk.bold("Files:  "));
+  if (reporter.failedFiles) {
+    process.stdout.write(chalk.bold.red(reporter.failedFiles + " failed"));
+  } else {
+    process.stdout.write(chalk.bold.greenBright("0 failed"));
+  }
+  process.stdout.write(
+    ", " + (reporter.failedFiles + reporter.passedFiles) + " total\n",
+  );
+
+  process.stdout.write(chalk.bold("Suites: "));
+  if (reporter.failedSuites) {
+    process.stdout.write(chalk.bold.red(reporter.failedSuites + " failed"));
+  } else {
+    process.stdout.write(chalk.bold.greenBright("0 failed"));
+  }
+  process.stdout.write(
+    ", " + (reporter.failedSuites + reporter.passedSuites) + " total\n",
+  );
+
+  process.stdout.write(chalk.bold("Tests:  "));
+  if (reporter.failedTests) {
+    process.stdout.write(chalk.bold.red(reporter.failedTests + " failed"));
+  } else {
+    process.stdout.write(chalk.bold.greenBright("0 failed"));
+  }
+  process.stdout.write(
+    ", " + (reporter.failedTests + reporter.passedTests) + " total\n",
+  );
+
+  process.stdout.write(
+    chalk.bold("Time:   ") + formatTime(reporter.time) + "\n",
+  );
+
+  if (reporter.failedFiles) process.exit(1);
+  process.exit(0);
+}
+
+class Reporter {
+  public passedFiles = 0;
+  public failedFiles = 0;
 
-  for (const file of inputFiles) {
-    const outFile =
-      config.outDir +
-      "/" +
-      file.slice(file.lastIndexOf("/") + 1).replace(".ts", ".wasm");
-
-    let cmd = config.runOptions.runtime.run
-      .replace(config.runOptions.runtime.name, execPath)
-      .replace("<file>", outFile);
-    if (
-      config.runOptions.runtime.run.startsWith("bun") ||
-      config.runOptions.runtime.run.startsWith("node") ||
-      config.runOptions.runtime.run.startsWith("deno")
-    ) {
-      cmd = config.runOptions.runtime.run
-        .replace(config.runOptions.runtime.name, execPath)
-        .replace("<file>", outFile.replace(".wasm", ".js"));
+  public passedSuites = 0;
+  public failedSuites = 0;
+
+  public passedTests = 0;
+  public failedTests = 0;
+
+  public failed: any[] = [];
+
+  public time = 0.0;
+  constructor(reports: any[]) {
+    this.readReports(reports);
+  }
+  readReports(reports: any[]) {
+    for (const file of reports) {
+      this.readFile(file);
     }
-    exec(cmd, (err, stdout, stderr) => {
-      process.stdout.write(stdout);
-      process.stderr.write(stderr);
-      if (err) {
-        process.exit(err.code);
+  }
+  readFile(file: any) {
+    let failed = false;
+    for (const suite of file) {
+      if (suite.verdict == "fail") {
+        failed = true;
+        this.failedSuites++;
+      } else {
+        this.passedSuites++;
       }
-    });
+      this.time += suite.time.end - suite.time.start;
+      for (const subSuite of suite.suites) {
+        this.readSuite(subSuite);
+      }
+      for (const test of suite.tests) {
+        if (test.verdict == "fail") this.failed.push(suite);
+        this.readTest(test);
+      }
+    }
+    if (failed) this.failedFiles++;
+    else this.passedFiles++;
+  }
+  readSuite(suite: any) {
+    if (suite.verdict == "fail") {
+      this.failedSuites++;
+    } else {
+      this.passedSuites++;
+    }
+    this.time += suite.time.end - suite.time.start;
+    for (const subSuite of suite.suites) {
+      this.readSuite(subSuite);
+    }
+    for (const test of suite.tests) {
+      if (test.verdict == "fail") this.failed.push(suite);
+      this.readTest(test);
+    }
+  }
+  readTest(test: any) {
+    if (test.verdict == "fail") {
+      this.failedTests++;
+    } else {
+      this.passedTests++;
+    }
+  }
+}
+
+function readData(data: string): string {
+  let out = "";
+  const start = data.indexOf("READ_LINE");
+  if (start >= 0) {
+    const slice = data.slice(start + 9);
+    const end = slice.indexOf("END_LINE");
+    out += slice.slice(0, end);
+    out += readData(slice);
   }
+  return out;
 }

package/cli/types.ts

@@ -1,9 +1,11 @@
 export class Config {
   input: string[] = ["./assembly/__tests__/*.spec.ts"];
   outDir: string = "./build";
-  config: string = "./asconfig.json";
-  suites: Suite[] = [];
-  coverage: Coverage = new Coverage();
+  logs: string = "./logs";
+  config: string = "none";
+  plugins: {} = {
+    coverage: true,
+  };
   buildOptions: BuildOptions = new BuildOptions();
   runOptions: RunOptions = new RunOptions();
 }
@@ -12,16 +14,9 @@ export class Suite {
   name: string = "";
 }
 
-export class Coverage {
-  enabled: boolean = false;
-  show: boolean = false;
-}
-
 export class BuildOptions {
   args: string[] = [];
-  wasi: boolean = true;
-  parallel: boolean = true;
-  verbose: boolean = true;
+  target: string = "wasi";
 }
 
 export class RunOptions {