as-test 0.3.4 → 0.4.0-beta.1

package/CHANGELOG.md

@@ -1,30 +1,5 @@
-v0.0.0 - Initial project setup
-v0.0.1 - Updates to UI, some bug fixes
-v0.0.2 - Diff between expected and recieved results
-v0.0.3 - Added `afterEach`, `beforeEach`, `afterAll`, `beforeAll`, `test`, `it`, `.toBeGreaterThan`, `.toBeGreaterThanOrEqualTo`, ect..
-v0.0.4 - Fix import issue in README usage section
-v0.0.5 - Switch errors to be thrown at compile time instead of runtime
-v0.0.6 - Failed tests should be pushed to bottom of logs
-v0.0.8 - Fix readme typo in v0.0.7
-v0.0.9 - Fix type issue
+# Change Log
 
-v0.1.0 - Fix more type issues
-v0.1.1 - Add code coverage!
-v0.1.2 - Fix bugs with globals and dependencies
-v0.1.3 - Revamp `log<T>(data: T)` with new as-console version
-v0.1.4 - Fix a few bugs with the cli
-v0.1.5 - Add skeleton cli and custom config
-v0.1.6 - Fix: args should be prefixed with a space
-v0.1.7 - Fix: remove warning about wasi-shim not being included when it is included
-v0.1.8 - Feat: function mocking
-v0.1.9 - Fix: mocks were not being applied to declared functions, only property accesses
-v0.1.10 - Feat: support node, deno, and bun
+## 2025-03-03 - v0.4.0-beta.1
 
-v0.2.0 - Fix mock -> mockFn artifacts
-v0.2.1 - Remove accidental logging
-
-v0.3.0 - Pass metadata through terminal - Support for multiple files - Better reporting - Timing for suites - Terminal utilities
-v0.3.1 - Add screenshot of completed tests to readme
-v0.3.2 - Add `mockImport` to override imported functions
-v0.3.3 - Allow `mockImport`'s return type to be any
-v0.3.4 - Fix: import functions were not received after visitSource()
+- deps: update json-as to `v1.0.0-beta.8`

package/README.md

@@ -1,90 +1,47 @@
 <h5 align="center">
-<pre> _____  _____      _____  _____  _____  _____ 
-|  _  ||   __| ___|_   _||   __||   __||_   _|
-|     ||__   ||___| | |  |   __||__   |  | |  
-|__|__||_____|      |_|  |_____||_____|  |_|  
-v0.3.4
+  <pre>
+<span style="font-size: 0.8em;"> █████  ███████       ████████ ███████ ███████ ████████ 
+██   ██ ██               ██    ██      ██         ██    
+███████ ███████ █████    ██    █████   ███████    ██    
+██   ██      ██          ██    ██           ██    ██    
+██   ██ ███████          ██    ███████ ███████    ██    
+                                                        </span>
+    AssemblyScript - v0.4.0-beta.1
 </pre>
 </h5>
 
-## Installation
+A lightweight testing framework for AssemblyScript.
 
-To get started, install the package from NPM or GitHub
+🔹 Minimal and fast – Run your tests without unnecessary overhead.
 
-`npm i as-test --save-dev`
+🔹 Familiar API – Inspired by modern JavaScript testing frameworks.
 
-You'll also need to install `visitor-as`
+🔹 Powerful mocking – Easily override functions and track calls.
 
-`npm i visitor-as --save-dev`
+🔹 Seamless CI/CD integration – Works effortlessly in automation pipelines.
 
-View the docs: https://docs.jairus.dev/as-test
+🔹 Universal environment – Run your tests on any platform, runtime, or bindings.
 
-## Usage
+## 💾 Installation
 
-You can setup the configuration files using
+```bash
+npm install as-test
+```
+
+Initialize your test setup with:
 
 ```bash
 as-test init
 ```
 
-Note: You can use either `ast` or `as-test` in the terminal.
+This creates a test directory at `assembly/__tests__/` with a sample test file.
 
-Next, take a look at the generated test file
+## 📝 Writing Tests
 
