as-test 0.1.4 → 0.1.6

package/bin/util.js

@@ -0,0 +1,23 @@
+export function formatTime(ms) {
+  if (ms < 0) {
+    throw new Error("Time should be a non-negative number.");
+  }
+  // Convert milliseconds to microseconds
+  const us = ms * 1000;
+  const units = [
+    { 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`;
+}

package/cli/build.ts

@@ -0,0 +1,154 @@
+import { existsSync, readFileSync } from "fs";
+import { Config } from "./types.js";
+import { glob } from "glob";
+import chalk from "chalk";
+import { exec } from "child_process";
+import { formatTime } from "./util.js";
+import * as path from "path";
+
+export async function build(args: string[]) {
+  const CONFIG_PATH = path.join(process.cwd(), "./as-test.config.json");
+  let config: Config;
+  if (!existsSync(CONFIG_PATH)) {
+    console.log(
+      chalk.bgMagentaBright(" WARN ") +
+        chalk.dim(":") +
+        " Could not locate config file in the current directory! Continuing with default config." +
+        "\n",
+    );
+    config = new Config();
+  } else {
+    config = Object.assign(
+      new Config(),
+      JSON.parse(readFileSync(CONFIG_PATH).toString()),
+    ) as Config;
+    console.log(chalk.dim("Loading config from: " + CONFIG_PATH) + "\n");
+  }
+  const ASCONFIG_PATH = path.join(process.cwd(), config.config);
+  if (!existsSync(ASCONFIG_PATH)) {
+    console.log(
+      chalk.bgMagentaBright(" WARN ") +
+        chalk.dim(":") +
+        ' Could not locate asconfig.json file! If you do not want to provide a config, set "config": "none". Continuing with default config.' +
+        "\n",
+    );
+  }
+  const pkg = JSON.parse(readFileSync("./package.json").toString()) as {
+    dependencies: string[] | null;
+    devDependencies: string[] | null;
+    peerDependencies: string[] | null;
+  };
+  let buildCommands: string[] = [];
+
+  if (config.buildOptions.wasi) {
+    if (!existsSync("./node_modules/@assemblyscript/wasi-shim/asconfig.json")) {
+      console.log(
+        chalk.bgRed(" ERROR ") +
+          chalk.dim(":") +
+          " " +
+          "could not find @assemblyscript/wasi-shim! Add it to your dependencies to run with WASI!",
+      );
+      process.exit(1);
+    }
+    if (
+      (pkg.dependencies &&
+        !Object.keys(pkg.dependencies).includes("@assemblyscript/wasi-shim")) ||
+      (pkg.devDependencies &&
+        !Object.keys(pkg.devDependencies).includes(
+          "@assemblyscript/wasi-shim",
+        )) ||
+      (pkg.peerDependencies &&
+        !Object.keys(pkg.peerDependencies).includes(
+          "@assemblyscript/wasi-shim",
+        ))
+    ) {
+      if (
+        existsSync("./node_modules/@assemblyscript/wasi-shim/asconfig.json")
+      ) {
+        console.log(
+          chalk.bold.bgMagentaBright(" WARN ") +
+            chalk.dim(": @assemblyscript/wasi-shim") +
+            " is not included in project dependencies!",
+        );
+      }
+    }
+  }
+
+  let packageManagerCommand = "npx";
+  if (
+    process.env.npm_config_user_agent &&
+    process.env.npm_config_user_agent.includes("pnpm")
+  ) {
+    packageManagerCommand = "pnpx";
+  } else if (
+    process.env.npm_config_user_agent &&
+    process.env.npm_config_user_agent.includes("yarn")
+  ) {
+    packageManagerCommand = "yarn run";
+  } else if (
+    process.env.npm_config_user_agent &&
+    process.env.npm_config_user_agent.includes("bun")
+  ) {
+    packageManagerCommand = "bunx";
+  }
+  console.log("");
+
+  const inputFiles = await glob(config.input);
+  for (const file of inputFiles) {
+    console.log(chalk.dim("Including " + file));
+    let command = `${packageManagerCommand} asc ${file}${args.length ? " " + args.join(" ") : ""}`;
+    if (config.buildOptions.wasi) {
+      command +=
+        " --config ./node_modules/@assemblyscript/wasi-shim/asconfig.json";
+    }
+    if (config.config !== "none") {
+      command += " --config " + config.config;
+    }
+    const outFile =
+      config.outDir +
+      "/" +
+      file.slice(file.lastIndexOf("/") + 1).replace(".ts", ".wasm");
+    if (config.outDir) {
+      command += " -o " + outFile;
+    }
+    if (config.coverage.enabled) {
+      console.log(chalk.dim("Enabling coverage"));
+      command += " --use COVERAGE_USE=1 --transform as-test/transform";
+      if (config.coverage.show) command += " --use COVERAGE_SHOW=1";
+    }
+    if (config.buildOptions.args) {
+      command += " " + config.buildOptions.args.join(" ");
+    }
+    buildCommands.push(command);
+  }
+
+  const build = (command: string) => {
+    return new Promise<void>((resolve, _) => {
+      console.log(chalk.dim("Building: " + command));
+      exec(command, (err, stdout, stderr) => {
+        if (config.buildOptions.verbose) {
+          process.stdout.write(stdout);
+        }
+        if (err) {
+          process.stderr.write(stderr + "\n");
+          process.exit(1);
+        }
+        resolve();
+      });
+    });
+  };
+
+  if (config.buildOptions.parallel) {
+    console.log(chalk.dim("Building sources in parallel..."));
+    const start = performance.now();
+    let builders: Promise<void>[] = [];
+    for (const command of buildCommands) {
+      builders.push(build(command));
+    }
+
+    await Promise.all(builders);
+    console.log(
+      chalk.dim("Compiled in " + formatTime(performance.now() - start)) + "\n",
+    );
+  }
+}

package/cli/index.ts

@@ -0,0 +1,201 @@
+#!/usr/bin/env node
+
+import chalk from "chalk";
+import { build } from "./build.js";
+import { run } from "./run.js";
+import { init } from "./init.js";
+
+const _args = process.argv.slice(2);
+const flags: string[] = [];
+const args: string[] = [];
+
+const COMMANDS: string[] = ["run", "build", "test", "init"];
+
+const version = "0.1.6";
+
+for (const arg of _args) {
+  if (arg.startsWith("-")) flags.push(arg);
+  else args.push(arg);
+}
+
+if (!args.length) {
+  if (flags.includes("--tap")) {
+    console.log(`TAP version 13
+# timing test
+ok 1 should be strictly equal
+not ok 2 should be strictly equal
+  ---
+    operator: equal
+    expected: 100
+    actual:   107
+  ...
+
+1..2
+# tests 2
+# pass  1
+# fail  1`);
+  } else if (flags.includes("--version") || flags.includes("-v")) {
+    console.log("as-test" + " " + version.toString());
+  } else {
+    console.log(
+      chalk.bold.blueBright("as-test") +
+        " is a testing framework for AssemblyScript. " +
+        chalk.dim("(v" + version + ")") +
+        "\n",
+    );
+
+    console.log(
+      chalk.bold("Usage: as-test") +
+        " " +
+        chalk.dim("<command>") +
+        " " +
+        chalk.bold.blueBright("[...flags]") +
+        " " +
+        chalk.bold("[...args]") +
+        " " +
+        chalk.dim("(alias: ast)") +
+        "\n",
+    );
+
+    console.log(chalk.bold("Commands:"));
+    console.log(
+      "  " +
+        chalk.bold.blueBright("run") +
+        "       " +
+        chalk.dim("<my-test.spec.ts>") +
+        "       " +
+        "Run unit tests with selected runtime",
+    );
+    console.log(
+      "  " +
+        chalk.bold.blueBright("build") +
+        "     " +
+        chalk.dim("<my-test.spec.ts>") +
+        "       " +
+        "Build unit tests and compile",
+    );
+    console.log(
+      "  " +
+        chalk.bold.blueBright("test") +
+        "      " +
+        chalk.dim("<my-test.spec.ts>") +
+        "       " +
+        "Build and run unit tests with selected runtime" +
+        "\n",
+    );
+
+    console.log(
+      "  " +
+        chalk.bold.magentaBright("init") +
+        "       " +
+        chalk.strikethrough.dim("") +
+        "                       " +
+        "Initialize an empty testing template",
+    );
+    console.log(
+      "  " +
+        chalk.strikethrough.bold.magentaBright("config") +
+        "     " +
+        chalk.strikethrough.dim("as-test.config.json") +
+        "    " +
+        "Specify the configuration file",
+    );
+    console.log(
+      "  " +
+        chalk.strikethrough.bold.magentaBright("reporter") +
+        "   " +
+        chalk.strikethrough.dim("<tap>") +
+        "                  " +
+        "Specify the test reporter to use",
+    );
+    console.log(
+      "  " +
+        chalk.strikethrough.bold.magentaBright("use") +
+        "        " +
+        chalk.strikethrough.dim("wasmtime") +
+        "               " +
+        "Specify the runtime to use" +
+        "\n",
+    );
+
+    console.log(chalk.bold("Flags:"));
+
+    console.log(
+      "  " +
+        chalk.strikethrough.dim("run") +
+        "        " +
+        chalk.strikethrough.bold.blue("--coverage") +
+        "             " +
+        "Use code coverage",
+    );
+    console.log(
+      "  " +
+        chalk.strikethrough.dim("run") +
+        "        " +
+        chalk.strikethrough.bold.blue("--snapshot") +
+        "             " +
+        "Take a snapshot of the tests",
+    );
+    console.log(
+      "  " +
+        chalk.strikethrough.dim("use") +
+        "        " +
+        chalk.strikethrough.bold.blue("--list") +
+        "                 " +
+        "List supported runtimes",
+    );
+    console.log(
+      "  " +
+        chalk.strikethrough.dim("reporter") +
+        "   " +
+        chalk.strikethrough.bold.blue("--list") +
+        "                 " +
+        "List supported reporters",
+    );
+    console.log(
+      "  " +
+        chalk.strikethrough.dim("<command>") +
+        "  " +
+        chalk.strikethrough.bold.blue("--help") +
+        "                 " +
+        "Print info about command" +
+        "\n",
+    );
+
+    console.log(
+      chalk.dim(
+        "If your using this, consider dropping a star, it would help a lot!",
+      ) + "\n",
+    );
+
+    console.log(
+      "View the repo:                   " +
+        chalk.magenta("https://github.com/JairusSW/as-test"),
+    );
+    console.log(
+      "View the docs:                   " +
+        chalk.strikethrough.blue("https://docs.jairus.dev/as-test"),
+    );
+  }
+} else if (COMMANDS.includes(args[0]!)) {
+  const command = args.shift();
+  if (command === "build") {
+    build(args);
+  } else if (command === "run") {
+    run();
+  } else if (command === "test") {
+    build(args).then(() => {
+      run();
+    });
+  } else if (command === "init") {
+    init(args);
+  }
+} else {
+  console.log(
+    chalk.bgRed(" ERROR ") +
+      chalk.dim(":") +
+      " " +
+      chalk.bold("Unknown command: ") +
+      args[0],
+  );
+}

package/cli/init.ts

@@ -0,0 +1,47 @@
+import chalk from "chalk";
+import { existsSync, writeFileSync } from "fs";
+import * as path from "path";
+import { createInterface } from "readline";
+import { Config } from "./types.js";
+
+export function init(args: string[]): void {
+  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(): 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);
+  }
+}

