as-test 0.2.1 → 0.3.0

package/bin/init.js

@@ -1,44 +1,216 @@
 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) {
-  console.log(
-    chalk.bold("This command will make sure that the following files exist") +
-      "\n",
-  );
-  console.log(
-    "  " +
-      chalk.bold.blueBright("./as-test.config.json") +
-      chalk.dim(" - The core config file for as-test") +
-      "\n",
-  );
-  console.log(
-    "This command will attempt to update files to match the correct configuration.\n",
-  );
-  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);
-    }
-  });
-}
-function initialize() {
-  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));
+import { loadConfig } from "./util.js";
+const TARGETS = ["wasi", "bindings"];
+export async function init(args) {
+    const rl = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    console.log(chalk.bold("as-test init v0.3.0") + "\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("\n" +
+        chalk.dim("[2/3]") +
+        " attempting to create the following files. Continue? [y/n]\n");
+    console.log(chalk.dim(`  ├── 📂 assembly/
+  │    └── 📂 __tests__/
+  │         └── 🧪 example.spec.ts
+  ├── 📂 build/
+  ├── 📂 logs/
+  ├── 📂 tests/
+  │    └── 📃 as-test.run.js   
+  ├── ⚙️  as-test.config.json
+  └── ⚙️  package.json\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()) { }
+}`);
+    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.0";
+    if (target == "bindings") {
+        pkg["type"] = "module";
+    }
+    writeFileSync(PKG_PATH, JSON.stringify(pkg, null, 2));
     process.exit(0);
-  }
+}
+function ask(question, face) {
+    return new Promise((res, _) => {
+        face.question(question, (answer) => {
+            res(answer);
+        });
+    });
+}
+function writeFile(pth, data) {
+    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) {
+    const fmtPath = path.join(process.cwd(), pth);
+    if (existsSync(fmtPath))
+        return;
+    mkdirSync(fmtPath);
+}
+function hasDep(PKG_PATH, dep) {
+    const pkg = JSON.parse(existsSync(PKG_PATH) ? readFileSync(PKG_PATH).toString() : "{}");
+    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/bin/reporter.js

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

package/bin/run.js

@@ -1,73 +1,231 @@
-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([
-  ["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()),
-  );
-  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;
-      }
-    }
-  }
-  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]),
-            )
-          : "."),
-    );
-  }
-  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"));
-    }
-    exec(cmd, (err, stdout, stderr) => {
-      process.stdout.write(stdout);
-      process.stderr.write(stderr);
-      if (err) {
-        process.exit(err.code);
-      }
-    });
-  }
+    const reports = [];
+    const config = loadConfig(CONFIG_PATH);
+    const inputFiles = await glob(config.input);
+    console.log(chalk.dim("Running tests using " + config.runOptions.runtime.name + ""));
+    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.0 -------------------\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((res, _) => {
+                let stdout = "";
+                const io = exec(cmd);
+                io.stdout.pipe(process.stdout);
+                io.stderr.pipe(process.stderr);
+                io.stdout.on("data", (data) => {
+                    stdout += readData(data);
+                });
+                io.stdout.on("close", () => {
+                    res(stdout);
+                });
+            });
+        })());
+        reports.push(report);
+    }
+    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 {
+    constructor(reports) {
+        this.passedFiles = 0;
+        this.failedFiles = 0;
+        this.passedSuites = 0;
+        this.failedSuites = 0;
+        this.passedTests = 0;
+        this.failedTests = 0;
+        this.failed = [];
+        this.time = 0.0;
+        this.readReports(reports);
+    }
+    readReports(reports) {
+        for (const file of reports) {
+            this.readFile(file);
+        }
+    }
+    readFile(file) {
+        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) {
+        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) {
+        if (test.verdict == "fail") {
+            this.failedTests++;
+        }
+        else {
+            this.passedTests++;
+        }
+    }
+}
+function readData(data) {
+    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/bin/types.js

@@ -1,41 +1,35 @@
 export class Config {
-  constructor() {
-    this.input = ["./assembly/__tests__/*.spec.ts"];
-    this.outDir = "./build";
-    this.config = "./asconfig.json";
-    this.suites = [];
-    this.coverage = new Coverage();
-    this.buildOptions = new BuildOptions();
-    this.runOptions = new RunOptions();
-  }
+    constructor() {
+        this.input = ["./assembly/__tests__/*.spec.ts"];
+        this.outDir = "./build";
+        this.logs = "./logs";
+        this.config = "none";
+        this.plugins = {
+            coverage: true,
+        };
+        this.buildOptions = new BuildOptions();
+        this.runOptions = new RunOptions();
+    }
 }
 export class Suite {
-  constructor() {
-    this.name = "";
-  }
-}
-export class Coverage {
-  constructor() {
-    this.enabled = false;
-    this.show = false;
-  }
+    constructor() {
+        this.name = "";
+    }
 }
 export class BuildOptions {
-  constructor() {
-    this.args = [];
-    this.wasi = true;
-    this.parallel = true;
-    this.verbose = true;
-  }
+    constructor() {
+        this.args = [];
+        this.target = "wasi";
+    }
 }
 export class RunOptions {
-  constructor() {
-    this.runtime = new Runtime();
-  }
+    constructor() {
+        this.runtime = new Runtime();
+    }
 }
 export class Runtime {
-  constructor() {
-    this.name = "wasmtime";
-    this.run = "wasmtime <file>";
-  }
+    constructor() {
+        this.name = "wasmtime";
+        this.run = "wasmtime <file>";
+    }
 }