@gjsify/unit 0.0.2

package/README.md

@@ -0,0 +1,96 @@
+# @gjsify/unit
+
+A BDD-style testing framework for Gjs, Deno and Node.js, forked from [gjsunit](https://github.com/philipphoffmann/gjsunit).
+
+## What it is
+unit is a BDD-style testing framework for the gjs Javascript binding for Gnome 4x which can be used to write Gnome 4x applications and extensions. It's syntax is totally stolen from [Jasmine](http://jasmine.github.io/) ;-).
+
+## How to use it
+
+First you need to install the package together with `@gjsify/cli`:
+
+```bash
+yarn install @gjsify/cli @gjsify/unit -D
+```
+
+After that you can build and run your tests:
+
+```bash
+gjsify build test-runner.ts --platform gjs --outfile test.gjs.js
+gjs -m test.gjs.js
+```
+
+## Writing test suites
+
+In your test directory you can have as many subdirectories and test files as you wish. unit will just run all of them.
+A test suite could look like this:
+
+```js
+// my-module.spec.ts
+
+import { describe, it, expect } from '@gjsify/unit';
+import MyModule from './my-module.js';
+
+export default async () => {
+
+	await describe('MyModule', async () => {
+		await it('should say hello', async () => {
+			var module = new MyModule();
+
+			expect(module.hello()).toEqual('hello');
+			expect(module.hello()).not.toEqual('hi');
+		});
+	});
+
+}
+```
+
+```js
+// test-runner.ts
+
+import { run } from '@gjsify/unit';
+import myTestSuite from './my-module.spec.ts';
+
+run({myTestSuite});
+```
+
+
+Your test files must expose a function. This is the function you will call in your test runner. In your test suite you can use `describe` and `it` to cluster your test suite. You can then use `expect` to capture the value you want to express expectations on. The available methods for expressing expectations are:
+- `toBe(value)` (checks using ===)
+- `toEqual(value)` (checks using ==)
+- `toMatch(regex)` (checks using String.prototype.match and a regular expression)
+- `toBeDefined()` (checks whether the actual value is defined)
+- `toBeUndefined()` (opposite of the above)
+- `toBeNull()` (checks whether the actual value is null)
+- `toBeTruthy()` (checks whether the actual value is castable to true)
+- `toBeFalsy()` (checks whether the actual value is castable to false)
+- `toContain(needle)` (checks whether an array contains the needle value)
+- `toBeLessThan(value)`
+- `toBeGreaterThan(value)`
+- `toBeCloseTo(value, precision)` (can check float values until a given precision)
+- `to(callback)` (checks the value using the provided callback (which gets passed the actual value as first parameter))
+
+There is also a `spy` method with which the call of methods can be checked, this is forked from [mysticatea/spy](https://github.com/mysticatea/spy).
+
+```js
+// spy.spec.ts
+
+import { describe, it, expect, spy } from '@gjsify/unit';
+
+export default async () => {
+    await describe("'spy' function", async () => {
+        await it("should have a calls length of 1 after called one time.", async () => {
+            const f = spy()
+            f()
+
+            expect(f.calls.length).toBe(1)
+        })
+	})
+}
+```
+
+I recommend looking at the test suite for examples.
+
+Happy testing!
+
+

package/lib/cjs/index.js

@@ -0,0 +1,390 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var src_exports = {};
+__export(src_exports, {
+  afterEach: () => afterEach,
+  assert: () => assert,
+  beforeEach: () => beforeEach,
+  default: () => src_default,
+  describe: () => describe,
+  expect: () => expect,
+  it: () => it,
+  on: () => on,
+  print: () => print,
+  run: () => run
+});
+module.exports = __toCommonJS(src_exports);
+var import_gjs = require("@girs/gjs");
+__reExport(src_exports, require("./spy.js"), module.exports);
+var import_assert = __toESM(require("assert"), 1);
+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;
+  }
+  (0, import_assert.default)(success, message);
+};
+assert.strictEqual = function(actual, expected, message) {
+  ++countTestsOverall;
+  try {
+    import_assert.default.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;
+  import_assert.default.throws(() => {
+    if (error)
+      throw error;
+  }, args[0], args[1]);
+};
+assert.deepStrictEqual = function(actual, expected, message) {
+  ++countTestsOverall;
+  try {
+    import_assert.default.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
+};

package/lib/cjs/spy.js

@@ -0,0 +1,158 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var spy_exports = {};
+__export(spy_exports, {
+  spy: () => spy
+});
+module.exports = __toCommonJS(spy_exports);
+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";
+}