package/cli/run.ts

@@ -0,0 +1,68 @@
+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"],
+]);
+export async function run() {
+  const config = Object.assign(
+    new Config(),
+    JSON.parse(readFileSync("./as-test.config.json").toString()),
+  ) as Config;
+  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.name ||
+        file == config.runOptions.runtime.name + ".exe"
+      ) {
+        execPath = bin + "/" + file;
+      }
+    }
+  }
+
+  if (!execPath) {
+    console.log(
+      chalk.bgRed(" ERROR ") +
+        chalk.dim(":") +
+        " could not locate " +
+        config.runOptions.runtime.name +
+        " in your PATH variable. Either set it, or install it" +
+        (config.runOptions.runtime.name
+          ? "using " +
+            chalk.dim(installScripts.get(config.runOptions.runtime.name))
+          : "."),
+    );
+  }
+  for (const file of inputFiles) {
+    const outFile =
+      config.outDir +
+      "/" +
+      file.slice(file.lastIndexOf("/") + 1).replace(".ts", ".wasm");
+    exec(
+      config.runOptions.runtime.run
+        .replace(config.runOptions.runtime.name, execPath)
+        .replace("<file>", outFile),
+      (err, stdout, stderr) => {
+        process.stdout.write(stdout);
+        process.stderr.write(stderr);
+        if (err) {
+          process.exit(err.code);
+        }
+      },
+    );
+  }
+}

