@gjsify/unit 0.0.2

package/lib/esm/index.js

@@ -0,0 +1,360 @@
+import "@girs/gjs";
+export * from "./spy.js";
+import nodeAssert from "assert";
+const mainloop = globalThis?.imports?.mainloop;
+let countTestsOverall = 0;
+let countTestsFailed = 0;
+let countTestsIgnored = 0;
+let runtime = "";
+const RED = "\x1B[31m";
+const GREEN = "\x1B[32m";
+const BLUE = "\x1B[34m";
+const GRAY = "\x1B[90m";
+const RESET = "\x1B[39m";
+const print = globalThis.print || console.log;
+class MatcherFactory {
+  constructor(actualValue, positive, negated) {
+    this.actualValue = actualValue;
+    this.positive = positive;
+    if (negated) {
+      this.not = negated;
+    } else {
+      this.not = new MatcherFactory(actualValue, !positive, this);
+    }
+  }
+  not;
+  triggerResult(success, msg) {
+    if (success && !this.positive || !success && this.positive) {
+      ++countTestsFailed;
+      throw new Error(msg);
+    }
+  }
+  to(callback) {
+    this.triggerResult(
+      callback(this.actualValue),
+      `      Expected callback to validate`
+    );
+  }
+  toBe(expectedValue) {
+    this.triggerResult(
+      this.actualValue === expectedValue,
+      `      Expected values to match using ===
+      Expected: ${expectedValue} (${typeof expectedValue})
+      Actual: ${this.actualValue} (${typeof this.actualValue})`
+    );
+  }
+  toEqual(expectedValue) {
+    this.triggerResult(
+      this.actualValue == expectedValue,
+      `      Expected values to match using ==
+      Expected: ${expectedValue} (${typeof expectedValue})
+      Actual: ${this.actualValue} (${typeof this.actualValue})`
+    );
+  }
+  toEqualArray(expectedValue) {
+    let success = Array.isArray(this.actualValue) && Array.isArray(expectedValue) && this.actualValue.length === expectedValue.length;
+    for (let i = 0; i < this.actualValue.length; i++) {
+      const actualVal = this.actualValue[i];
+      const expectedVal = expectedValue[i];
+      success = actualVal == expectedVal;
+      if (!success)
+        break;
+    }
+    this.triggerResult(
+      success,
+      `      Expected array items to match using ==
+      Expected: ${expectedValue} (${typeof expectedValue})
+      Actual: ${this.actualValue} (${typeof this.actualValue})`
+    );
+  }
+  toMatch(expectedValue) {
+    if (typeof this.actualValue.match !== "function") {
+      throw new Error(`You can not use toMatch on type ${typeof this.actualValue}`);
+    }
+    this.triggerResult(
+      !!this.actualValue.match(expectedValue),
+      "      Expected values to match using regular expression\n      Expression: " + expectedValue + "\n      Actual: " + this.actualValue
+    );
+  }
+  toBeDefined() {
+    this.triggerResult(
+      typeof this.actualValue !== "undefined",
+      `      Expected value to be defined`
+    );
+  }
+  toBeUndefined() {
+    this.triggerResult(
+      typeof this.actualValue === "undefined",
+      `      Expected value to be undefined`
+    );
+  }
+  toBeNull() {
+    this.triggerResult(
+      this.actualValue === null,
+      `      Expected value to be null`
+    );
+  }
+  toBeTruthy() {
+    this.triggerResult(
+      this.actualValue,
+      `      Expected value to be truthy`
+    );
+  }
+  toBeFalsy() {
+    this.triggerResult(
+      !this.actualValue,
+      `      Expected value to be falsy`
+    );
+  }
+  toContain(needle) {
+    this.triggerResult(
+      this.actualValue instanceof Array && this.actualValue.indexOf(needle) !== -1,
+      `      Expected ` + this.actualValue + ` to contain ` + needle
+    );
+  }
+  toBeLessThan(greaterValue) {
+    this.triggerResult(
+      this.actualValue < greaterValue,
+      `      Expected ` + this.actualValue + ` to be less than ` + greaterValue
+    );
+  }
+  toBeGreaterThan(smallerValue) {
+    this.triggerResult(
+      this.actualValue > smallerValue,
+      `      Expected ` + this.actualValue + ` to be greater than ` + smallerValue
+    );
+  }
+  toBeCloseTo(expectedValue, precision) {
+    const shiftHelper = Math.pow(10, precision);
+    this.triggerResult(
+      Math.round(this.actualValue * shiftHelper) / shiftHelper === Math.round(expectedValue * shiftHelper) / shiftHelper,
+      `      Expected ` + this.actualValue + ` with precision ` + precision + ` to be close to ` + expectedValue
+    );
+  }
+  toThrow(ErrorType) {
+    let errorMessage = "";
+    let didThrow = false;
+    let typeMatch = true;
+    try {
+      this.actualValue();
+      didThrow = false;
+    } catch (e) {
+      errorMessage = e.message || "";
+      didThrow = true;
+      if (ErrorType) {
+        typeMatch = e instanceof ErrorType;
+      }
+    }
+    const functionName = this.actualValue.name || typeof this.actualValue === "function" ? "[anonymous function]" : this.actualValue.toString();
+    this.triggerResult(
+      didThrow,
+      `      Expected ${functionName} to ${this.positive ? "throw" : "not throw"} an exception ${!this.positive && errorMessage ? `, but an error with the message "${errorMessage}" was thrown` : ""}`
+    );
+    if (ErrorType) {
+      this.triggerResult(
+        typeMatch,
+        `      Expected Error type '${ErrorType.name}', but the error is not an instance of it`
+      );
+    }
+  }
+}
+const describe = async function(moduleName, callback) {
+  print("\n" + moduleName);
+  await callback();
+  beforeEachCb = null;
+  afterEachCb = null;
+};
+const runtimeMatch = async function(onRuntime, version) {
+  const currRuntime = await getRuntime();
+  const foundRuntime = onRuntime.find((r) => currRuntime.includes(r));
+  if (!foundRuntime) {
+    return {
+      matched: false
+    };
+  }
+  if (typeof version === "string") {
+    if (!currRuntime.includes(version)) {
+      return {
+        matched: false
+      };
+    }
+  }
+  return {
+    matched: true,
+    runtime: foundRuntime,
+    version
+  };
+};
+const on = async function(onRuntime, version, callback) {
+  if (typeof onRuntime === "string") {
+    onRuntime = [onRuntime];
+  }
+  if (typeof version === "function") {
+    callback = version;
+    version = void 0;
+  }
+  const { matched } = await runtimeMatch(onRuntime, version);
+  if (!matched) {
+    ++countTestsIgnored;
+    return;
+  }
+  print(`
+On ${onRuntime.join(", ")}${version ? " " + version : ""}`);
+  await callback();
+};
+let beforeEachCb;
+let afterEachCb;
+const beforeEach = function(callback) {
+  beforeEachCb = callback;
+};
+const afterEach = function(callback) {
+  afterEachCb = callback;
+};
+const it = async function(expectation, callback) {
+  try {
+    if (typeof beforeEachCb === "function") {
+      await beforeEachCb();
+    }
+    await callback();
+    if (typeof afterEachCb === "function") {
+      await afterEachCb();
+    }
+    print(`  ${GREEN}\u2714${RESET} ${GRAY}${expectation}${RESET}`);
+  } catch (e) {
+    print(`  ${RED}\u274C${RESET} ${GRAY}${expectation}${RESET}`);
+    print(`${RED}${e.message}${RESET}`);
+    if (e.stack)
+      print(e.stack);
+  }
+};
+const expect = function(actualValue) {
+  ++countTestsOverall;
+  const expecter = new MatcherFactory(actualValue, true);
+  return expecter;
+};
+const assert = function(success, message) {
+  ++countTestsOverall;
+  if (!success) {
+    ++countTestsFailed;
+  }
+  nodeAssert(success, message);
+};
+assert.strictEqual = function(actual, expected, message) {
+  ++countTestsOverall;
+  try {
+    nodeAssert.strictEqual(actual, expected, message);
+  } catch (error) {
+    ++countTestsFailed;
+    throw error;
+  }
+};
+assert.throws = function(promiseFn, ...args) {
+  ++countTestsOverall;
+  let error;
+  try {
+    promiseFn();
+  } catch (e) {
+    error = e;
+  }
+  if (!error)
+    ++countTestsFailed;
+  nodeAssert.throws(() => {
+    if (error)
+      throw error;
+  }, args[0], args[1]);
+};
+assert.deepStrictEqual = function(actual, expected, message) {
+  ++countTestsOverall;
+  try {
+    nodeAssert.deepStrictEqual(actual, expected, message);
+  } catch (error) {
+    ++countTestsFailed;
+    throw error;
+  }
+};
+const runTests = async function(namespaces) {
+  for (const subNamespace in namespaces) {
+    const namespace = namespaces[subNamespace];
+    if (typeof namespace === "function") {
+      await namespace();
+    } else if (typeof namespace === "object") {
+      await runTests(namespace);
+    }
+  }
+};
+const printResult = () => {
+  if (countTestsIgnored) {
+    print(`
+${BLUE}\u2714 ${countTestsIgnored} ignored test${countTestsIgnored > 1 ? "s" : ""}${RESET}`);
+  }
+  if (countTestsFailed) {
+    print(`
+${RED}\u274C ${countTestsFailed} of ${countTestsOverall} tests failed${RESET}`);
+  } else {
+    print(`
+${GREEN}\u2714 ${countTestsOverall} completed${RESET}`);
+  }
+};
+const getRuntime = async () => {
+  if (runtime && runtime !== "Unknown") {
+    return runtime;
+  }
+  if (globalThis.Deno?.version?.deno) {
+    return "Deno " + globalThis.Deno?.version?.deno;
+  } else {
+    let process = globalThis.process;
+    if (!process) {
+      try {
+        process = await import("process");
+      } catch (error) {
+        console.error(error);
+        console.warn(error.message);
+        runtime = "Unknown";
+      }
+    }
+    if (process?.versions?.gjs) {
+      runtime = "Gjs " + process.versions.gjs;
+    } else if (process?.versions?.node) {
+      runtime = "Node.js " + process.versions.node;
+    }
+  }
+  return runtime || "Unknown";
+};
+const printRuntime = async () => {
+  const runtime2 = await getRuntime();
+  print(`
+Running on ${runtime2}`);
+};
+const run = async (namespaces) => {
+  printRuntime().then(async () => {
+    return runTests(namespaces).then(() => {
+      printResult();
+      print();
+      mainloop?.quit();
+    });
+  });
+  mainloop?.run();
+};
+var src_default = {
+  run,
+  assert,
+  expect,
+  it,
+  afterEach,
+  beforeEach,
+  on,
+  describe,
+  print
+};
+export {
+  afterEach,
+  assert,
+  beforeEach,
+  src_default as default,
+  describe,
+  expect,
+  it,
+  on,
+  print,
+  run
+};

