qunitx 0.8.3 → 0.9.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "qunitx",
   "type": "module",
-  "version": "0.8.3",
+  "version": "0.9.0",
   "description": "A universal test framework for testing any js file on node.js, browser or deno with QUnit API",
   "author": "Izel Nakri",
   "license": "MIT",
@@ -61,7 +61,7 @@
     "ts-node": ">=10.7.0"
   },
   "volta": {
-    "node": "20.4.0"
+    "node": "20.5.0"
   },
   "prettier": {
     "printWidth": 100,

package/shims/deno/assert.js

@@ -9,39 +9,79 @@ export class AssertionError extends DenoAssertionError {
   }
 }
 
-// NOTE: Maybe do the expect, steps in some object, and also do timeout and async(?)
-export default {
-  _steps: [],
-  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);
+export default class Assert {
+  AssertionError = AssertionError
+
+  #asyncOps = [];
+
+  constructor(module, test) {
+    this.test = test || module;
+  }
+  _incrementAssertionCount() {
+    this.test.totalExecutedAssertions++;
+  }
+  timeout(number) {
+    if (!Number.isInteger(number) || number < 0) {
+      throw new Error('assert.timeout() expects a positive integer.');
+    }
+
+    this.test.timeout = number;
+  }
+  step(message) {
+    let assertionMessage = message;
+    let result = !!message;
+
+    this.test.steps.push(message);
+
+    if (typeof message === 'undefined' || message === '') {
+      assertionMessage = 'You must provide a message to assert.step';
+    } else if (typeof message !== 'string') {
+      assertionMessage = 'You must provide a string value to assert.step';
+      result = false;
+    }
 
-    this._steps.length = 0;
+    this.pushResult({
+      result,
+      message: assertionMessage
+    });
+  }
+  verifySteps(steps, message = 'Verify steps failed!') {
+    this.deepEqual(this.test.steps, steps, message);
+    this.test.steps.length = 0;
+  }
+  expect(number) {
+    if (!Number.isInteger(number) || number < 0) {
+      throw new Error('assert.expect() expects a positive integer.');
+    }
 
-    return result;
-  },
-  expect() {
-    return () => {}; // NOTE: NOT implemented
-  },
+    this.test.expectedAssertionCount = number;
+  }
   async() {
-    return () => {}; // NOTE: noop, node should have sanitizeResources
-  },
+    let resolveFn;
+    let done = new Promise(resolve => { resolveFn = resolve; });
+
+    this.#asyncOps.push(done);
+
+    return () => { resolveFn(); };
+  }
+  async waitForAsyncOps() {
+    return Promise.all(this.#asyncOps);
+  }
   pushResult(resultInfo = {}) {
-    if (!result) {
+    this._incrementAssertionCount();
+    if (!resultInfo.result) {
       throw new AssertionError({
         actual: resultInfo.actual,
         expected: resultInfo.expected,
-        message: result.Infomessage || 'Custom assertion failed!',
+        message: resultInfo.message || 'Custom assertion failed!',
         stackStartFn: this.pushResult,
       });
     }
-  },
+
+    return this;
+  }
   ok(state, message) {
+    this._incrementAssertionCount();
     if (!state) {
       throw new AssertionError({
         actual: state,
@@ -50,8 +90,9 @@ export default {
         stackStartFn: this.ok,
       });
     }
-  },
+  }
   notOk(state, message) {
+    this._incrementAssertionCount();
     if (state) {
       throw new AssertionError({
         actual: state,
@@ -60,8 +101,9 @@ export default {
         stackStartFn: this.notOk,
       });
     }
-  },
+  }
   true(state, message) {
+    this._incrementAssertionCount();
     if (state !== true) {
       throw new AssertionError({
         actual: state,
@@ -70,8 +112,9 @@ export default {
         stackStartFn: this.true,
       });
     }
-  },
+  }
   false(state, message) {
+    this._incrementAssertionCount();
     if (state !== false) {
       throw new AssertionError({
         actual: state,
@@ -80,8 +123,9 @@ export default {
         stackStartFn: this.false,
       });
     }
-  },
+  }
   equal(actual, expected, message) {
+    this._incrementAssertionCount();
     if (actual != expected) {
       throw new AssertionError({
         actual,
@@ -91,8 +135,9 @@ export default {
         stackStartFn: this.equal,
       });
     }
-  },
+  }
   notEqual(actual, expected, message) {
+    this._incrementAssertionCount();
     if (actual == expected) {
       throw new AssertionError({
         actual,
@@ -102,11 +147,12 @@ export default {
         stackStartFn: this.notEqual,
       });
     }
-  },
+  }
   propEqual(actual, expected, message) {
+    this._incrementAssertionCount();
     let targetActual = objectValues(actual);
     let targetExpected = objectValues(expected);
-    if (!window.QUnit.equiv(targetActual, targetExpected)) {
+    if (!QUnit.equiv(targetActual, targetExpected)) {
       throw new AssertionError({
         actual: targetActual,
         expected: targetExpected,
@@ -114,11 +160,12 @@ export default {
         stackStartFn: this.propEqual,
       });
     }
-  },
+  }
   notPropEqual(actual, expected, message) {
+    this._incrementAssertionCount();
     let targetActual = objectValues(actual);
     let targetExpected = objectValues(expected);
-    if (window.QUnit.equiv(targetActual, targetExpected)) {
+    if (QUnit.equiv(targetActual, targetExpected)) {
       throw new AssertionError({
         actual: targetActual,
         expected: targetExpected,
@@ -126,11 +173,12 @@ export default {
         stackStartFn: this.notPropEqual,
       });
     }
-  },
+  }
   propContains(actual, expected, message) {
+    this._incrementAssertionCount();
     let targetActual = objectValuesSubset(actual, expected);
     let targetExpected = objectValues(expected, false);
-    if (!window.QUnit.equiv(targetActual, targetExpected)) {
+    if (!QUnit.equiv(targetActual, targetExpected)) {
       throw new AssertionError({
         actual: targetActual,
         expected: targetExpected,
@@ -138,11 +186,12 @@ export default {
         stackStartFn: this.propContains,
       });
     }
-  },
+  }
   notPropContains(actual, expected, message) {
+    this._incrementAssertionCount();
     let targetActual = objectValuesSubset(actual, expected);
     let targetExpected = objectValues(expected);
-    if (window.QUnit.equiv(targetActual, targetExpected)) {
+    if (QUnit.equiv(targetActual, targetExpected)) {
       throw new AssertionError({
         actual: targetActual,
         expected: targetExpected,
@@ -150,9 +199,10 @@ export default {
         stackStartFn: this.notPropContains,
       });
     }
-  },
+  }
   deepEqual(actual, expected, message) {
-    if (!window.QUnit.equiv(actual, expected)) {
+    this._incrementAssertionCount();
+    if (!QUnit.equiv(actual, expected)) {
       throw new AssertionError({
         actual,
         expected,
@@ -161,9 +211,10 @@ export default {
         stackStartFn: this.deepEqual,
       });
     }
-  },
+  }
   notDeepEqual(actual, expected, message) {
-    if (window.QUnit.equiv(actual, expected)) {
+    this._incrementAssertionCount();
+    if (QUnit.equiv(actual, expected)) {
       throw new AssertionError({
         actual,
         expected,
@@ -172,8 +223,9 @@ export default {
         stackStartFn: this.notDeepEqual,
       });
     }
-  },
+  }
   strictEqual(actual, expected, message) {
+    this._incrementAssertionCount();
     if (actual !== expected) {
       throw new AssertionError({
         actual,
@@ -183,8 +235,9 @@ export default {
         stackStartFn: this.strictEqual,
       });
     }
-  },
+  }
   notStrictEqual(actual, expected, message) {
+    this._incrementAssertionCount();
     if (actual === expected) {
       throw new AssertionError({
         actual,
@@ -194,8 +247,9 @@ export default {
         stackStartFn: this.notStrictEqual,
       });
     }
-  },
+  }
   throws(blockFn, expectedInput, assertionMessage) {
+    this?._incrementAssertionCount();
     let [expected, message] = validateExpectedExceptionArgs(expectedInput, assertionMessage, 'rejects');
     if (typeof blockFn !== 'function') {
       throw new AssertionError({
@@ -228,8 +282,9 @@ export default {
       message: 'Function passed to `assert.throws` did not throw an exception!',
       stackStartFn: this.throws,
     });
-  },
+  }
   async rejects(promise, expectedInput, assertionMessage) {
+    this._incrementAssertionCount();
     let [expected, message] = validateExpectedExceptionArgs(expectedInput, assertionMessage, 'rejects');
     let then = promise && promise.then;
     if (typeof then !== 'function') {
@@ -276,4 +331,3 @@ ${inspect(expected)}`
 function inspect(value) {
   return util.inspect(value, { depth: 10, colors: true, compact: false });
 }
-

package/shims/deno/index.js

@@ -1,48 +1,238 @@
 import {
-  afterEach,
-  beforeEach,
   beforeAll,
   afterAll,
   describe,
   it,
 } from "https://deno.land/std@0.192.0/testing/bdd.ts";
-import assert from './assert.js';
+import Assert from './assert.js';
 
-// TODO: TEST beforeEach, before, afterEach, after, currently not sure if they work!
-export const module = async function(moduleName, runtimeOptions, moduleContent) {
-  let targetRuntimeOptions = moduleContent ? Object.assign(runtimeOptions, { name: moduleName }) : { name: moduleName };
-  let targetModuleContent = moduleContent ? moduleName : runtimeOptions;
+class TestContext {
+  name;
 
-  return describe(assignDefaultValues(targetRuntimeOptions, { concurrency: true }), async function() {
-    return await targetModuleContent({ before: beforeAll, after: afterAll, beforeEach, afterEach }, {
-      moduleName,
-      options: runtimeOptions
+  #module;
+  get module() {
+    return this.#module;
+  }
+  set module(value) {
+    this.#module = value;
+  }
+
+  #assert;
+  get assert() {
+    return this.#assert;
+  }
+  set assert(value) {
+    this.#assert = value;
+  }
+
+  #timeout;
+  get timeout() {
+    return this.#timeout;
+  }
+  set timeout(value) {
+    this.#timeout = value;
+  }
+
+  #steps = [];
+  get steps() {
+    return this.#steps;
+  }
+  set steps(value) {
+    this.#steps = value;
+  }
+
+  #expectedAssertionCount;
+  get expectedAssertionCount() {
+    return this.#expectedAssertionCount;
+  }
+  set expectedAssertionCount(value) {
+    this.#expectedAssertionCount = value;
+  }
+
+  #totalExecutedAssertions = 0;
+  get totalExecutedAssertions() {
+    return this.#totalExecutedAssertions;
+  }
+  set totalExecutedAssertions(value) {
+    this.#totalExecutedAssertions = value;
+  }
+
+  constructor(name, moduleContext) {
+    if (moduleContext) {
+      this.name = `${moduleContext.name} | ${name}`;
+      this.module = moduleContext;
+      this.module.tests.push(this);
+      this.assert = new Assert(moduleContext, this);
+    }
+  }
+
+  finish() {
+    if (this.totalExecutedAssertions === 0) {
+      this.assert.pushResult({
+        result: false,
+        actual: this.totalExecutedAssertions,
+        expected: '> 0',
+        message: `Expected at least one assertion to be run for test: ${this.name}`,
+      });
+    } else if (this.steps.length > 0) {
+      this.assert.pushResult({
+        result: false,
+        actual: this.steps,
+        expected: [],
+        message: `Expected assert.verifySteps() to be called before end of test after using assert.step(). Unverified steps: ${this.steps.join(', ')}`,
+      });
+    } else if (this.expectedAssertionCount && this.expectedAssertionCount !== this.totalExecutedAssertions) {
+      this.assert.pushResult({
+        result: false,
+        actual: this.totalExecutedAssertions,
+        expected: this.expectedAssertionCount,
+        message: `Expected ${this.expectedAssertionCount} assertions, but ${this.totalExecutedAssertions} were run for test: ${this.name}`,
+      });
+    }
+  }
+}
+
+class ModuleContext extends TestContext {
+  static currentModuleChain = [];
+
+  static get lastModule() {
+    return this.currentModuleChain[this.currentModuleChain.length - 1];
+  }
+
+  #tests = [];
+  get tests() {
+    return this.#tests;
+  }
+
+  #beforeEachHooks = [];
+  get beforeEachHooks() {
+    return this.#beforeEachHooks;
+  }
+
+  #afterEachHooks = [];
+  get afterEachHooks() {
+    return this.#afterEachHooks;
+  }
+
+  #moduleChain = [];
+  get moduleChain() {
+    return this.#moduleChain;
+  }
+  set moduleChain(value) {
+    this.#moduleChain = value;
+  }
+
+  constructor(name) {
+    super(name);
+
+    let parentModule = ModuleContext.currentModuleChain[ModuleContext.currentModuleChain.length - 1];
+
+    ModuleContext.currentModuleChain.push(this);
+
+    this.moduleChain = ModuleContext.currentModuleChain.slice(0);
+    this.name = parentModule ? `${parentModule.name} > ${name}` : name;
+    this.assert = new Assert(this);
+  }
+}
+
+export const module = (moduleName, runtimeOptions, moduleContent) => {
+  let targetRuntimeOptions = moduleContent ? runtimeOptions : {};
+  let targetModuleContent = moduleContent ? moduleContent : runtimeOptions;
+  let moduleContext = new ModuleContext(moduleName);
+
+  return describe(moduleName, { concurrency: true, ...targetRuntimeOptions }, async function () {
+    let beforeHooks = [];
+    let afterHooks = [];
+
+    beforeAll(async function () {
+      Object.assign(moduleContext, moduleContext.moduleChain.reduce((result, module) => {
+        const { name, ...moduleWithoutName } = module;
+
+        return Object.assign(result, moduleWithoutName, {
+          steps: result.steps.concat(module.steps),
+          expectedAssertionCount: module.expectedAssertionCount
+            ? module.expectedAssertionCount
+            : result.expectedAssertionCount
+        });
+      }, { steps: [], expectedAssertionCount: undefined }));
+
+      for (let hook of beforeHooks) {
+        await hook.call(moduleContext, moduleContext.assert);
+      }
+
+      moduleContext.tests.forEach((testContext) => {
+        const { name, ...moduleContextWithoutName } = moduleContext;
+
+        Object.assign(testContext, moduleContextWithoutName, {
+          steps: moduleContext.steps,
+          totalExecutedAssertions: moduleContext.totalExecutedAssertions,
+          expectedAssertionCount: moduleContext.expectedAssertionCount,
+        });
+      });
+    });
+    afterAll(async () => {
+      for (const assert of moduleContext.tests.map(testContext => testContext.assert)) {
+        await assert.waitForAsyncOps();
+      }
+
+      let targetContext = moduleContext.tests[moduleContext.tests.length - 1];
+      for (let j = afterHooks.length - 1; j >= 0; j--) {
+        await afterHooks[j].call(targetContext, targetContext.assert);
+      }
+
+      moduleContext.tests.forEach(testContext => testContext.finish());
     });
+
+    targetModuleContent.call(moduleContext, {
+      before(beforeFn) {
+        return beforeHooks.push(beforeFn);
+      },
+      beforeEach(beforeEachFn) {
+        return moduleContext.beforeEachHooks.push(beforeEachFn);
+      },
+      afterEach(afterEachFn) {
+        return moduleContext.afterEachHooks.push(afterEachFn);
+      },
+      after(afterFn) {
+        return afterHooks.push(afterFn);
+      }
+    }, { moduleName, options: runtimeOptions });
+
+    ModuleContext.currentModuleChain.pop();
   });
 }
 
-export const test = async function(testName, runtimeOptions, testContent) {
-  let targetRuntimeOptions = testContent ? Object.assign(runtimeOptions, { name: testName }) : { name: testName };
+export const test = (testName, runtimeOptions, testContent) => {
+  let moduleContext = ModuleContext.lastModule;
+  if (!moduleContext) {
+    throw new Error(`Test '${testName}' called outside of module context.`);
+  }
+
+  let targetRuntimeOptions = testContent ? runtimeOptions : {};
   let targetTestContent = testContent ? testContent : runtimeOptions;
+  let context = new TestContext(testName, moduleContext);
 
-  return it(targetRuntimeOptions, async function() {
-    let metadata = { testName, options: targetRuntimeOptions, expectedTestCount: undefined };
-    return await targetTestContent(assert, metadata);
+  return it(testName, { concurrency: true, ...targetRuntimeOptions }, async function () {
+    let result;
+    for (let module of context.module.moduleChain) {
+      for (let hook of module.beforeEachHooks) {
+        await hook.call(context, context.assert);
+      }
+    }
 
-    if (expectedTestCount) {
+    result = await targetTestContent.call(context, context.assert, { testName, options: runtimeOptions });
 
-    }
-  });
-}
+    await context.assert.waitForAsyncOps();
 
-function assignDefaultValues(options, defaultValues) {
-  for (let key in defaultValues) {
-    if (options[key] === undefined) {
-      options[key] = defaultValues[key];
+    for (let i = context.module.moduleChain.length - 1; i >= 0; i--) {
+      let module = context.module.moduleChain[i];
+      for (let j = module.afterEachHooks.length - 1; j >= 0; j--) {
+        await module.afterEachHooks[j].call(context, context.assert);
+      }
     }
-  }
 
-  return options;
+    return result;
+  });
 }
 
-export default { module, test, assert };
+export default { module, test, config: {} };

package/shims/node/assert.js

@@ -1,41 +1,88 @@
 import QUnit from '../../vendor/qunit.js';
 import { objectValues, objectValuesSubset, validateExpectedExceptionArgs, validateException } from '../shared/index.js';
-import assert, { AssertionError } from 'node:assert';
+import assert, { AssertionError as _AssertionError } from 'node:assert';
 import util from 'node:util';
 
-// NOTE: Maybe do the expect, steps in some object, and also do timeout and async(?)
-export default {
-  _steps: [],
-  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);
+export const AssertionError = _AssertionError;
+
+// More: contexts needed for timeout
+// NOTE: QUnit API provides assert on hooks, which makes it hard to make it concurrent
+// NOTE: Another approach for a global report Make this._assertions.set(this.currentTest, (this._assertions.get(this.currentTest) || 0) + 1); for pushResult
+// NOTE: This should *always* be a singleton(?), passed around as an argument for hooks. Seems difficult with concurrency. Singleton needs to be a concurrent data structure.
+
+export default class Assert {
+  AssertionError = _AssertionError;
+
+  #asyncOps = [];
+
+  constructor(module, test) {
+    this.test = test || module;
+  }
+  _incrementAssertionCount() {
+    this.test.totalExecutedAssertions++;
+  }
+  timeout(number) {
+    if (!Number.isInteger(number) || number < 0) {
+      throw new Error('assert.timeout() expects a positive integer.');
+    }
+
+    this.test.timeout = number;
+  }
+  step(message) {
+    let assertionMessage = message;
+    let result = !!message;
 
-    this._steps.length = 0;
+    this.test.steps.push(message);
 
-    return result;
-  },
-  expect() {
-    return () => {}; // NOTE: NOT implemented
-  },
+    if (typeof message === 'undefined' || message === '') {
+      assertionMessage = 'You must provide a message to assert.step';
+    } else if (typeof message !== 'string') {
+      assertionMessage = 'You must provide a string value to assert.step';
+      result = false;
+    }
+
+    this.pushResult({
+      result,
+      message: assertionMessage
+    });
+  }
+  verifySteps(steps, message = 'Verify steps failed!') {
+    this.deepEqual(this.test.steps, steps, message);
+    this.test.steps.length = 0;
+  }
+  expect(number) {
+    if (!Number.isInteger(number) || number < 0) {
+      throw new Error('assert.expect() expects a positive integer.');
+    }
+
+    this.test.expectedAssertionCount = number;
+  }
   async() {
-    return () => {}; // NOTE: noop, node should have sanitizeResources
-  },
+    let resolveFn;
+    let done = new Promise(resolve => { resolveFn = resolve; });
+
+    this.#asyncOps.push(done);
+
+    return () => { resolveFn(); };
+  }
+  async waitForAsyncOps() {
+    return Promise.all(this.#asyncOps);
+  }
   pushResult(resultInfo = {}) {
-    if (!result) {
+    this._incrementAssertionCount();
+    if (!resultInfo.result) {
       throw new AssertionError({
         actual: resultInfo.actual,
         expected: resultInfo.expected,
-        message: result.Infomessage || 'Custom assertion failed!',
+        message: resultInfo.message || 'Custom assertion failed!',
         stackStartFn: this.pushResult,
       });
     }
-  },
+
+    return this;
+  }
   ok(state, message) {
+    this._incrementAssertionCount();
     if (!state) {
       throw new AssertionError({
         actual: state,
@@ -44,8 +91,9 @@ export default {
         stackStartFn: this.ok,
       });
     }
-  },
+  }
   notOk(state, message) {
+    this._incrementAssertionCount();
     if (state) {
       throw new AssertionError({
         actual: state,
@@ -54,8 +102,9 @@ export default {
         stackStartFn: this.notOk,
       });
     }
-  },
+  }
   true(state, message) {
+    this._incrementAssertionCount();
     if (state !== true) {
       throw new AssertionError({
         actual: state,
@@ -64,8 +113,9 @@ export default {
         stackStartFn: this.true,
       });
     }
-  },
+  }
   false(state, message) {
+    this._incrementAssertionCount();
     if (state !== false) {
       throw new AssertionError({
         actual: state,
@@ -74,8 +124,9 @@ export default {
         stackStartFn: this.false,
       });
     }
-  },
+  }
   equal(actual, expected, message) {
+    this._incrementAssertionCount();
     if (actual != expected) {
       throw new AssertionError({
         actual,
@@ -85,8 +136,9 @@ export default {
         stackStartFn: this.equal,
       });
     }
-  },
+  }
   notEqual(actual, expected, message) {
+    this._incrementAssertionCount();
     if (actual == expected) {
       throw new AssertionError({
         actual,
@@ -96,8 +148,9 @@ export default {
         stackStartFn: this.notEqual,
       });
     }
-  },
+  }
   propEqual(actual, expected, message) {
+    this._incrementAssertionCount();
     let targetActual = objectValues(actual);
     let targetExpected = objectValues(expected);
     if (!QUnit.equiv(targetActual, targetExpected)) {
@@ -108,8 +161,9 @@ export default {
         stackStartFn: this.propEqual,
       });
     }
-  },
+  }
   notPropEqual(actual, expected, message) {
+    this._incrementAssertionCount();
     let targetActual = objectValues(actual);
     let targetExpected = objectValues(expected);
     if (QUnit.equiv(targetActual, targetExpected)) {
@@ -120,8 +174,9 @@ export default {
         stackStartFn: this.notPropEqual,
       });
     }
-  },
+  }
   propContains(actual, expected, message) {
+    this._incrementAssertionCount();
     let targetActual = objectValuesSubset(actual, expected);
     let targetExpected = objectValues(expected, false);
     if (!QUnit.equiv(targetActual, targetExpected)) {
@@ -132,8 +187,9 @@ export default {
         stackStartFn: this.propContains,
       });
     }
-  },
+  }
   notPropContains(actual, expected, message) {
+    this._incrementAssertionCount();
     let targetActual = objectValuesSubset(actual, expected);
     let targetExpected = objectValues(expected);
     if (QUnit.equiv(targetActual, targetExpected)) {
@@ -144,8 +200,9 @@ export default {
         stackStartFn: this.notPropContains,
       });
     }
-  },
+  }
   deepEqual(actual, expected, message) {
+    this._incrementAssertionCount();
     if (!QUnit.equiv(actual, expected)) {
       throw new AssertionError({
         actual,
@@ -155,8 +212,9 @@ export default {
         stackStartFn: this.deepEqual,
       });
     }
-  },
+  }
   notDeepEqual(actual, expected, message) {
+    this._incrementAssertionCount();
     if (QUnit.equiv(actual, expected)) {
       throw new AssertionError({
         actual,
@@ -166,8 +224,9 @@ export default {
         stackStartFn: this.notDeepEqual,
       });
     }
-  },
+  }
   strictEqual(actual, expected, message) {
+    this._incrementAssertionCount();
     if (actual !== expected) {
       throw new AssertionError({
         actual,
@@ -177,8 +236,9 @@ export default {
         stackStartFn: this.strictEqual,
       });
     }
-  },
+  }
   notStrictEqual(actual, expected, message) {
+    this._incrementAssertionCount();
     if (actual === expected) {
       throw new AssertionError({
         actual,
@@ -188,8 +248,9 @@ export default {
         stackStartFn: this.notStrictEqual,
       });
     }
-  },
+  }
   throws(blockFn, expectedInput, assertionMessage) {
+    this?._incrementAssertionCount();
     let [expected, message] = validateExpectedExceptionArgs(expectedInput, assertionMessage, 'rejects');
     if (typeof blockFn !== 'function') {
       throw new AssertionError({
@@ -222,8 +283,9 @@ export default {
       message: 'Function passed to `assert.throws` did not throw an exception!',
       stackStartFn: this.throws,
     });
-  },
+  }
   async rejects(promise, expectedInput, assertionMessage) {
+    this._incrementAssertionCount();
     let [expected, message] = validateExpectedExceptionArgs(expectedInput, assertionMessage, 'rejects');
     let then = promise && promise.then;
     if (typeof then !== 'function') {

package/shims/node/index.js

@@ -1,75 +1,237 @@
-import { run, describe, it, before, after, beforeEach, afterEach } from 'node:test';
-import assert from './assert.js';
+import { describe, it, before as beforeAll, after as afterAll } from 'node:test';
+import Assert from './assert.js';
 
-export const module = async function(moduleName, runtimeOptions, moduleContent) {
+// NOTE: node.js beforeEach & afterEach is buggy because the TestContext it has is NOT correct reference when called, it gets the last context
+// NOTE: QUnit expect() logic is buggy in nested modules
+// NOTE: after gets the last direct children test of the module, not last defined context of a module(last defined context is a module)
+
+class TestContext {
+  name;
+
+  #module;
+  get module() {
+    return this.#module;
+  }
+  set module(value) {
+    this.#module = value;
+  }
+
+  #assert;
+  get assert() {
+    return this.#assert;
+  }
+  set assert(value) {
+    this.#assert = value;
+  }
+
+  #timeout;
+  get timeout() {
+    return this.#timeout;
+  }
+  set timeout(value) {
+    this.#timeout = value;
+  }
+
+  #steps = [];
+  get steps() {
+    return this.#steps;
+  }
+  set steps(value) {
+    this.#steps = value;
+  }
+
+  #expectedAssertionCount;
+  get expectedAssertionCount() {
+    return this.#expectedAssertionCount;
+  }
+  set expectedAssertionCount(value) {
+    this.#expectedAssertionCount = value;
+  }
+
+  #totalExecutedAssertions = 0;
+  get totalExecutedAssertions() {
+    return this.#totalExecutedAssertions;
+  }
+  set totalExecutedAssertions(value) {
+    this.#totalExecutedAssertions = value;
+  }
+
+  constructor(name, moduleContext) {
+    if (moduleContext) {
+      this.name = `${moduleContext.name} | ${name}`;
+      this.module = moduleContext;
+      this.module.tests.push(this);
+      this.assert = new Assert(moduleContext, this);
+    }
+  }
+
+  finish() {
+    if (this.totalExecutedAssertions === 0) {
+      this.assert.pushResult({
+        result: false,
+        actual: this.totalExecutedAssertions,
+        expected: '> 0',
+        message: `Expected at least one assertion to be run for test: ${this.name}`,
+      });
+    } else if (this.steps.length > 0) {
+      this.assert.pushResult({
+        result: false,
+        actual: this.steps,
+        expected: [],
+        message: `Expected assert.verifySteps() to be called before end of test after using assert.step(). Unverified steps: ${this.steps.join(', ')}`,
+      });
+    } else if (this.expectedAssertionCount && this.expectedAssertionCount !== this.totalExecutedAssertions) {
+      this.assert.pushResult({
+        result: false,
+        actual: this.totalExecutedAssertions,
+        expected: this.expectedAssertionCount,
+        message: `Expected ${this.expectedAssertionCount} assertions, but ${this.totalExecutedAssertions} were run for test: ${this.name}`,
+      });
+    }
+  }
+}
+
+class ModuleContext extends TestContext {
+  static currentModuleChain = [];
+
+  static get lastModule() {
+    return this.currentModuleChain[this.currentModuleChain.length - 1];
+  }
+
+  #tests = [];
+  get tests() {
+    return this.#tests;
+  }
+
+  #beforeEachHooks = [];
+  get beforeEachHooks() {
+    return this.#beforeEachHooks;
+  }
+
+  #afterEachHooks = [];
+  get afterEachHooks() {
+    return this.#afterEachHooks;
+  }
+
+  #moduleChain = [];
+  get moduleChain() {
+    return this.#moduleChain;
+  }
+  set moduleChain(value) {
+    this.#moduleChain = value;
+  }
+
+  constructor(name) {
+    super(name);
+
+    let parentModule = ModuleContext.currentModuleChain[ModuleContext.currentModuleChain.length - 1];
+
+    ModuleContext.currentModuleChain.push(this);
+
+    this.moduleChain = ModuleContext.currentModuleChain.slice(0);
+    this.name = parentModule ? `${parentModule.name} > ${name}` : name;
+    this.assert = new Assert(this);
+  }
+}
+
+export const module = (moduleName, runtimeOptions, moduleContent) => {
   let targetRuntimeOptions = moduleContent ? runtimeOptions : {};
   let targetModuleContent = moduleContent ? moduleContent : runtimeOptions;
+  let moduleContext = new ModuleContext(moduleName);
+
+  return describe(moduleName, { concurrency: true, ...targetRuntimeOptions }, async function () {
+    let beforeHooks = [];
+    let afterHooks = [];
+
+    beforeAll(async function () {
+      Object.assign(moduleContext, moduleContext.moduleChain.reduce((result, module) => {
+        const { name, ...moduleWithoutName } = module;
+
+        return Object.assign(result, moduleWithoutName, {
+          steps: result.steps.concat(module.steps),
+          expectedAssertionCount: module.expectedAssertionCount
+            ? module.expectedAssertionCount
+            : result.expectedAssertionCount
+        });
+      }, { steps: [], expectedAssertionCount: undefined }));
+
+      for (let hook of beforeHooks) {
+        await hook.call(moduleContext, moduleContext.assert);
+      }
 
-  return describe(moduleName, assignDefaultValues(targetRuntimeOptions, { concurrency: true }), async function() {
-    return await targetModuleContent({ before, after, beforeEach, afterEach }, {
-      moduleName,
-      options: runtimeOptions
+      moduleContext.tests.forEach((testContext) => {
+        const { name, ...moduleContextWithoutName } = moduleContext;
+
+        Object.assign(testContext, moduleContextWithoutName, {
+          steps: moduleContext.steps,
+          totalExecutedAssertions: moduleContext.totalExecutedAssertions,
+          expectedAssertionCount: moduleContext.expectedAssertionCount,
+        });
+      });
+    });
+    afterAll(async () => {
+      for (const assert of moduleContext.tests.map(testContext => testContext.assert)) {
+        await assert.waitForAsyncOps();
+      }
+
+      let targetContext = moduleContext.tests[moduleContext.tests.length - 1];
+      for (let j = afterHooks.length - 1; j >= 0; j--) {
+        await afterHooks[j].call(targetContext, targetContext.assert);
+      }
+
+      moduleContext.tests.forEach(testContext => testContext.finish());
     });
+
+    targetModuleContent.call(moduleContext, {
+      before(beforeFn) {
+        return beforeHooks.push(beforeFn);
+      },
+      beforeEach(beforeEachFn) {
+        return moduleContext.beforeEachHooks.push(beforeEachFn);
+      },
+      afterEach(afterEachFn) {
+        return moduleContext.afterEachHooks.push(afterEachFn);
+      },
+      after(afterFn) {
+        return afterHooks.push(afterFn);
+      }
+    }, { moduleName, options: runtimeOptions });
+
+    ModuleContext.currentModuleChain.pop();
   });
 }
 
-export const test = async function(testName, runtimeOptions, testContent) {
+export const test = (testName, runtimeOptions, testContent) => {
+  let moduleContext = ModuleContext.lastModule;
+  if (!moduleContext) {
+    throw new Error(`Test '${testName}' called outside of module context.`);
+  }
+
   let targetRuntimeOptions = testContent ? runtimeOptions : {};
   let targetTestContent = testContent ? testContent : runtimeOptions;
+  let context = new TestContext(testName, moduleContext);
 
-  return it(testName, assignDefaultValues(targetRuntimeOptions, { concurrency: true }), async function() {
-    return await targetTestContent(assert, { testName, options: runtimeOptions });
-  });
-}
+  return it(testName, { concurrency: true, ...targetRuntimeOptions }, async function () {
+    let result;
+    for (let module of context.module.moduleChain) {
+      for (let hook of module.beforeEachHooks) {
+        await hook.call(context, context.assert);
+      }
+    }
+
+    result = await targetTestContent.call(context, context.assert, { testName, options: runtimeOptions });
 
-function assignDefaultValues(options, defaultValues) {
-  for (let key in defaultValues) {
-    if (options[key] === undefined) {
-      options[key] = defaultValues[key];
+    await context.assert.waitForAsyncOps();
+
+    for (let i = context.module.moduleChain.length - 1; i >= 0; i--) {
+      let module = context.module.moduleChain[i];
+      for (let j = module.afterEachHooks.length - 1; j >= 0; j--) {
+        await module.afterEachHooks[j].call(context, context.assert);
+      }
     }
-  }
 
-  return options;
+    return result;
+  });
 }
 
 export default { module, test, config: {} };
-
-// NOTE: later maybe expose these as well:
-
-// import QUnit from './vendor/qunit.js';
-
-// QUnit.config.autostart = false;
-
-// export const isLocal = QUnit.isLocal;
-// export const on = QUnit.on;
-// export const test = QUnit.test;
-// export const skip = QUnit.skip;
-// export const start = QUnit.start;
-// export const is = QUnit.is;
-// export const extend = QUnit.extend;
-// export const stack = QUnit.stack;
-// export const onUnhandledRejection = QUnit.onUnhandledRejection;
-// export const assert = QUnit.assert;
-// export const dump = QUnit.dump;
-// export const done = QUnit.done;
-// export const testStart = QUnit.testStart;
-// export const moduleStart = QUnit.moduleStart;
-// export const version = QUnit.version;
-// export const module = QUnit.module;
-// export const todo = QUnit.todo;
-// export const only = QUnit.only;
-// export const config = QUnit.config;
-// export const objectType = QUnit.objectType;
-// export const load = QUnit.load;
-// export const onError = QUnit.onError;
-// export const pushFailure = QUnit.pushFailure;
-// export const equiv = QUnit.equiv;
-// export const begin = QUnit.begin;
-// export const log = QUnit.log;
-// export const testDone = QUnit.testDone;
-// export const moduleDone = QUnit.moduleDone;
-// export const diff = QUnit.diff;
-
-// export default Object.assign(QUnit, {
-//   QUnitxVersion: '0.0.1'
-// });