qunitx 1.2.4 → 1.2.6

package/shims/deno/module.ts

@@ -1,6 +1,6 @@
 import { describe, beforeAll, afterAll } from "jsr:@std/testing/bdd";
 import type Assert from '../shared/assert.ts';
-import type { HooksObject } from '../types.ts';
+import type { HookFn, HooksObject } from '../types.ts';
 import ModuleContext from '../shared/module-context.ts';
 export type { Assert };
 export type { HookFn, HooksObject, PushResultInfo } from '../types.ts';
@@ -32,13 +32,13 @@ export type { HookFn, HooksObject, PushResultInfo } from '../types.ts';
  * });
  * ```
  */
-export default function module(moduleName: string, moduleContent: (hooks: HooksObject<Assert>, meta: { moduleName: string; options: unknown }) => void): void;
+export default function module(moduleName: string, moduleContent: (hooks: HooksObject<Assert>, meta: { moduleName: string; options: unknown; context: Record<string, unknown> }) => void): void;
 /** Defines a test module (suite) with optional Deno BDD runtime options forwarded to `describe()`. */
-export default function module(moduleName: string, runtimeOptions: object, moduleContent: (hooks: HooksObject<Assert>, meta: { moduleName: string; options: unknown }) => void): void;
+export default function module(moduleName: string, runtimeOptions: object, moduleContent: (hooks: HooksObject<Assert>, meta: { moduleName: string; options: unknown; context: Record<string, unknown> }) => void): void;
 export default function module(
   moduleName: string,
   runtimeOptions: object | ((hooks: HooksObject<Assert>) => void),
-  moduleContent?: (hooks: HooksObject<Assert>, meta: { moduleName: string; options: unknown }) => void,
+  moduleContent?: (hooks: HooksObject<Assert>, meta: { moduleName: string; options: unknown; context: Record<string, unknown> }) => void,
 ): void {
   const targetRuntimeOptions = moduleContent ? runtimeOptions as object : {};
   const { skip } = targetRuntimeOptions as { skip?: boolean | string };
@@ -57,8 +57,8 @@ export default function module(
   const moduleContext = new ModuleContext(moduleName);
 
   describe(moduleName, { ...targetRuntimeOptions }, function () {
-    const beforeHooks: ((assert: Assert) => void | Promise<void>)[] = [];
-    const afterHooks: ((assert: Assert) => void | Promise<void>)[] = [];
+    const beforeHooks: HookFn<Assert>[] = [];
+    const afterHooks: HookFn<Assert>[] = [];
 
     beforeAll(async function () {
       // before() assertions are attributed to the first direct test only (matching QUnit's model).
@@ -67,7 +67,7 @@ export default function module(
       const beforeAssert = firstTest ? firstTest.assert! : moduleContext.assert!;
 
       for (const hook of beforeHooks) {
-        await hook.call(moduleContext.userContext, beforeAssert);
+        await hook.call(moduleContext.userContext, beforeAssert, { context: moduleContext.userContext });
       }
     });
 
@@ -79,7 +79,7 @@ export default function module(
       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!);
+          await afterHooks[j]!.call(lastTest.userContext, lastTest.assert!, { context: lastTest.userContext });
         }
       }
 
@@ -101,7 +101,7 @@ export default function module(
       after(afterFn) {
         afterHooks.push(afterFn);
       }
-    }, { moduleName, options: runtimeOptions });
+    }, { moduleName, options: runtimeOptions, context: moduleContext.userContext });
 
     ModuleContext.currentModuleChain.pop();
   });
@@ -127,3 +127,25 @@ export default function module(
 module.skip = function skipModule(moduleName: string, _moduleContent?: unknown): void {
   describe(moduleName, { ignore: true }, function () {});
 };
+
+/**
+ * Marks all tests inside a module as todo. Equivalent to `QUnit.module.todo`.
+ * The module is registered as ignored by Deno's runner; no test bodies run.
+ * Deno has no native "todo module" concept, so this maps to ignore.
+ *
+ * @param {string} moduleName - Name of the module to mark as todo.
+ * @param {function} [_moduleContent] - Optional body (ignored — no tests run).
+ * @example
+ * ```js ignore
+ * import { module, test } from "qunitx";
+ *
+ * module.todo("Math — not yet implemented", () => {
+ *   test("addition", (assert) => {
+ *     assert.equal(1 + 1, 2);
+ *   });
+ * });
+ * ```
+ */
+module.todo = function todoModule(moduleName: string, _moduleContent?: unknown): void {
+  describe(moduleName, { ignore: true }, function () {});
+};

package/shims/deno/test.ts

@@ -36,13 +36,13 @@ export type { PushResultInfo } from '../types.ts';
  * });
  * ```
  */
-export default function test(testName: string, testContent: (assert: Assert, meta: { testName: string; options: unknown }) => void | Promise<void>): void;
+export default function test(testName: string, testContent: (assert: Assert, meta: { testName: string; options: unknown; context: Record<string, unknown> }) => void | Promise<void>): void;
 /** Defines an individual test with optional Deno BDD runtime options forwarded to `it()`. */