package/lib/esm/spy.js

@@ -0,0 +1,139 @@
+function spy(f) {
+  const calls = [];
+  function spy2(...args) {
+    let retv;
+    try {
+      retv = f ? f.apply(this, args) : void 0;
+    } catch (error) {
+      calls.push({
+        type: "throw",
+        this: this,
+        arguments: args,
+        throw: error
+      });
+      throw error;
+    }
+    calls.push({
+      type: "return",
+      this: this,
+      arguments: args,
+      return: retv
+    });
+    return retv;
+  }
+  Object.defineProperties(spy2, {
+    calls: descriptors.calls(calls),
+    returnedCalls: descriptors.returnedCalls,
+    thrownCalls: descriptors.thrownCalls,
+    firstCall: descriptors.firstCall,
+    lastCall: descriptors.lastCall,
+    firstReturnedCall: descriptors.firstReturnedCall,
+    lastReturnedCall: descriptors.lastReturnedCall,
+    firstThrownCall: descriptors.firstThrownCall,
+    lastThrownCall: descriptors.lastThrownCall,
+    reset: descriptors.reset,
+    toString: descriptors.toString(f)
+  });
+  return spy2;
+}
+const descriptors = {
+  calls(value) {
+    return { value, configurable: true };
+  },
+  returnedCalls: {
+    get: function returnedCalls() {
+      return this.calls.filter(isReturned);
+    },
+    configurable: true
+  },
+  thrownCalls: {
+    get: function thrownCalls() {
+      return this.calls.filter(isThrown);
+    },
+    configurable: true
+  },
+  firstCall: {
+    get: function firstCall() {
+      return this.calls[0] || null;
+    },
+    configurable: true
+  },
+  lastCall: {
+    get: function lastCall() {
+      return this.calls[this.calls.length - 1] || null;
+    },
+    configurable: true
+  },
+  firstReturnedCall: {
+    get: function firstReturnedCall() {
+      for (let i = 0; i < this.calls.length; ++i) {
+        const call = this.calls[i];
+        if (isReturned(call)) {
+          return call;
+        }
+      }
+      return null;
+    },
+    configurable: true
+  },
+  lastReturnedCall: {
+    get: function lastReturnedCall() {
+      for (let i = this.calls.length - 1; i >= 0; --i) {
+        const call = this.calls[i];
+        if (isReturned(call)) {
+          return call;
+        }
+      }
+      return null;
+    },
+    configurable: true
+  },
+  firstThrownCall: {
+    get: function firstThrownCall() {
+      for (let i = 0; i < this.calls.length; ++i) {
+        const call = this.calls[i];
+        if (isThrown(call)) {
+          return call;
+        }
+      }
+      return null;
+    },
+    configurable: true
+  },
+  lastThrownCall: {
+    get: function lastThrownCall() {
+      for (let i = this.calls.length - 1; i >= 0; --i) {
+        const call = this.calls[i];
+        if (isThrown(call)) {
+          return call;
+        }
+      }
+      return null;
+    },
+    configurable: true
+  },
+  reset: {
+    value: function reset() {
+      ;
+      this.calls.length = 0;
+    },
+    configurable: true
+  },
+  toString(f) {
+    return {
+      value: function toString() {
+        return `/* The spy of */ ${f ? f.toString() : "function(){}"}`;
+      },
+      configurable: true
+    };
+  }
+};
+function isReturned(call) {
+  return call.type === "return";
+}
+function isThrown(call) {
+  return call.type === "throw";
+}
+export {
+  spy
+};

