qunitx 1.2.2 → 1.2.5

package/shims/deno/test.ts

@@ -14,8 +14,10 @@ export type { PushResultInfo } from '../types.ts';
  * Must be called inside a `module()` callback.
  *
  * @param {string} testName - Name of the test
- * @param {object} [runtimeOptions] - Optional Deno BDD options forwarded to `it()`
- *   (e.g. `{ concurrency: false }`, `{ sanitizeExit: false }`)
+ * @param {object} [runtimeOptions] - Optional options forwarded to `it()`.
+ *   Use `{ skip: true | string }` to skip the test, `{ todo: true | string }` to mark it as todo
+ *   (both map to Deno's `{ ignore: true }`). Other Deno BDD options like
+ *   `{ concurrency: false }` or `{ sanitizeExit: false }` are forwarded as-is.
  * @param {function} testContent - Test callback receiving `(assert, { testName, options })`
  * @returns {void}
  * @example
@@ -34,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) {
@@ -48,12 +50,11 @@ export default function test(
   }
 
   const targetRuntimeOptions = testContent ? runtimeOptions as object : {};
-  const { skip } = targetRuntimeOptions as { skip?: boolean | string };
+  const { skip, todo } = targetRuntimeOptions as { skip?: boolean | string; todo?: boolean | string };
 
-  // If skip is set, register a skipped it() without creating a TestContext (whose
-  // finish() would otherwise fire a "0 assertions" failure from afterAll).
-  // Deno uses `ignore` instead of `skip`.
-  if (skip) {
+  // skip/todo: no TestContext — finish() would fire "0 assertions" from afterAll otherwise.
+  // Deno uses `ignore` for both (no native todo concept).
+  if (skip || todo) {
     it(testName, { ignore: true }, async function () {});
     return;
   }
@@ -68,20 +69,22 @@ export default function test(
   context.userContext = userContext;
 
   it(testName, { ...targetRuntimeOptions }, async function () {
+    const hookMeta = { context: userContext };
+
     for (const module of context.module!.moduleChain) {
       for (const hook of module.beforeEachHooks) {
-        await hook.call(userContext, context.assert!);
+        await hook.call(userContext, context.assert!, hookMeta);
       }
     }
 
-    const result = await targetTestContent.call(userContext, context.assert!, { testName, options: runtimeOptions });
+    const result = await targetTestContent.call(userContext, context.assert!, { testName, options: runtimeOptions, context: userContext });
 
     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!);
+        await module.afterEachHooks[j]!.call(userContext, context.assert!, hookMeta);
       }
     }
 
@@ -109,3 +112,25 @@ export default function test(
 test.skip = function skipTest(testName: string, _testContent?: unknown): void {
   it(testName, { ignore: true }, async function () {});
 };
+
+/**
+ * Registers a todo test. Equivalent to `QUnit.test.todo`.
+ * The test body is never executed; the test is reported as ignored by Deno's runner
+ * (Deno has no native todo concept).
+ *
+ * @param {string} testName - Name of the test to mark as todo.
+ * @param {function} [_testContent] - Optional body (ignored — the test will not run).
+ * @example
+ * ```js ignore
+ * import { module, test } from "qunitx";
+ *
+ * module("Math", () => {
+ *   test.todo("addition is not yet implemented", (assert) => {
+ *     assert.equal(1 + 1, 2);
+ *   });
+ * });
+ * ```
+ */
+test.todo = function todoTest(testName: string, _testContent?: unknown): void {
+  it(testName, { ignore: true }, async function () {});
+};

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

@@ -68,7 +68,7 @@ export default class TestContext {
     this.#totalExecutedAssertions = value;
   }
 
-  userContext: object = {};
+  userContext: Record<string, unknown> = {};
 
   constructor(name?: string, moduleContext?: ModuleContext) {
     if (moduleContext) {

package/shims/types.ts

@@ -37,7 +37,7 @@ export interface TestState {
   asyncOps: Promise<void>[];
   timeout?: number;
   expectedAssertionCount?: number;
-  userContext?: object;
+  userContext?: Record<string, unknown>;
   module?: { name: string };
 }
 
@@ -46,11 +46,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. */