qunitx 0.8.0 → 0.8.2

package/README.md

@@ -1,26 +1,33 @@
+![docker-based-ci](https://github.com/izelnakri/qunitx/workflows/docker-based-ci/badge.svg)
+[![npm version](https://badge.fury.io/js/qunitx.svg)](https://badge.fury.io/js/qunitx)
+
 # QUnitX
 
-Experimental improvements, suggestions for qunit CLI
+***Truly universal testing for JavaScript with the oldest, most mature & flexible
+testing API in the JavaScript ecosystem. Run the same test file in node.js, deno or in the browser***
 
-![QunitX terminal output](https://raw.githubusercontent.com/izelnakri/qunitx/main/docs/qunitx-help-stdout.png)
+Your test JS/TS file(s) can now run interchangably in different runtimes with
+the default test runner of node.js or deno, or with a browser runner of your
+choice!
 
-Default test output is TAP (_Test-Anything-Protocol_) thus you can use any tap reporter of your choice to display test
-output in anyway you like. Example:
+[![asciicast](https://asciinema.org/a/597066.svg)](https://asciinema.org/a/597066?autoplay=1)
 
-```zsh
-# using it with tap-difflet TAP reporter:
-qunitx tests/attachments tests/user | npx tap-difflet
-```
+In the browser you can use the same browser test/filter UI of
+[QUnit](https://github.com/qunitjs/qunit) and share the web links with your
+colleagues thanks to the test filters through query params feature of QUnit:
 
-#### Installation:
+[QUnit Test Suite Example](https://objectmodel.js.org/test/?moduleId=6e15ed5f&moduleId=950ec9c5)
 
-```zsh
-npm install -g qunitx
+**UI visual automated tests also possible with QUnit!**
 
-qunitx
-```
+![QunitX terminal output](https://raw.githubusercontent.com/izelnakri/qunitx/main/docs/qunitx-help-stdout.png)
+
+### Installation: Node & Deno
+
+This is a 0-dependency test library that runs code in your target runtime(node,
+deno or browser) test runner. Since a default test runner is a new feature of node.js, please use node.js v20.3+.
 
-In order to use qunitx to execute existing qunit tests please change:
+In order to use qunitx to convert qunit tests files please change:
 
 ```js
 import { module, test } from 'qunit';
@@ -32,7 +39,7 @@ import { module, test } from 'qunitx';
 Example:
 
 ```js
-// in some-test.js: (typescript is also supported for --browser mode and node.js with --loader flag)
+// in some-test.js: (typescript also works)
 import { module, test } from 'qunitx';
 import $ from 'jquery';
 
@@ -56,37 +63,91 @@ module('Basic sanity check', function (hooks) {
 # you can run the test in node with ES modules package.json{ "type": "module" }
 $ node --test some-test.js
 
-# Suggested mode: if you want to run it in CI/google chrome:
+# TypeScript also works, make sure on node.js mode, tsconfig.json exists with compilerOptions.module & compilerOptions.moduleResolution set to "NodeNext":
+$ node --loader=ts-node/esm/transpile-only --test some-test.ts
+
+# You can use the new watch mode of node.js to watch for files or folder patterns
+$ node --test --watch some-test.js some-folder/*.js
+
+# You can also run this test on deno. Unfortunately today deno requires one extra step to create a deno.json file:
+$ echo '{"imports": { "qunitx": "https://esm.sh/qunitx/shims/deno/index.js" } }' > deno.json
+
+# then run the tests in default deno test runner:
+$ deno test some-test.js
+```
+
+### Installation: Browser
+
+QUnitX mainly proxies to [QUnit
+API](https://api.qunitjs.com/QUnit/module/#hooks-on-nested-modules) in browser.
+You can use [QUnitX CLI](https://github.com/izelnakri/qunitx-cli) to get your
+browser tests to stdout/CI or use the watch mode during the development.
 
+```zsh
+# Install QUnitX browser runner/cli:
+$ npm install -g qunitx-cli
+$ qunitx
 $ qunitx some-test.js
 
 # with browser output enabled:
-
 $ qunitx some-test.js --debug
 
-# TypeScript also works, make sure on node.js mode, tsconfig.json exists with compilerOptions.module & compilerOptions.moduleResolution set to "NodeNext":
+```
 
-$ node --loader=ts-node/esm/transpile-only --test some-test.ts
+### Concurrency options
 
-$ qunitx some-test.ts --debug
+QUnitX API accepts an optional options object as 2nd argument to:
+- `QUnit.module(testName, optionsOrHandler?, handler?)`
+- `QUnit.test(testName, optionsOrHandler?, handler?)`
 
-```
+So you can run tests in parallel(default) or in series. You can even run them
+through the [node.js test runner run()
+api](https://nodejs.org/api/test.html#runoptions):
 
-### Code coverage
+```js
+// in some-test.js: (typescript also works)
+import { module, test } from 'qunitx';
+import $ from 'jquery';
 
-Since QUnitX proxies to default node.js test runner in when executed with node, you can use any code coverage tool you like. When running the tests in `qunit`(the browser mode) code coverage support is limited.
-```
-c8 node test/attachments test/user
+module('Basic sanity check', function (hooks) {
+  test('it works', { concurrency: false }, function (assert) {
+    assert.equal(true, true);
+  });
+
+  module('More advanced cases', { concurrency: false, permissions: { read: true }, sanitizeExit: false }, function (hooks) {
+    test('deepEqual works', function (assert) {
+      assert.deepEqual({ username: 'izelnakri' }, { username: 'izelnakri' });
+    });
+    test('can import ES & npm modules', function (assert) {
+      assert.ok(Object.keys($));
+    });
+  });
+});
 ```
 
-You can browse [c8 documentation](https://github.com/bcoe/c8) for all configuration options.
+### Code coverage
+
+Since QUnitX proxies to default node.js test runner in when executed with node,
+you can use any code coverage tool you like. When running the tests in
+`qunit`(the browser mode) code coverage support is limited.
 
-Implementing code coverage for the browser mode is currently not possible because we use esbuild --bundle feature to
-create a JS bundles for testing in the browser, this could be instrumented with `puppeteer-to-istanbul` however
-instrumentation includes transpiled npm imports of `qunitx` and other potential npm imports developer
-includes in the code, this cannot be filtered since potential filtering can only occur after the `esbuild` bundling.
-When chrome browser and puppeteer fully supports ES asset maps we can remove esbuild from the browser mode, run
-everything in deno and make instrumentation for code coverage possible with the default v8 instrumentation.
+```zsh
+$ c8 node --test test/attachments test/user
+```
 
-Esbuild plugin interface is an ongoing development, we might be able to figure out a way to generate this instrumentation
-with esbuild in the future, which could allow code coverage for --browser mode.
+You can browse [c8 documentation](https://github.com/bcoe/c8) for all
+configuration options.
+
+Implementing code coverage for the browser mode is currently not possible
+because we use esbuild --bundle feature to create a JS bundles for testing in
+the browser, this could be instrumented with `puppeteer-to-istanbul` however
+instrumentation includes transpiled npm imports of `qunitx` and other potential
+npm imports developer includes in the code, this cannot be filtered since
+potential filtering can only occur after the `esbuild` bundling. When chrome
+browser and puppeteer fully supports ES asset maps we can remove esbuild from
+the browser mode, run everything in deno and make instrumentation for code
+coverage possible with the default v8 instrumentation.
+
+Esbuild plugin interface is an ongoing development, we might be able to figure
+out a way to generate this instrumentation with esbuild in the future, which
+could allow code coverage for --browser mode.

package/deno.lock

@@ -7,5 +7,16 @@
     "https://deno.land/std@0.192.0/testing/_test_suite.ts": "30f018feeb3835f12ab198d8a518f9089b1bcb2e8c838a8b615ab10d5005465c",
     "https://deno.land/std@0.192.0/testing/asserts.ts": "e16d98b4d73ffc4ed498d717307a12500ae4f2cbe668f1a215632d19fcffc22f",
     "https://deno.land/std@0.192.0/testing/bdd.ts": "59f7f7503066d66a12e50ace81bfffae5b735b6be1208f5684b630ae6b4de1d0"
+  },
+  "npm": {
+    "specifiers": {
+      "@types/node": "@types/node@18.16.19"
+    },
+    "packages": {
+      "@types/node@18.16.19": {
+        "integrity": "sha512-IXl7o+R9iti9eBW4Wg2hx1xQDig183jj7YLn8F7udNceyfkbn1ZxmzZXuak20gR40D7pIkIY1kYGx5VIGbaHKA==",
+        "dependencies": {}
+      }
+    }
   }
 }

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "qunitx",
   "type": "module",
-  "version": "0.8.0",
-  "description": "Framework testing any js file on node.js, browser or deno with QUnit API",
+  "version": "0.8.2",
+  "description": "A universal test framework for testing any js file on node.js, browser or deno with QUnit API",
   "author": "Izel Nakri",
   "license": "MIT",
   "keywords": [
@@ -45,16 +45,20 @@
     "release:alpha": "node_modules/.bin/release-it --preRelease=alpha --no-git.requireUpstream",
     "release:beta": "node_modules/.bin/release-it --preRelease=beta --no-git.requireUpstream",
     "release": "node_modules/.bin/release-it",
-    "test": "node --test test/index.js",
-    "test:deno": "deno test --allow-read --allow-env --allow-run test/commands/index.js",
-    "test:dev": "node --test test/index.js | tee test-output.log"
+    "test": "npm run test:browser && npm run test:node && npm run test:deno",
+    "test:dev": "npm run test | tee test-output.log",
+    "test:browser": "qunitx test/index.js --debug",
+    "test:deno": "deno test --allow-read --allow-env --allow-run test/index.js",
+    "test:node": "node --test test/index.js"
   },
   "devDependencies": {
-    "ts-node": ">=10.7.0",
     "auto-changelog": "^2.4.0",
     "prettier": "^3.0.0",
     "qunit": "^2.19.4",
-    "release-it": "^16.1.0"
+    "qunitx": "^0.8.0",
+    "qunitx-cli": "^0.1.0",
+    "release-it": "^16.1.0",
+    "ts-node": ">=10.7.0"
   },
   "volta": {
     "node": "20.4.0"

package/shims/deno/assert.js

@@ -1,55 +1,228 @@
-import { assert, assertEquals, assertNotEquals, assertStrictEquals, assertNotStrictEquals, assertObjectMatch, assertRejects, assertThrows } from "https://deno.land/std@0.192.0/testing/asserts.ts";
+import { AssertionError as DenoAssertionError, assertRejects, assertThrows } from "https://deno.land/std@0.192.0/testing/asserts.ts";
+import '../../vendor/qunit.js';
+import { objectValuesSubset } from '../shared/index.js';
+import util from 'node:util';
 
-class AssertionError extends Error {
-  // override name = 'AssertionError';
-  constructor(message) {
-    super(message);
+export class AssertionError extends DenoAssertionError {
+  constructor(object) {
+    super(object.message);
   }
 }
 
+// NOTE: Maybe do the expect, steps in some object, and also do timeout and async(?)
 export default {
   _steps: [],
-  async() {
-    return () => {}; // NOTE: noop, deno has sanitizeResources
+  timeout() {
+    return true; // NOTE: NOT implemented
+  },
+  step(value = '') {
+    this._steps.push(value);
+  },
+  verifySteps(steps, message = 'Verify steps failed!') {
+    const result = this.deepEqual(this._steps, steps, message);
+
+    this._steps.length = 0;
+
+    return result;
   },
-  deepEqual: assertEquals,
-  equal: assertEquals,
   expect() {
     return () => {}; // NOTE: NOT implemented
   },
-  false(state, message) {
-    return assert(state === false, message);
+  async() {
+    return () => {}; // NOTE: noop, node should have sanitizeResources
+  },
+  pushResult(resultInfo = {}) {
+    if (!result) {
+      throw new AssertionError({
+        actual: resultInfo.actual,
+        expected: resultInfo.expected,
+        message: result.Infomessage || 'Custom assertion failed!',
+        stackStartFn: this.pushResult,
+      });
+    }
+  },
+  ok(state, message) {
+    if (!state) {
+      throw new AssertionError({
+        actual: state,
+        expected: true,
+        message: message || `Expected argument to be truthy, it was: ${inspect(state)}`,
+        stackStartFn: this.ok,
+      });
+    }
   },
-  notDeepEqual: assertNotEquals,
-  notEqual: assertNotEquals,
   notOk(state, message) {
-    return assert(!state, message);
+    if (state) {
+      throw new AssertionError({
+        actual: state,
+        expected: false,
+        message: message || `Expected argument to be falsy, it was: ${inspect(state)}`,
+        stackStartFn: this.notOk,
+      });
+    }
   },
-  notPropContains() {
-    throw new AssertionError('assert.notPropContains is not implemented for deno on QUnit');
+  true(state, message) {
+    if (state === true) {
+      throw new AssertionError({
+        actual: state,
+        expected: true,
+        message: message || `Expected argument to be true, it was: ${inspect(state)}`,
+        stackStartFn: this.true,
+      });
+    }
   },
-  notPropEqual() {
-    throw new AssertionError('assert.notPropEqual is not implemented for deno on QUnit');
+  false(state, message) {
+    if (state === false) {
+      throw new AssertionError({
+        actual: state,
+        expected: true,
+        message: message || `Expected argument to be false, it was: ${inspect(state)}`,
+        stackStartFn: this.false,
+      });
+    }
   },
-  notStrictEqual: assertNotStrictEquals,
-  ok: assert,
-  propContains: assertObjectMatch,
-  pushResult() {
-    return () => {}; // NOTE: NOT implemented
+  equal(actual, expected, message) {
+    if (actual == expected) {
+      throw new AssertionError({
+        actual,
+        expected,
+        message: message || `Expected: ${defaultMessage(actual, 'should equal to:', expected)}`,
+        operator: '==',
+        stackStartFn: this.equal,
+      });
+    }
   },
-  rejects: assertRejects,
-  step(value = '') {
-    this._steps.push(value);
+  notEqual(actual, expected, message) {
+    if (actual != expected) {
+      throw new AssertionError({
+        actual,
+        expected,
+        operator: '!=',
+        message: message || `Expected: ${defaultMessage(actual, 'should notEqual to:', expected)}`,
+        stackStartFn: this.notEqual,
+      });
+    }
   },
-  strictEqual: assertStrictEquals,
-  throws: assertThrows,
-  timeout() {
-    return true; // NOTE: NOT implemented
+  propEqual(actual, expected, message) {
+    let targetActual = objectValues(actual);
+    let targetExpected = objectValues(expected);
+    if (!window.QUnit.window.QUnit.equiv(targetActual, targetExpected)) {
+      throw new AssertionError({
+        actual: targetActual,
+        expected: targetExpected,
+        message: message || `Expected properties to be propEqual: ${defaultMessage(targetActual, 'should propEqual to:', targetExpected)}`,
+        stackStartFn: this.propEqual,
+      });
+    }
   },
-  true(state, message) {
-    return assert(state === true, message);
+  notPropEqual(actual, expected, message) {
+    let targetActual = objectValues(actual);
+    let targetExpected = objectValues(expected);
+    if (window.QUnit.equiv(targetActual, targetExpected)) {
+      throw new AssertionError({
+        actual: targetActual,
+        expected: targetExpected,
+        message: message || `Expected properties to NOT be propEqual: ${defaultMessage(targetActual, 'should notPropEqual to:', targetExpected)}`,
+        stackStartFn: this.notPropEqual,
+      });
+    }
   },
-  verifySteps(steps, message = 'Verify steps failed!') {
-    return assertEquals(this._steps, steps, message);
-  }
+  propContains(actual, expected, message) {
+    let targetActual = objectValuesSubset(actual, expected);
+    let targetExpected = objectValues(expected, false);
+    if (!window.QUnit.equiv(targetActual, targetExpected)) {
+      throw new AssertionError({
+        actual: targetActual,
+        expected: targetExpected,
+        message: message || `propContains assertion fail on: ${defaultMessage(targetActual, 'should propContains to:', targetExpected)}`,
+        stackStartFn: this.propContains,
+      });
+    }
+  },
+  notPropContains(actual, expected, message) {
+    let targetActual = objectValuesSubset(actual, expected);
+    let targetExpected = objectValues(expected);
+    if (window.QUnit.equiv(targetActual, targetExpected)) {
+      throw new AssertionError({
+        actual: targetActual,
+        expected: targetExpected,
+        message: message || `notPropContains assertion fail on: ${defaultMessage(targetActual, 'should notPropContains of:', targetExpected)}`,
+        stackStartFn: this.notPropContains,
+      });
+    }
+  },
+  deepEqual(actual, expected, message) {
+    if (!window.QUnit.equiv(actual, expected)) {
+      throw new AssertionError({
+        actual,
+        expected,
+        message: message || `Expected values to be deepEqual: ${defaultMessage(actual, 'should deepEqual to:', expected)}`,
+        operator: 'deepEqual',
+        stackStartFn: this.deepEqual,
+      });
+    }
+  },
+  notDeepEqual(actual, expected, message) {
+    if (window.QUnit.equiv(actual, expected)) {
+      throw new AssertionError({
+        actual,
+        expected,
+        message: message || `Expected values to be NOT deepEqual: ${defaultMessage(actual, 'should notDeepEqual to:', expected)}`,
+        operator: 'notDeepEqual',
+        stackStartFn: this.notDeepEqual,
+      });
+    }
+  },
+  strictEqual(actual, expected, message) {
+    if (actual !== expected) {
+      throw new AssertionError({
+        actual,
+        expected,
+        message: message || `Expected: ${defaultMessage(actual, 'is strictEqual to:', expected)}`,
+        operator: 'strictEqual',
+        stackStartFn: this.strictEqual,
+      });
+    }
+  },
+  notStrictEqual(actual, expected, message) {
+    if (actual === expected) {
+      throw new AssertionError({
+        actual,
+        expected,
+        message: message || `Expected: ${defaultMessage(actual, 'is notStrictEqual to:', expected)}`,
+        operator: 'notStrictEqual',
+        stackStartFn: this.notStrictEqual,
+      });
+    }
+  },
+  throws: assertThrows,
+  rejects: assertRejects,
 };
+
+function objectValues(obj) {
+  let allowArray = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+  let vals = allowArray && is('array', obj) ? [] : {};
+
+  for (var key in obj) {
+    if (hasOwn$1.call(obj, key)) {
+      let val = obj[key];
+      vals[key] = val === Object(val) ? objectValues(val, allowArray) : val;
+    }
+  }
+
+  return vals;
+}
+
+function defaultMessage(actual, description, expected) {
+  return `
+
+${inspect(actual)}
+
+${description}
+
+${inspect(expected)}`
+}
+
+function inspect(value) {
+  return util.inspect(value, { depth: 10, colors: true, compact: false });
+}

package/shims/node/assert.js

@@ -1,55 +1,222 @@
-import assert from 'node:assert';
+import QUnit from '../../vendor/qunit.js';
+import { objectValuesSubset } from '../shared/index.js';
+import assert, { AssertionError } from 'node:assert';
+import util from 'node:util';
 
-// TODO: write test cases for these
-// TODO: basically keep going until const { message } = new assert.AssertionError({ actual, expected, operator, message });
+// NOTE: Maybe do the expect, steps in some object, and also do timeout and async(?)
 export default {
   _steps: [],
-  async() {
-    return () => {}; // NOTE: noop, node should have sanitizeResources
+  timeout() {
+    return true; // NOTE: NOT implemented
+  },
+  step(value = '') {
+    this._steps.push(value);
+  },
+  verifySteps(steps, message = 'Verify steps failed!') {
+    const result = this.deepEqual(this._steps, steps, message);
+
+    this._steps.length = 0;
+
+    return result;
   },
-  deepEqual: assert.deepStrictEqual,
-  equal: assert.strictEqual,
   expect() {
     return () => {}; // NOTE: NOT implemented
   },
-  false(state, message) {
-    return assert.strictEqual(state, false, message);
+  async() {
+    return () => {}; // NOTE: noop, node should have sanitizeResources
+  },
+  pushResult(resultInfo = {}) {
+    if (!result) {
+      throw new AssertionError({
+        actual: resultInfo.actual,
+        expected: resultInfo.expected,
+        message: result.Infomessage || 'Custom assertion failed!',
+        stackStartFn: this.pushResult,
+      });
+    }
+  },
+  ok(state, message) {
+    if (!state) {
+      throw new AssertionError({
+        actual: state,
+        expected: true,
+        message: message || `Expected argument to be truthy, it was: ${inspect(state)}`,
+        stackStartFn: this.ok,
+      });
+    }
   },
-  notDeepEqual: assert.notDeepStrictEqual,
-  notEqual: assert.notStrictEqual,
   notOk(state, message) {
-    return assert.ok(!state, message);
+    if (state) {
+      throw new AssertionError({
+        actual: state,
+        expected: false,
+        message: message || `Expected argument to be falsy, it was: ${inspect(state)}`,
+        stackStartFn: this.notOk,
+      });
+    }
   },
-  notPropContains() {
-    // NOTE: NOT implemented, maybe this is possible(?):
-    throw new AssertionError('assert.notPropContains is not implemented for node on QUnit');
+  true(state, message) {
+    if (state === true) {
+      throw new AssertionError({
+        actual: state,
+        expected: true,
+        message: message || `Expected argument to be true, it was: ${inspect(state)}`,
+        stackStartFn: this.true,
+      });
+    }
   },
-  notPropEqual() {
-    // NOTE: NOT implemented, maybe this is possible(?):
-    throw new AssertionError('assert.notPropEqual is not implemented node deno on QUnit');
+  false(state, message) {
+    if (state === false) {
+      throw new AssertionError({
+        actual: state,
+        expected: true,
+        message: message || `Expected argument to be false, it was: ${inspect(state)}`,
+        stackStartFn: this.false,
+      });
+    }
   },
-  notStrictEqual: assert.notStrictEqual,
-  ok: assert.ok,
-  propContains() {
-    // NOTE: NOT implemented, maybe this is possible(?):
-    throw new AssertionError('assert.notPropContains is not implemented for node on QUnit');
+  equal(actual, expected, message) {
+    if (actual == expected) {
+      throw new AssertionError({
+        actual,
+        expected,
+        message: message || `Expected: ${defaultMessage(actual, 'should equal to:', expected)}`,
+        operator: '==',
+        stackStartFn: this.equal,
+      });
+    }
   },
-  pushResult() {
-    return () => {}; // NOTE: NOT implemented, maybe this is possible(?);
+  notEqual(actual, expected, message) {
+    if (actual != expected) {
+      throw new AssertionError({
+        actual,
+        expected,
+        operator: '!=',
+        message: message || `Expected: ${defaultMessage(actual, 'should notEqual to:', expected)}`,
+        stackStartFn: this.notEqual,
+      });
+    }
   },
-  rejects: assert.rejects,
-  step(value = '') {
-    this._steps.push(value);
+  propEqual(actual, expected, message) {
+    let targetActual = objectValues(actual);
+    let targetExpected = objectValues(expected);
+    if (!QUnit.equiv(targetActual, targetExpected)) {
+      throw new AssertionError({
+        actual: targetActual,
+        expected: targetExpected,
+        message: message || `Expected properties to be propEqual: ${defaultMessage(targetActual, 'should propEqual to:', targetExpected)}`,
+        stackStartFn: this.propEqual,
+      });
+    }
   },
-  strictEqual: assert.strictEqual,
-  throws: assert.throws,
-  timeout() {
-    return true; // NOTE: NOT implemented
+  notPropEqual(actual, expected, message) {
+    let targetActual = objectValues(actual);
+    let targetExpected = objectValues(expected);
+    if (QUnit.equiv(targetActual, targetExpected)) {
+      throw new AssertionError({
+        actual: targetActual,
+        expected: targetExpected,
+        message: message || `Expected properties to NOT be propEqual: ${defaultMessage(targetActual, 'should notPropEqual to:', targetExpected)}`,
+        stackStartFn: this.notPropEqual,
+      });
+    }
   },
-  true(state, message) {
-    return assert.strictEqual(state, true, message);
+  propContains(actual, expected, message) {
+    let targetActual = objectValuesSubset(actual, expected);
+    let targetExpected = objectValues(expected, false);
+    if (!QUnit.equiv(targetActual, targetExpected)) {
+      throw new AssertionError({
+        actual: targetActual,
+        expected: targetExpected,
+        message: message || `propContains assertion fail on: ${defaultMessage(targetActual, 'should propContains to:', targetExpected)}`,
+        stackStartFn: this.propContains,
+      });
+    }
   },
-  verifySteps(steps, message = 'Verify steps failed!') {
-    return assert.deepStrictEqual(this._steps, steps, message);
-  }
+  notPropContains(actual, expected, message) {
+    let targetActual = objectValuesSubset(actual, expected);
+    let targetExpected = objectValues(expected);
+    if (QUnit.equiv(targetActual, targetExpected)) {
+      throw new AssertionError({
+        actual: targetActual,
+        expected: targetExpected,
+        message: message || `notPropContains assertion fail on: ${defaultMessage(targetActual, 'should notPropContains of:', targetExpected)}`,
+        stackStartFn: this.notPropContains,
+      });
+    }
+  },
+  deepEqual(actual, expected, message) {
+    if (!QUnit.equiv(actual, expected)) {
+      throw new AssertionError({
+        actual,
+        expected,
+        message: message || `Expected values to be deepEqual: ${defaultMessage(actual, 'should deepEqual to:', expected)}`,
+        operator: 'deepEqual',
+        stackStartFn: this.deepEqual,
+      });
+    }
+  },
+  notDeepEqual(actual, expected, message) {
+    if (QUnit.equiv(actual, expected)) {
+      throw new AssertionError({
+        actual,
+        expected,
+        message: message || `Expected values to be NOT deepEqual: ${defaultMessage(actual, 'should notDeepEqual to:', expected)}`,
+        operator: 'notDeepEqual',
+        stackStartFn: this.notDeepEqual,
+      });
+    }
+  },
+  strictEqual(actual, expected, message) {
+    if (actual !== expected) {
+      throw new AssertionError({
+        actual,
+        expected,
+        message: message || `Expected: ${defaultMessage(actual, 'is strictEqual to:', expected)}`,
+        operator: 'strictEqual',
+        stackStartFn: this.strictEqual,
+      });
+    }
+  },
+  notStrictEqual(actual, expected, message) {
+    if (actual === expected) {
+      throw new AssertionError({
+        actual,
+        expected,
+        message: message || `Expected: ${defaultMessage(actual, 'is notStrictEqual to:', expected)}`,
+        operator: 'notStrictEqual',
+        stackStartFn: this.notStrictEqual,
+      });
+    }
+  },
+  throws: assert.throws,
+  rejects: assert.rejects,
 };
+
+function objectValues(obj) {
+  let allowArray = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+  let vals = allowArray && is('array', obj) ? [] : {};
+
+  for (var key in obj) {
+    if (hasOwn$1.call(obj, key)) {
+      let val = obj[key];
+      vals[key] = val === Object(val) ? objectValues(val, allowArray) : val;
+    }
+  }
+
+  return vals;
+}
+
+function defaultMessage(actual, description, expected) {
+  return `
+
+${inspect(actual)}
+
+${description}
+
+${inspect(expected)}`
+}
+
+function inspect(value) {
+  return util.inspect(value, { depth: 10, colors: true, compact: false });
+}

package/shims/node/index.js

@@ -32,7 +32,7 @@ function assignDefaultValues(options, defaultValues) {
   return options;
 }
 
-export default { module, test, assert, config: {} };
+export default { module, test, config: {} };
 
 // NOTE: later maybe expose these as well:
 

package/shims/shared/index.js

@@ -0,0 +1,29 @@
+/**
+ * Recursively clone an object into a plain object, taking only the
+ * subset of own enumerable properties that exist a given model.
+ *
+ * @param {any} obj
+ * @param {any} model
+ * @return {Object}
+ */
+export function objectValuesSubset(obj, model) {
+  // Return primitive values unchanged to avoid false positives or confusing
+  // results from assert.propContains().
+  // E.g. an actual null or false wrongly equaling an empty object,
+  // or an actual string being reported as object not matching a partial object.
+  if (obj !== Object(obj)) {
+    return obj;
+  }
+
+  // Unlike objectValues(), subset arrays to a plain objects as well.
+  // This enables subsetting [20, 30] with {1: 30}.
+  var subset = {};
+  for (var key in model) {
+    if (hasOwn$1.call(model, key) && hasOwn$1.call(obj, key)) {
+      subset[key] = objectValuesSubset(obj[key], model[key]);
+    }
+  }
+  return subset;
+}
+
+export default { objectValuesSubset };

package/build.js

@@ -1,54 +0,0 @@
-import fs from 'fs/promises';
-
-let [qunitJS, qunitCSS, _] = await Promise.all([
-  fs.readFile('./node_modules/qunit/qunit/qunit.js'),
-  fs.readFile('./node_modules/qunit/qunit/qunit.css'),
-  fs.mkdir('./vendor', { recursive: true })
-]);
-
-let newQUnit = qunitJS.toString().replace(
-  'start: function start(count) {',
-  `reset: function() {
-		ProcessingQueue.finished = false;
-		globalStartCalled = false;
-		runStarted = false;
-
-		config.queue.length = 0;
-		config.modules.length = 0;
-		config.autostart = false;
-
-    Object.assign(config.stats, { total: 0, passed: 0, failed: 0, skipped: 0, todo: 0 });
-
-		[
-			"started", "updateRate", "filter", "depth", "current",
-			"pageLoaded", "timeoutHandler", "timeout", "pollution"
-		].forEach( ( key ) => delete config[ key ] );
-
-		const suiteReport = config.currentModule.suiteReport;
-
-		suiteReport.childSuites.length = 0;
-		delete suiteReport._startTime;
-		delete suiteReport._endTime;
-
-		config.modules.push( config.currentModule );
-  },
-  start: function start(count) {`);
-
-await Promise.all([
-  fs.writeFile('./vendor/qunit.js', newQUnit),
-  fs.writeFile('./vendor/qunit.css', qunitCSS),
-  createPackageJSONIfNotExists()
-]);
-
-async function createPackageJSONIfNotExists() {
-  try {
-    await fs.stat('./vendor/package.json');
-
-    return true;
-  } catch (error) {
-    await fs.writeFile('./vendor/package.json', JSON.stringify({
-      name: 'qunitx-vendor',
-      version: '0.0.1'
-    }));
-  }
-}