package/lib/types/index.d.ts

@@ -0,0 +1,61 @@
+import "@girs/gjs";
+export * from './spy.js';
+export interface Namespaces {
+    [key: string]: () => (Promise<void>) | Namespaces;
+}
+export type Callback = () => Promise<void>;
+export type Runtime = 'Gjs' | 'Deno' | 'Node.js' | 'Unknown' | 'Browser';
+export declare const print: typeof globalThis.print;
+declare class MatcherFactory {
+    protected readonly actualValue: any;
+    protected readonly positive: boolean;
+    not: MatcherFactory;
+    constructor(actualValue: any, positive: boolean, negated?: MatcherFactory);
+    triggerResult(success: boolean, msg: string): void;
+    to(callback: (actualValue: any) => boolean): void;
+    toBe(expectedValue: any): void;
+    toEqual(expectedValue: any): void;
+    toEqualArray(expectedValue: Array<any> | Uint8Array): void;
+    toMatch(expectedValue: any): void;
+    toBeDefined(): void;
+    toBeUndefined(): void;
+    toBeNull(): void;
+    toBeTruthy(): void;
+    toBeFalsy(): void;
+    toContain(needle: any): void;
+    toBeLessThan(greaterValue: number): void;
+    toBeGreaterThan(smallerValue: number): void;
+    toBeCloseTo(expectedValue: number, precision: number): void;
+    toThrow(ErrorType?: typeof Error): void;
+}
+export declare const describe: (moduleName: string, callback: Callback) => Promise<void>;
+/** E.g on('Deno', () {  it(...) }) */
+export declare const on: (onRuntime: Runtime | Runtime[], version: string | Callback, callback?: Callback) => Promise<void>;
+export declare const beforeEach: (callback?: Callback) => void;
+export declare const afterEach: (callback?: Callback) => void;
+export declare const it: (expectation: string, callback: () => void | Promise<void>) => Promise<void>;
+export declare const expect: (actualValue: any) => MatcherFactory;
+export declare const assert: {
+    (success: any, message?: string | Error): void;
+    strictEqual<T>(actual: unknown, expected: T, message?: string | Error): asserts actual is T;
+    throws(promiseFn: () => unknown, ...args: any[]): void;
+    deepStrictEqual<T_1>(actual: unknown, expected: T_1, message?: string | Error): asserts actual is T_1;
+};
+export declare const run: (namespaces: Namespaces) => Promise<void>;
+declare const _default: {
+    run: (namespaces: Namespaces) => Promise<void>;
+    assert: {
+        (success: any, message?: string | Error): void;
+        strictEqual<T>(actual: unknown, expected: T, message?: string | Error): asserts actual is T;
+        throws(promiseFn: () => unknown, ...args: any[]): void;
+        deepStrictEqual<T_1>(actual: unknown, expected: T_1, message?: string | Error): asserts actual is T_1;
+    };
+    expect: (actualValue: any) => MatcherFactory;
+    it: (expectation: string, callback: () => void | Promise<void>) => Promise<void>;
+    afterEach: (callback?: Callback) => void;
+    beforeEach: (callback?: Callback) => void;
+    on: (onRuntime: Runtime | Runtime[], version: string | Callback, callback?: Callback) => Promise<void>;
+    describe: (moduleName: string, callback: Callback) => Promise<void>;
+    print: typeof globalThis.print;
+};
+export default _default;