package/cli/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "outDir": "../bin",
+    "importHelpers": false,
+    "moduleResolution": "Node10"
+  }
+}

package/cli/types.ts

@@ -0,0 +1,34 @@
+export class Config {
+  input: string[] = ["./assembly/__tests__/*.spec.ts"];
+  outDir: string = "./build";
+  config: string = "./asconfig.json";
+  suites: Suite[] = [];
+  coverage: Coverage = new Coverage();
+  buildOptions: BuildOptions = new BuildOptions();
+  runOptions: RunOptions = new RunOptions();
+}
+
+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;
+}
+
+export class RunOptions {
+  runtime: Runtime = new Runtime();
+}
+
+export class Runtime {
+  name: string = "wasmtime";
+  run: string = "wasmtime <file>";
+}

package/cli/util.ts

@@ -0,0 +1,30 @@
+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: {
+    name: string;
+    divisor: number;
+  }[] = [
+    { 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`;
+}

package/index.ts

@@ -1 +1 @@
-export * from "./assembly/index";
+export * from "./assembly/index";

package/jest.test.js

@@ -1,5 +1,44 @@
-describe("Should create suite successfully", () => {
-    expect("foo joe momma joe mommmmma").toBe("booq2132132312");
-    expect("abcdefg").not.toBe("abcdefg");
-    expect("hello").toBe("hello");
-});
+describe("Math operations", () => {
+  // Setup before each test in this group (optional)
+  beforeEach(() => {
+    log("Initializing test...");
+  });
+
+  // Teardown after each test in this group (optional)
+  afterEach(() => {
+    log("Cleaning up after test...");
+  });
+
+  test("Addition", () => {
+    expect(1 + 2).toBe(3);
+  });
+
+  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 = [];
+
+describe("Array manipulation", () => {
+  beforeAll(() => {
+    myArray = [1, 2, 3];
+  });
+
+  test("Array length", () => {
+    expect(myArray).toHaveLength(3);
+  });
+
+  test("Array inclusion", () => {
+    expect(myArray).toContain(2);
+  });
+});
+
+function foo() {}

package/package.json

@@ -1,37 +1,36 @@
 {
   "name": "as-test",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "Testing framework for AssemblyScript. Compatible with WASI or Bindings ",
   "types": "assembly/index.ts",
   "author": "Jairus Tanaka",
   "contributors": [],
   "license": "MIT",
   "scripts": {
-    "test": "wasmtime ./build/test.wasm",
-    "pretest": "TEST_DEBUG=all asc assembly/test.ts -o build/test.wasm --transform ./transform --bindings esm  --config ./node_modules/@assemblyscript/wasi-shim/asconfig.json",
-    "bench:wasmtime": "wasmtime ./build/bench.wasm",
+    "test": "node ./bin/index.js run",
+    "test:tap": "node ./bin/index.js --tap",
+    "pretest": "node ./bin/index.js build",
     "build:transform": "tsc -p ./transform",
-    "prettier": "as-prettier -w ."
+    "build:cli": "tsc -p cli",
+    "prettier": "prettier -w .",
+    "prepublish": "npm run build:cli && npm run build:transform && npm run test"
   },
   "devDependencies": {
-    "as-test": "./",
     "@assemblyscript/wasi-shim": "^0.1.0",
-    "@types/micromatch": "^4.0.7",
+    "@types/node": "^20.14.9",
+    "as-test": "./",
     "assemblyscript": "^0.27.28",
     "assemblyscript-prettier": "^3.0.1",
-    "jest": "^29.7.0",
-    "typescript": "^5.5.2",
-    "visitor-as": "^0.11.4",
-    "json-as": "^0.9.8"
+    "typescript": "^5.5.3",
+    "visitor-as": "^0.11.4"
   },
   "dependencies": {
-    "as-console": "^1.0.1",
+    "as-console": "^7.0.0",
     "as-rainbow": "^0.1.0",
-    "as-string-sink": "^0.5.3",
     "as-variant": "^0.4.1",
     "chalk": "^5.3.0",
-    "micromatch": "^4.0.7",
-    "table-as": "^1.0.1"
+    "glob": "^10.4.2",
+    "jest": "^29.7.0"
   },
   "overrides": {
     "assemblyscript": "$assemblyscript",
@@ -55,5 +54,9 @@
   "type": "module",
   "publishConfig": {
     "@JairusSW:registry": "https://npm.pkg.github.com"
+  },
+  "bin": {
+    "as-test": "./bin/index.js",
+    "ast": "./bin/index.js"
   }
 }