-export default function test(testName: string, runtimeOptions: object, testContent: (assert: Assert, meta: { testName: string; options: unknown }) => void | Promise<void>): void;
+export default function test(testName: string, runtimeOptions: object, testContent: (assert: Assert, meta: { testName: string; options: unknown; context: Record<string, unknown> }) => void | Promise<void>): void;
 export default function test(
   testName: string,
-  runtimeOptions: object | ((assert: Assert, meta: { testName: string; options: unknown }) => void | Promise<void>),
-  testContent?: (assert: Assert, meta: { testName: string; options: unknown }) => void | Promise<void>,
+  runtimeOptions: object | ((assert: Assert, meta: { testName: string; options: unknown; context: Record<string, unknown> }) => void | Promise<void>),
+  testContent?: (assert: Assert, meta: { testName: string; options: unknown; context: Record<string, unknown> }) => void | Promise<void>,
 ): void {
   const moduleContext = ModuleContext.lastModule;
   if (!moduleContext) {
@@ -68,25 +68,39 @@ export default function test(
   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(userContext, context.assert!);
-      }
-    }
+  it(testName, { ...targetRuntimeOptions }, function () {
+    return new Promise((resolve, reject) => {
+      context.rejectTimeout = reject;
 
-    const result = await targetTestContent.call(userContext, context.assert!, { testName, options: runtimeOptions });
+      (async () => {
+        const hookMeta = { context: userContext };
 
-    await context.assert!.waitForAsyncOps();
+        try {
+          for (const module of context.module!.moduleChain) {
+            for (const hook of module.beforeEachHooks) {
+              await hook.call(userContext, context.assert!, hookMeta);
+            }
+          }
 
-    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(userContext, context.assert!);
-      }
-    }
+          const result = await targetTestContent.call(userContext, context.assert!, { testName, options: runtimeOptions, context: userContext });
 
-    return result;
+          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(userContext, context.assert!, hookMeta);
+            }
+          }
+
+          resolve(result);
+        } catch (err) {
+          reject(err);
+        } finally {
+          context.clearTimeoutHandle();
+        }
+      })();
+    });
   });
 }
 

package/shims/shared/assert.ts

@@ -61,6 +61,7 @@ export default class Assert {
     }
 
     this.test.timeout = number;
+    this.test.setTimeoutDuration(number);
   }
 
   /**

package/shims/shared/module-context.ts

@@ -12,7 +12,7 @@ export default class ModuleContext {
 
   name!: string;
   assert!: Assert;
-  userContext!: object;
+  userContext!: Record<string, unknown>;
 
   // Internal fallback assert for modules with no direct tests
   context = new TestContext();

package/shims/shared/test-context.ts

@@ -44,6 +44,29 @@ export default class TestContext {
     this.#timeout = value;
   }
 
+  rejectTimeout: ((err: Error) => void) | undefined;
+  #timeoutHandle: ReturnType<typeof setTimeout> | undefined;
+  #timedOut = false;
+
+  setTimeoutDuration(ms: number) {
+    if (this.#timeoutHandle !== undefined) {
+      clearTimeout(this.#timeoutHandle);
+      this.#timeoutHandle = undefined;
+    }
+    if (!this.rejectTimeout) return;
+    this.#timeoutHandle = setTimeout(() => {
+      this.#timedOut = true;
+      this.rejectTimeout!(new Error(`Test timed out after ${ms}ms`));
+    }, ms);
+  }
+
+  clearTimeoutHandle() {
+    if (this.#timeoutHandle !== undefined) {
+      clearTimeout(this.#timeoutHandle);
+      this.#timeoutHandle = undefined;
+    }
+  }
+
   #steps: string[] = [];
   get steps() {
     return this.#steps;
@@ -68,7 +91,7 @@ export default class TestContext {
     this.#totalExecutedAssertions = value;
   }
 
-  userContext: object = {};
+  userContext: Record<string, unknown> = {};
 
   constructor(name?: string, moduleContext?: ModuleContext) {
     if (moduleContext) {
@@ -80,6 +103,7 @@ export default class TestContext {
   }
 
   finish() {
+    if (this.#timedOut) return;
     if (this.totalExecutedAssertions === 0) {
       this.assert!.pushResult({
         result: false,

package/shims/types.ts

@@ -37,8 +37,9 @@ export interface TestState {
   asyncOps: Promise<void>[];
   timeout?: number;
   expectedAssertionCount?: number;
-  userContext?: object;
+  userContext?: Record<string, unknown>;
   module?: { name: string };
+  setTimeoutDuration(ms: number): void;
 }
 
 /** Minimal module shape that Assert needs to resolve a fallback test context. */
@@ -46,11 +47,11 @@ export interface ModuleState {
   context: TestState;
 }
 
-/** A lifecycle hook callback that receives an {@linkcode Assert} instance. */
-export type HookFn<A = unknown> = (assert: A) => void | Promise<void>;
+/** A lifecycle hook callback that receives an {@linkcode Assert} instance and a meta object with the shared context. */
+export type HookFn<A = unknown> = (assert: A, meta: { context: Record<string, unknown> }) => void | Promise<void>;
 export type TestFn<A = unknown> = (
   assert: A,
-  meta: { testName: string; options: unknown },
+  meta: { testName: string; options: unknown; context: Record<string, unknown> },
 ) => void | Promise<unknown>;
 
 /** Lifecycle hooks available inside a `module()` callback. */