-`assembly/__tests__/example.spec.ts`
+Create a new test file in `assembly/__tests__/`, for example, `math.spec.ts`:
 
 ```js
-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");
-});
-
-// Or override an imported function with mockImport
-
-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);
-    });
-});
+import { describe, test, expect, run } from "as-test";
 
 describe("Math operations", () => {
     test("Addition", () => {
@@ -92,55 +49,93 @@ describe("Math operations", () => {
     });
 
     test("Subtraction", () => {
-        expect(1 - 2).toBe(-1);
+        expect(5 - 2).toBe(3);
     });
 
-    test("Comparison", () => {
-        expect(5).toBeGreaterThan(3);
-        expect(2).toBeLessThan(4);
+    test("Multiplication", () => {
+        expect(3 * 3).toBe(9);
     });
+});
 
-    test("Type checking", () => {
-        expect("hello").toBeString();
-        expect(true).toBeBoolean();
-        expect(10.5).toBeNumber();
-    });
+run();
+```
+
+## 🔍 Examples
+
+### 🏗️ Mocking Functions
+
+Use `mockFn` to override functions during testing:
+
+```js
+import { mockFn } from "as-test";
+
+// Mock console.log
+mockFn<void>("console.log", (data: string): void => {
+    console.log("[MOCKED]: " + data);
 });
 
-let myArray: i32[] = [1, 2, 3];
+run();
+```
 