package/lib/types/spy.d.ts

@@ -0,0 +1,54 @@
+/** Spy. */
+export type Spy<T extends (...args: any[]) => any> = T & Spy.CallInformation<T>;
+export declare namespace Spy {
+    /** Information for calls on a spy. */
+    interface CallInformation<T extends (...args: any[]) => any> {
+        /** Information for each call. */
+        readonly calls: ReadonlyArray<Call<T>>;
+        /** Information for each returned call. */
+        readonly returnedCalls: ReadonlyArray<ReturnedCall<T>>;
+        /** Information for each thrown call. */
+        readonly thrownCalls: ReadonlyArray<ThrownCall<T>>;
+        /** Information of the first call. */
+        readonly firstCall: Call<T> | null;
+        /** Information of the last call. */
+        readonly lastCall: Call<T> | null;
+        /** Information of the first returned call. */
+        readonly firstReturnedCall: ReturnedCall<T> | null;
+        /** Information of the last returned call. */
+        readonly lastReturnedCall: ReturnedCall<T> | null;
+        /** Information of the first thrown call. */
+        readonly firstThrownCall: ThrownCall<T> | null;
+        /** Information of the last thrown call. */
+        readonly lastThrownCall: ThrownCall<T> | null;
+        /** Reset calls. */
+        reset(): void;
+    }
+    /** Information for each call. */
+    type Call<T extends (...args: any[]) => any> = ReturnedCall<T> | ThrownCall<T>;
+    /** Information for each returned call. */
+    interface ReturnedCall<T extends (...args: any[]) => any> {
+        type: "return";
+        this: This<T>;
+        arguments: Parameters<T>;
+        return: ReturnType<T>;
+    }
+    /** Information for each thrown call. */
+    interface ThrownCall<T extends (...args: any[]) => any> {
+        type: "throw";
+        this: This<T>;
+        arguments: Parameters<T>;
+        throw: any;
+    }
+}
+type This<T> = T extends (this: infer TT, ...args: any[]) => any ? TT : undefined;
+/**
+ * Create a spy.
+ */
+export declare function spy(): Spy<() => void>;
+/**
+ * Create a spy with a certain behavior.
+ * @param f The function of the spy's behavior.
+ */
+export declare function spy<T extends (...args: any[]) => any>(f: T): Spy<T>;
+export {};

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@gjsify/unit",
+  "version": "0.0.2",
+  "description": "A BDD-style testing framework for Gjs",
+  "main": "lib/cjs/index.js",
+  "module": "lib/esm/index.js",
+  "types": "lib/types/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./lib/types/index.d.ts",
+        "default": "./lib/esm/index.js"
+      },
+      "require": {
+        "types": "./lib/types/index.d.ts",
+        "default": "./lib/cjs/index.js"
+      }
+    }
+  },
+  "scripts": {
+    "print:name": "echo '@gjsify/unit'",
+    "clear": "rm -rf lib tsconfig.tsbuildinfo test.gjs.mjs test.gjs.mjs.meta.json test.node.mjs || exit 0",
+    "build": "yarn print:name && yarn build:gjsify && yarn build:types",
+    "build:gjsify": "gjsify build --library 'src/**/*.{ts,js}' --exclude 'src/**/*.spec.{mts,ts}' 'src/test.{mts,ts}'",
+    "build:types": "tsc --project tsconfig.types.json",
+    "build:test": "yarn build:test:gjs && yarn build:test:node",
+    "build:test:gjs": "gjsify build src/test.mts --app gjs --outfile test.gjs.mjs",
+    "build:test:node": "gjsify build src/test.mts --app node --outfile test.node.mjs",
+    "test": "yarn print:name && yarn build:gjsify && yarn build:test && yarn test:node && yarn test:gjs",
+    "test:gjs": "gjs -m test.gjs.mjs",
+    "test:node": "node test.node.mjs"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/gjsify/unit.git"
+  },
+  "keywords": [
+    "gjs",
+    "test",
+    "tdd",
+    "bdd"
+  ],
+  "author": "Philipp Hoffmann <mail@philipphoffmann.de>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/gjsify/unit/issues"
+  },
+  "homepage": "https://github.com/gjsify/unit#readme",
+  "devDependencies": {
+    "@girs/gjs": "^3.1.0",
+    "@gjsify/cli": "^0.0.2",
+    "typescript": "^5.1.3"
+  },
+  "dependencies": {
+    "@gjsify/assert": "^0.0.2",
+    "@gjsify/process": "^0.0.2"
+  }
+}