qunitx 1.0.3 → 1.0.4

package/README.md

@@ -170,16 +170,29 @@ import { module, test } from 'qunitx';
 
 ---
 
-## Concurrency options
+## QUnit compatibility
 
-`module()` and `test()` accept an optional options object forwarded directly to the underlying
-Node / Deno test runner:
+qunitx follows the same test-environment model as QUnit:
+
+- **Fresh context per test** — each test gets its own `this` object. Writes in one test never bleed into a sibling.
+- **Prototype-chain inheritance** — a parent module's `before()` hook sets properties on the module context. Each test inherits those properties, so reads work naturally (`this.x`) while writes stay local to the test.
+- **`before()` assertions** — attributed to the first test in the module (matching QUnit's attribution model).
+- **`after()` assertions** — attributed to the last test in the module.
+- **Hook ordering** — `before`/`beforeEach` run FIFO; `afterEach`/`after` run LIFO, exactly as in QUnit.
+
+> **Known difference:** In QUnit's browser runner, `before()` hook assertions are attributed to the first test in the *entire subtree* (including nested modules). In the Node/Deno adapters, they are attributed to the first *direct* test of the module. In the common case where direct tests appear before nested modules, the behavior is identical.
+
+---
+
+## Concurrency
+
+Tests run **sequentially by default** — matching QUnit's browser behavior where tests run one at a time. You can enable concurrency by passing options to the underlying Node / Deno runner:
 
 ```js
 import { module, test } from 'qunitx';
 
-// Run tests in this module serially
-module('Serial suite', { concurrency: false }, (hooks) => {
+// Enable parallel execution for this module (Node/Deno only)
+module('Parallel suite', { concurrency: true }, (hooks) => {
   test('first', (assert) => { assert.ok(true); });
   test('second', (assert) => { assert.ok(true); });
 });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "qunitx",
   "type": "module",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "description": "A universal test framework for testing any js file on node.js, browser or deno with QUnit API",
   "author": "Izel Nakri",
   "license": "MIT",
@@ -91,8 +91,8 @@
   "devDependencies": {
     "prettier": "^3.8.1",
     "qunit": "^2.25.0",
-    "qunitx": "^0.9.3",
-    "qunitx-cli": "^0.5.0"
+    "qunitx": "^1.0.3",
+    "qunitx-cli": "^0.5.3"
   },
   "volta": {
     "node": "24.14.0"

package/shims/deno/module.js

@@ -1,10 +1,6 @@
 import { describe, beforeAll, afterAll } from "jsr:@std/testing/bdd";
 import ModuleContext from '../shared/module-context.js';
 
-// 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)
-
 /**
  * Defines a test module (suite) for Deno's BDD test runner.
  *
@@ -37,40 +33,31 @@ export default function module(moduleName, runtimeOptions, moduleContent) {
   const targetModuleContent = moduleContent ? moduleContent : runtimeOptions;
   const moduleContext = new ModuleContext(moduleName);
 
-  describe(moduleName, { concurrency: true, ...targetRuntimeOptions }, function () {
+  describe(moduleName, { ...targetRuntimeOptions }, function () {
     const beforeHooks = [];
     const afterHooks = [];
 
     beforeAll(async function () {
-      Object.assign(moduleContext.context, moduleContext.moduleChain.reduce((result, module) => {
-        return Object.assign(result, module.context, {
-          steps: result.steps.concat(module.context.steps),
-          expectedAssertionCount: module.context.expectedAssertionCount
-            ? module.context.expectedAssertionCount
-            : result.expectedAssertionCount
-        });
-      }, { steps: [], expectedAssertionCount: undefined }));
+      // before() assertions are attributed to the first direct test only (matching QUnit's model).
+      // Tests inherit parent context via prototype chain, so no Object.assign needed.
+      const firstTest = moduleContext.tests[0];
+      const beforeAssert = firstTest ? firstTest.assert : moduleContext.assert;
 
       for (const hook of beforeHooks) {
-        await hook.call(moduleContext.context, moduleContext.assert);
-      }
-
-      for (let i = 0, len = moduleContext.tests.length; i < len; i++) {
-        Object.assign(moduleContext.tests[i], moduleContext.context, {
-          steps: moduleContext.context.steps,
-          totalExecutedAssertions: moduleContext.context.totalExecutedAssertions,
-          expectedAssertionCount: moduleContext.context.expectedAssertionCount,
-        });
+        await hook.call(moduleContext.userContext, beforeAssert);
       }
     });
+
     afterAll(async () => {
       for (const testContext of moduleContext.tests) {
         await testContext.assert.waitForAsyncOps();
       }
 
-      const targetContext = moduleContext.tests[moduleContext.tests.length - 1];
-      for (let j = afterHooks.length - 1; j >= 0; j--) {
-        await afterHooks[j].call(targetContext, targetContext.assert);
+      const lastTest = moduleContext.tests[moduleContext.tests.length - 1];
+      if (lastTest) {
+        for (let j = afterHooks.length - 1; j >= 0; j--) {
+          await afterHooks[j].call(lastTest.userContext, lastTest.assert);
+        }
       }
 
       for (let i = 0, len = moduleContext.tests.length; i < len; i++) {
@@ -78,7 +65,7 @@ export default function module(moduleName, runtimeOptions, moduleContent) {
       }
     });
 
-    targetModuleContent.call(moduleContext.context, {
+    targetModuleContent.call(moduleContext.userContext, {
       before(beforeFn) {
         beforeHooks[beforeHooks.length] = beforeFn;
       },

package/shims/deno/test.js

@@ -41,25 +41,30 @@ export default function test(testName, runtimeOptions, testContent) {
   const targetTestContent = testContent ? testContent : runtimeOptions;
   const context = new TestContext(testName, moduleContext);
 
-  it(testName, { concurrency: true, ...targetRuntimeOptions }, async function () {
+  // Each test gets a fresh plain object inheriting from the module's user context.
+  // This matches QUnit's prototype-chain model: before() sets props on the module context,
+  // tests inherit them, and each test's own writes don't pollute sibling tests.
+  const userContext = Object.create(moduleContext.userContext);
+  context.userContext = userContext;
+
+  it(testName, { ...targetRuntimeOptions }, async function () {
     for (const module of context.module.moduleChain) {
       for (const hook of module.beforeEachHooks) {
-        await hook.call(context, context.assert);
+        await hook.call(userContext, context.assert);
       }
     }
 
-    const result = await targetTestContent.call(context, context.assert, { testName, options: runtimeOptions });
+    const result = await targetTestContent.call(userContext, context.assert, { testName, options: runtimeOptions });
 
     await context.assert.waitForAsyncOps();
 
     for (let i = context.module.moduleChain.length - 1; i >= 0; i--) {
       const module = context.module.moduleChain[i];
       for (let j = module.afterEachHooks.length - 1; j >= 0; j--) {
-        await module.afterEachHooks[j].call(context, context.assert);
+        await module.afterEachHooks[j].call(userContext, context.assert);
       }
     }
 
     return result;
   });
 }
-

package/shims/node/module.js

@@ -1,49 +1,36 @@
 import { describe, before as beforeAll, after as afterAll } from 'node:test';
 import ModuleContext from '../shared/module-context.js';
 
-// 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)
-
 export default function module(moduleName, runtimeOptions, moduleContent) {
   const targetRuntimeOptions = moduleContent ? runtimeOptions : {};
   const targetModuleContent = moduleContent ? moduleContent : runtimeOptions;
   const moduleContext = new ModuleContext(moduleName);
 
-  return describe(moduleName, { concurrency: true, ...targetRuntimeOptions }, function () {
+  return describe(moduleName, { ...targetRuntimeOptions }, function () {
     const beforeHooks = [];
     const afterHooks = [];
 
     beforeAll(async function () {
-      Object.assign(moduleContext.context, moduleContext.moduleChain.reduce((result, module) => {
-        return Object.assign(result, module.context, {
-          steps: result.steps.concat(module.context.steps),
-          expectedAssertionCount: module.context.expectedAssertionCount
-            ? module.context.expectedAssertionCount
-            : result.expectedAssertionCount
-        });
-      }, { steps: [], expectedAssertionCount: undefined }));
+      // before() assertions are attributed to the first direct test only (matching QUnit's model).
+      // Tests inherit parent context via prototype chain, so no Object.assign needed.
+      const firstTest = moduleContext.tests[0];
+      const beforeAssert = firstTest ? firstTest.assert : moduleContext.assert;
 
       for (const hook of beforeHooks) {
-        await hook.call(moduleContext.context, moduleContext.assert);
-      }
-
-      for (let i = 0, len = moduleContext.tests.length; i < len; i++) {
-        Object.assign(moduleContext.tests[i], moduleContext.context, {
-          steps: moduleContext.context.steps,
-          totalExecutedAssertions: moduleContext.context.totalExecutedAssertions,
-          expectedAssertionCount: moduleContext.context.expectedAssertionCount,
-        });
+        await hook.call(moduleContext.userContext, beforeAssert);
       }
     });
+
     afterAll(async () => {
       for (const testContext of moduleContext.tests) {
         await testContext.assert.waitForAsyncOps();
       }
 
-      const targetContext = moduleContext.tests[moduleContext.tests.length - 1];
-      for (let j = afterHooks.length - 1; j >= 0; j--) {
-        await afterHooks[j].call(targetContext, targetContext.assert);
+      const lastTest = moduleContext.tests[moduleContext.tests.length - 1];
+      if (lastTest) {
+        for (let j = afterHooks.length - 1; j >= 0; j--) {
+          await afterHooks[j].call(lastTest.userContext, lastTest.assert);
+        }
       }
 
       for (let i = 0, len = moduleContext.tests.length; i < len; i++) {
@@ -51,7 +38,7 @@ export default function module(moduleName, runtimeOptions, moduleContent) {
       }
     });
 
-    targetModuleContent.call(moduleContext.context, {
+    targetModuleContent.call(moduleContext.userContext, {
       before(beforeFn) {
         beforeHooks[beforeHooks.length] = beforeFn;
       },

package/shims/node/test.js

@@ -12,25 +12,30 @@ export default function test(testName, runtimeOptions, testContent) {
   const targetTestContent = testContent ? testContent : runtimeOptions;
   const context = new TestContext(testName, moduleContext);
 
-  return it(testName, { concurrency: true, ...targetRuntimeOptions }, async function () {
+  // Each test gets a fresh plain object inheriting from the module's user context.
+  // This matches QUnit's prototype-chain model: before() sets props on the module context,
+  // tests inherit them, and each test's own writes don't pollute sibling tests.
+  const userContext = Object.create(moduleContext.userContext);
+  context.userContext = userContext;
+
+  return it(testName, { ...targetRuntimeOptions }, async function () {
     for (const module of context.module.moduleChain) {
       for (const hook of module.beforeEachHooks) {
-        await hook.call(context, context.assert);
+        await hook.call(userContext, context.assert);
       }
     }
 
-    const result = await targetTestContent.call(context, context.assert, { testName, options: runtimeOptions });
+    const result = await targetTestContent.call(userContext, context.assert, { testName, options: runtimeOptions });
 
     await context.assert.waitForAsyncOps();
 
     for (let i = context.module.moduleChain.length - 1; i >= 0; i--) {
       const module = context.module.moduleChain[i];
       for (let j = module.afterEachHooks.length - 1; j >= 0; j--) {
-        await module.afterEachHooks[j].call(context, context.assert);
+        await module.afterEachHooks[j].call(userContext, context.assert);
       }
     }
 
     return result;
   });
 }
-

package/shims/shared/assert.js

@@ -2,10 +2,6 @@ import '../../vendor/qunit.js';
 import { objectValues, objectValuesSubset, validateExpectedExceptionArgs, validateException } from '../shared/index.js';
 import util from 'node:util';
 
-// More: contexts needed for timeout
-// 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.
-
 /**
  * The assertion object passed to every test callback and lifecycle hook.
  *

package/shims/shared/module-context.js

@@ -8,6 +8,7 @@ export default class ModuleContext {
     return this.currentModuleChain[this.currentModuleChain.length - 1];
   }
 
+  // Internal fallback assert for modules with no direct tests
   context = new TestContext();
 
   moduleChain = [];
@@ -24,6 +25,10 @@ export default class ModuleContext {
     this.name = parentModule ? `${parentModule.name} > ${name}` : name;
     this.assert = new ModuleContext.Assert(this);
 
+    // User context uses prototype chain from parent module for proper QUnit-style inheritance:
+    // parent before() sets props on parent userContext, child tests inherit via prototype.
+    this.userContext = parentModule ? Object.create(parentModule.userContext) : Object.create(null);
+
     return Object.freeze(this);
   }
 }