-describe("Array manipulation", () => {
-    test("Array length", () => {
-        expect(myArray).toHaveLength(3);
-    });
+Or override imported functions with `mockImport`.
 
-    test("Array inclusion", () => {
-        expect(myArray).toContain(2);
-    });
+### ⚒️ Setup and Teardown
+
+Use `beforeAll` and `afterAll` to run code before and after a test is run.
+
+```js
+import { beforeAll, afterAll } from "as-test";
 
-    it("should be empty", () => { });
+beforeAll(() => {
+    log("Setting up test environment...");
+});
+
+afterAll(() => {
+    log("Tearing down test environment...");
 });
 
 run();
+```
+
+### 📃 Pretty Logging
 
-function sleep(ms: i64): void {
-    const target = Date.now() + ms;
-    while (target > Date.now()) { }
-}
+Using `console.log` will mess up the terminal output. Instead, use the inbuilt `log` function:
+
+```js
+import { log } from "as-test";
+
+log("This is a pretty log function");
+
+run();
 ```
 
-Build and run it using as-test
+Or override all existing `console.log` calls with `log`:
 
-```bash
-npm run test
+```js
+import { mockFn, log } from "as-test";
+
+mockFn<void>("console.log", (data: string): void => {
+    log(data);
+});
+
+run();
 ```
 
-## Running
+### 🔄 Running Tests in CI
+
+To integrate `as-test` into your CI/CD workflow, see the [example configuration](https://github.com/JairusSW/as-test/blob/main/.github/workflows/as-test.yml).
+
+`assembly/__tests__/example.spec.ts`
+
+## 📃 License
 
-To add `as-test` to your CI/CD workflow, check out [The provided example](https://github.com/JairusSW/as-test/blob/main/.github/workflows/nodejs.yml)
+This project is distributed under an open source license. You can view the full license using the following link: [License](./LICENSE)
 
-If you use this project in your codebase, consider dropping a [⭐ HERE](https://github.com/JairusSW/as-test). I would really appreciate it!
+## 📫 Contact
 
-## Issues
+Please send all issues to [GitHub Issues](https://github.com/JairusSW/as-test/issues) and to converse, please send me an email at [me@jairus.dev](mailto:me@jairus.dev)
 
-Please submit an issue to https://github.com/JairusSW/as-test/issues if you find anything wrong with this library
+- **Email:** Send me inquiries, questions, or requests at [me@jairus.dev](mailto:me@jairus.dev)
+- **GitHub:** Visit the official GitHub repository [Here](https://github.com/JairusSW/as-test)
+- **Website:** Visit my official website at [jairus.dev](https://jairus.dev/)
+- **Discord:** Contact me at [My Discord](https://discord.com/users/600700584038760448) or on the [AssemblyScript Discord Server](https://discord.gg/assemblyscript/)

package/as-test.config.json

@@ -4,10 +4,10 @@
   "logs": "./logs",
   "config": "none",
   "plugins": {
-    "coverage": true
+    "coverage": false
   },
   "buildOptions": {
-    "args": [],
+    "args": ["--lib ./node_modules/json-as/lib"],
     "target": "bindings"
   },
   "runOptions": {

package/assembly/__tests__/array.spec.ts

@@ -3,17 +3,23 @@ import { describe, expect, test, run, it } from "..";
 const myArray: i32[] = [1, 2, 3];
 
 describe("Array manipulation", () => {
-  test("Array length", () => {
-    expect(myArray).toHaveLength(3);
-  });
+  // test("Array length", () => {
+  //   expect("foo").toBe("foo")
+  // });
 
-  test("Array inclusion", () => {
-    expect(myArray).toContain(2);
-  });
+  // test("Array inclusion", () => {
+  //   expect(myArray).toContain(2);
+  // });
+
+  test("Array check", () => {
+    const a = [1,2,3];
+    const b = [1,2,3];
+    expect(a).toBe(b);
+  })
 
   it("should be empty", () => {});
 });
 
 run({
-  log: false,
+  log: true,
 });

package/assembly/coverage.ts

@@ -3,7 +3,7 @@ export class CoverPoint {
   public hash: string = "";
   public line: i32 = 0;
   public column: i32 = 0;
-  public type!: string;
+  public type: string = "";
   public executed: boolean = false;
 }
 

package/assembly/src/expectation.ts

@@ -1,11 +1,14 @@
 import { visualize } from "../util/helpers";
 import { Tests } from "./tests";
 import { after_each_callback, before_each_callback } from "..";
+import { JSON } from "json-as";
 
 
 @json
 export class Expectation<T> extends Tests {
   public verdict: string = "none";
+  public right: JSON.Raw = JSON.Raw.from("");
+  public left: JSON.Raw = JSON.Raw.from("");
   private _left: T;
   // @ts-ignore
   private _right: u64 = 0;
@@ -33,10 +36,10 @@ export class Expectation<T> extends Tests {
 
     this.instr = "toBeNull";
 
-    this.left = visualize<T>(this._left);
-    this.right = visualize<T>(
+    this.left.set(visualize<T>(this._left));
+    this.right.set(visualize<T>(
       load<T>(changetype<usize>(this), offsetof<Expectation<T>>("_right")),
-    );
+    ));
 
     // @ts-ignore
     if (after_each_callback) after_each_callback();
@@ -62,10 +65,10 @@ export class Expectation<T> extends Tests {
 
     this.instr = "toBeGreaterThan";
 
-    this.left = visualize<T>(this._left);
-    this.right = visualize<T>(
+    this.left.set(visualize<T>(this._left));
+    this.right.set(visualize<T>(
       load<T>(changetype<usize>(this), offsetof<Expectation<T>>("_right")),
-    );
+    ));
 
     // @ts-ignore
     if (after_each_callback) after_each_callback();
@@ -91,10 +94,10 @@ export class Expectation<T> extends Tests {
 
     this.instr = "toBeGreaterThanOrEqualTo";
 
-    this.left = visualize<T>(this._left);
-    this.right = visualize<T>(
+    this.left.set(visualize<T>(this._left));
+    this.right.set(visualize<T>(
       load<T>(changetype<usize>(this), offsetof<Expectation<T>>("_right")),
-    );
+    ));
 
     // @ts-ignore
     if (after_each_callback) after_each_callback();
@@ -120,10 +123,10 @@ export class Expectation<T> extends Tests {
 
     this.instr = "toBeLessThan";
 
-    this.left = visualize<T>(this._left);
-    this.right = visualize<T>(
+    this.left.set(visualize<T>(this._left));
+    this.right.set(visualize<T>(
       load<T>(changetype<usize>(this), offsetof<Expectation<T>>("_right")),
-    );
+    ));
 
     // @ts-ignore
     if (after_each_callback) after_each_callback();
@@ -149,10 +152,10 @@ export class Expectation<T> extends Tests {
 
     this.instr = "toBeLessThanOrEqualTo";
 
-    this.left = visualize<T>(this._left);
-    this.right = visualize<T>(
+    this.left.set(visualize<T>(this._left));
+    this.right.set(visualize<T>(
       load<T>(changetype<usize>(this), offsetof<Expectation<T>>("_right")),
-    );
+    ));
 
     // @ts-ignore
     if (after_each_callback) after_each_callback();
@@ -167,8 +170,8 @@ export class Expectation<T> extends Tests {
   toBeString(): void {
     this.verdict = isString<T>() ? "ok" : "fail";
 
-    this.left = nameof<T>();
-    this.right = "string";
+    this.left.set(nameof<T>());
+    this.right.set("string");
 
     this.instr = "toBeString";
 
@@ -185,8 +188,8 @@ export class Expectation<T> extends Tests {
   toBeBoolean(): void {
     this.verdict = isBoolean<T>() ? "ok" : "fail";
 
-    this.left = nameof<T>();
-    this.right = "boolean";
+    this.left.set(nameof<T>());
+    this.right.set("boolean");
 
     this.instr = "toBeBoolean";
 
@@ -203,8 +206,8 @@ export class Expectation<T> extends Tests {
   toBeArray(): void {
     this.verdict = isArray<T>() ? "ok" : "fail";
 
-    this.left = nameof<T>();
-    this.right = "Array<any>";
+    this.left.set(nameof<T>());
+    this.right.set("Array<any>");
 
     this.instr = "toBeArray";
 
@@ -221,8 +224,8 @@ export class Expectation<T> extends Tests {
   toBeNumber(): void {
     this.verdict = isFloat<T>() || isInteger<T>() ? "ok" : "fail";
 
-    this.left = nameof<T>();
-    this.right = "number";
+    this.left.set(nameof<T>());
+    this.right.set("number");
 
     this.instr = "toBeNumber";
 
@@ -239,8 +242,8 @@ export class Expectation<T> extends Tests {
   toBeInteger(): void {
     this.verdict = isInteger<T>() ? "ok" : "fail";
 
-    this.left = nameof<T>();
-    this.right = "float";
+    this.left.set(nameof<T>());
+    this.right.set("float");
 
     this.instr = "toBeInteger";
 
@@ -257,8 +260,8 @@ export class Expectation<T> extends Tests {
   toBeFloat(): void {
     this.verdict = isFloat<T>() ? "ok" : "fail";
 
-    this.left = nameof<T>();
-    this.right = "integer";
+    this.left.set(nameof<T>());
+    this.right.set("integer");
 
     this.instr = "toBeFloat";
 
@@ -277,8 +280,8 @@ export class Expectation<T> extends Tests {
       // @ts-ignore
       (isFloat<T>() || isInteger<T>()) && isFinite(this._left) ? "ok" : "fail";
 
-    this.left = "Infinity";
-    this.right = "Finite";
+    this.left.set("Infinity");
+    this.right.set("Finite");
 
     this.instr = "toBeFinite";
 
@@ -300,8 +303,8 @@ export class Expectation<T> extends Tests {
       isArray<T>() && this._left.length == value ? "ok" : "fail";
 
     // @ts-ignore
-    this.left = this._left.length.toString();
-    this.right = value.toString();
+    this.left.set(this._left.length.toString());
+    this.right.set(value.toString());
 
     this.instr = "toHaveLength";
 
@@ -323,9 +326,8 @@ export class Expectation<T> extends Tests {
       // @ts-ignore
       isArray<T>() && this._left.includes(value) ? "ok" : "fail";
 
-    // @ts-ignore
-    this.left = "includes value";
-    this.right = "does not include value";
+    this.left.set("includes value");
+    this.right.set("does not include value");
     this.instr = "toContain";
 
     // @ts-ignore
@@ -340,33 +342,38 @@ export class Expectation<T> extends Tests {
    * @returns - void
    */
   toBe(equals: T): void {
-    store<T>(
-      changetype<usize>(this),
-      equals,
-      offsetof<Expectation<T>>("_right"),
-    );
-    if (isBoolean<T>()) {
+    if (isArray<T>()) {
+      // @ts-ignore
+      this.verdict = arrayEquals(this._left, equals) ? "ok" : "fail";
+    } else if (isBoolean<T>()) {
       this.verdict = this._left === equals ? "ok" : "fail";
     } else if (isString<T>()) {
       this.verdict = this._left === equals ? "ok" : "fail";
     } else if (isInteger<T>() || isFloat<T>()) {
       this.verdict = this._left === equals ? "ok" : "fail";
-    } else if (isArray<T>()) {
-      // getArrayDepth<T>();
     } else {
       this.verdict = "none";
     }
 
     this.instr = "toBe";
 
-    this.left = visualize<T>(this._left);
-    this.right = visualize<T>(
-      load<T>(changetype<usize>(this), offsetof<Expectation<T>>("_right")),
-    );
+    this.left.set(JSON.stringify<T>(this._left));
+    this.right.set(JSON.stringify<T>(equals));
 
     // @ts-ignore
     if (after_each_callback) after_each_callback();
     // @ts-ignore
     if (before_each_callback) before_each_callback();
+
+    // store<T>(
+    //   changetype<usize>(this),
+    //   equals,
+    //   offsetof<Expectation<T>>("_right"),
+    // );
   }
 }
+
+function arrayEquals<T extends any[]>(a: T, b: T): boolean {
+  if (a.length != b.length) return false;
+  return JSON.stringify(a) == JSON.stringify(b);
+}

package/assembly/src/tests.ts

@@ -1,10 +1,11 @@
+import { JSON } from "json-as";
 
 @json
 export class Tests {
   public order: i32 = 0;
-  public type!: string;
+  public type: string = "";
   public verdict: string = "none";
-  public left: string = "";
-  public right: string = "";
+  public left: JSON.Raw = JSON.Raw.from("");
+  public right: JSON.Raw = JSON.Raw.from("");
   public instr: string = "";
 }

package/assembly/util/helpers.ts

@@ -1,4 +1,5 @@
 import { rainbow } from "as-rainbow";
+import { JSON } from "json-as";
 
 export function visualize<T>(value: T): string {
   if (isNullable<T>() && changetype<usize>(value) == <usize>0) {
@@ -11,6 +12,18 @@ export function visualize<T>(value: T): string {
   } else if (isInteger<T>() || isFloat<T>()) {
     // @ts-ignore
     return value.toString();
+  } else if (isArray<T>()) {
+    // @ts-ignore
+    if (!value.length) return "[]";
+    let out = "[";
+    // @ts-ignore
+    for (let i = 0; i < value.length - 1; i++) {
+      // @ts-ignore
+      out += visualize<valueof<T>>(value[i]);
+    }
+    // @ts-ignore
+    out += visualize<valueof<T>>(value[value.length - 1]);
+    return out;
   }
 
   return unreachable();

package/bin/index.js

@@ -7,7 +7,7 @@ const _args = process.argv.slice(2);
 const flags = [];
 const args = [];
 const COMMANDS = ["run", "build", "test", "init"];
-const version = "0.3.4";
+const version = "0.3.5";
 for (const arg of _args) {
   if (arg.startsWith("-")) flags.push(arg);
   else args.push(arg);

package/bin/init.js

@@ -9,7 +9,7 @@ export async function init(args) {
     input: process.stdin,
     output: process.stdout,
   });
-  console.log(chalk.bold("as-test init v0.3.4") + "\n");
+  console.log(chalk.bold("as-test init v0.3.5") + "\n");
   console.log(chalk.dim("[1/3]") + " select a target [wasi/bindings]");
   const target = await ask(chalk.dim(" -> "), rl);
   if (!TARGETS.includes(target)) {
@@ -182,7 +182,7 @@ const exports = instantiate(module, {});`,
   }
   if (!pkg["devDependencies"]) pkg["devDependencies"] = {};
   if (!pkg["devDependencies"]["as-test"])
-    pkg["devDependencies"]["as-test"] = "^0.3.4";
+    pkg["devDependencies"]["as-test"] = "^0.3.5";
   if (target == "bindings") {
     pkg["type"] = "module";
   }

package/bin/run.js

@@ -35,7 +35,7 @@ export async function run() {
       chalk.bold.blueBright(`|__|__||_____|      |_|  |_____||_____|  |_|  `),
     );
     console.log(
-      chalk.dim("\n------------------- v0.3.4 -------------------\n"),
+      chalk.dim("\n------------------- v0.3.5 -------------------\n"),
     );
   }
   for (const plugin of Object.keys(config.plugins)) {
@@ -114,10 +114,10 @@ export async function run() {
       );
       for (const test of failed.tests) {
         const diffResult = diff(
-          JSON.stringify(test._left),
-          JSON.stringify(test._right),
+          JSON.stringify(test.left),
+          JSON.stringify(test.right),
         );
-        let expected = chalk.dim(JSON.stringify(test._left));
+        let expected = chalk.dim(JSON.stringify(test.left));
         let received = "";
         for (const res of diffResult.diff) {
           switch (res.type) {

package/cli/index.ts

@@ -11,7 +11,7 @@ const args: string[] = [];
 
 const COMMANDS: string[] = ["run", "build", "test", "init"];
 
-const version = "0.3.4";
+const version = "0.3.5";
 
 for (const arg of _args) {
   if (arg.startsWith("-")) flags.push(arg);