qunitx 1.2.6 → 1.2.8

package/shims/shared/assert.ts

@@ -1,6 +1,9 @@
 import '../../vendor/qunit.js';
-import { objectValues, objectValuesSubset, validateExpectedExceptionArgs, validateException } from './index.ts';
-import type { QUnitObject, AssertionErrorConstructor, InspectFn, TestState, ModuleState, PushResultInfo } from '../types.ts';
+import type { AssertionErrorConstructor, InspectFn, ModuleState, PushResultInfo, QUnitObject, TestState } from '../types.ts';
+import { objectValues, objectValuesSubset, validateException, validateExpectedExceptionArgs } from './index.ts';
+
+// Sentinel used by rejects() to distinguish "promise resolved" from "caught undefined".
+const PENDING = Symbol('pending');
 
 /**
  * The assertion object passed to every test callback and lifecycle hook.
@@ -34,11 +37,11 @@ export default class Assert {
 
   /** @internal */
   constructor(module: ModuleState | null, test?: TestState) {
-    this.test = test || (module as ModuleState).context;
+    this.test = test || (module as ModuleState).testContext;
   }
 
   /** @internal */
-  _incrementAssertionCount() {
+  private _incrementAssertionCount() {
     this.test.totalExecutedAssertions++;
   }
 
@@ -80,22 +83,16 @@ export default class Assert {
    * ```
    */
   step(message: string): void {
-    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;
-    }
+    const result = typeof message === 'string' && message.length > 0;
+    const assertionMessage = result
+      ? message
+      : (message === undefined || message === '')
+        ? 'You must provide a message to assert.step'
+        : 'You must provide a string value to assert.step';
 
-    this.pushResult({
-      result,
-      message: assertionMessage
-    });
+    this.pushResult({ result, message: assertionMessage });
   }
 
   /**
@@ -159,12 +156,9 @@ export default class Assert {
    * ```
    */
   async(): () => void {
-    let resolveFn!: () => void;
-    const done = new Promise<void>(resolve => { resolveFn = resolve; });
-
-    this.test.asyncOps.push(done);
-
-    return () => { resolveFn(); };
+    const { promise, resolve } = Promise.withResolvers<void>();
+    this.test.asyncOps.push(promise);
+    return resolve;
   }
 
   /** @internal Used by the test runner to wait for all async operations to complete. */
@@ -320,7 +314,7 @@ export default class Assert {
       throw new Assert.AssertionError({
         actual,
         expected,
-        message: message || `Expected: ${defaultMessage(actual, 'should equal to:', expected)}`,
+        message: message || `Values are not equal:${formatDiff(actual, expected)}`,
         operator: '==',
         stackStartFn: this.equal,
       });
@@ -346,7 +340,7 @@ export default class Assert {
         actual,
         expected,
         operator: '!=',
-        message: message || `Expected: ${defaultMessage(actual, 'should notEqual to:', expected)}`,
+        message: message || `Values are unexpectedly equal:${formatUnexpectedMatch(actual)}`,
         stackStartFn: this.notEqual,
       });
     }
@@ -376,7 +370,7 @@ export default class Assert {
       throw new Assert.AssertionError({
         actual: targetActual,
         expected: targetExpected,
-        message: message || `Expected properties to be propEqual: ${defaultMessage(targetActual, 'should propEqual to:', targetExpected)}`,
+        message: message || `Own properties are not equal:${formatDiff(targetActual, targetExpected)}`,
         stackStartFn: this.propEqual,
       });
     }
@@ -403,7 +397,7 @@ export default class Assert {
       throw new Assert.AssertionError({
         actual: targetActual,
         expected: targetExpected,
-        message: message || `Expected properties to NOT be propEqual: ${defaultMessage(targetActual, 'should notPropEqual to:', targetExpected)}`,
+        message: message || `Own properties are unexpectedly equal:${formatUnexpectedMatch(targetActual)}`,
         stackStartFn: this.notPropEqual,
       });
     }
@@ -430,7 +424,7 @@ export default class Assert {
       throw new Assert.AssertionError({
         actual: targetActual,
         expected: targetExpected,
-        message: message || `propContains assertion fail on: ${defaultMessage(targetActual, 'should propContains to:', targetExpected)}`,
+        message: message || `Object does not contain expected properties:${formatDiff(targetActual, targetExpected)}`,
         stackStartFn: this.propContains,
       });
     }
@@ -457,7 +451,7 @@ export default class Assert {
       throw new Assert.AssertionError({
         actual: targetActual,
         expected: targetExpected,
-        message: message || `notPropContains assertion fail on: ${defaultMessage(targetActual, 'should notPropContains of:', targetExpected)}`,
+        message: message || `Object unexpectedly contains all expected properties:${formatUnexpectedMatch(targetActual)}`,
         stackStartFn: this.notPropContains,
       });
     }
@@ -482,7 +476,7 @@ export default class Assert {
       throw new Assert.AssertionError({
         actual,
         expected,
-        message: message || `Expected values to be deepEqual: ${defaultMessage(actual, 'should deepEqual to:', expected)}`,
+        message: message || `Values are not deeply equal:${formatDiff(actual, expected)}`,
         operator: 'deepEqual',
         stackStartFn: this.deepEqual,
       });
@@ -507,7 +501,7 @@ export default class Assert {
       throw new Assert.AssertionError({
         actual,
         expected,
-        message: message || `Expected values to be NOT deepEqual: ${defaultMessage(actual, 'should notDeepEqual to:', expected)}`,
+        message: message || `Values are unexpectedly deeply equal:${formatUnexpectedMatch(actual)}`,
         operator: 'notDeepEqual',
         stackStartFn: this.notDeepEqual,
       });
@@ -532,7 +526,7 @@ export default class Assert {
       throw new Assert.AssertionError({
         actual,
         expected,
-        message: message || `Expected: ${defaultMessage(actual, 'is strictEqual to:', expected)}`,
+        message: message || `Values are not strictly equal:${formatDiff(actual, expected)}`,
         operator: 'strictEqual',
         stackStartFn: this.strictEqual,
       });
@@ -557,7 +551,7 @@ export default class Assert {
       throw new Assert.AssertionError({
         actual,
         expected,
-        message: message || `Expected: ${defaultMessage(actual, 'is notStrictEqual to:', expected)}`,
+        message: message || `Values are unexpectedly strictly equal:${formatUnexpectedMatch(actual)}`,
         operator: 'notStrictEqual',
         stackStartFn: this.notStrictEqual,
       });
@@ -580,7 +574,7 @@ export default class Assert {
    * ```
    */
   throws(blockFn: unknown, expectedInput?: unknown, assertionMessage?: string): void {
-    this?._incrementAssertionCount();
+    this._incrementAssertionCount();
     const [expected, message] = validateExpectedExceptionArgs(expectedInput, assertionMessage, 'throws');
     if (typeof blockFn !== 'function') {
       throw new Assert.AssertionError({
@@ -591,15 +585,18 @@ export default class Assert {
       });
     }
 
+    let returnValue: unknown;
     try {
-      blockFn();
+      returnValue = blockFn();
     } catch (error) {
-      const [result, validatedExpected, validatedMessage] = validateException(error, expected, message);
+      const [result, , validatedMessage] = validateException(error, expected, message);
       if (result === false) {
+        const expectedDesc = describeExpected(expected);
+        const receivedDesc = String(error);
         throw new Assert.AssertionError({
-          actual: result,
-          expected: validatedExpected,
-          message: validatedMessage,
+          actual: receivedDesc,
+          expected: expectedDesc,
+          message: validatedMessage || throwsFailMessage('throws', expectedDesc, receivedDesc),
           stackStartFn: this.throws,
         });
       }
@@ -607,6 +604,15 @@ export default class Assert {
       return;
     }
 
+    if (returnValue !== null && typeof returnValue === 'object' && typeof (returnValue as PromiseLike<unknown>).then === 'function') {
+      throw new Assert.AssertionError({
+        actual: returnValue,
+        expected: expected,
+        message: 'Function passed to `assert.throws` returned a Promise — did you mean to use `assert.rejects`?',
+        stackStartFn: this.throws,
+      });
+    }
+
     throw new Assert.AssertionError({
       actual: blockFn,
       expected: expected,
@@ -643,16 +649,14 @@ export default class Assert {
       });
     }
 
-    let didReject = false;
-    let rejectionError;
+    let caught: unknown = PENDING;
     try {
       await promise;
     } catch (error) {
-      didReject = true;
-      rejectionError = error;
+      caught = error;
     }
 
-    if (!didReject) {
+    if (caught === PENDING) {
       throw new Assert.AssertionError({
         actual: promise,
         expected: expected,
@@ -661,28 +665,60 @@ export default class Assert {
       });
     }
 
-    const [result, validatedExpected, validatedMessage] = validateException(rejectionError, expected, message);
+    const [result, , validatedMessage] = validateException(caught, expected, message);
     if (result === false) {
+      const expectedDesc = describeExpected(expected);
+      const receivedDesc = String(caught);
       throw new Assert.AssertionError({
-        actual: result,
-        expected: validatedExpected,
-        message: validatedMessage,
+        actual: receivedDesc,
+        expected: expectedDesc,
+        message: validatedMessage || throwsFailMessage('rejects', expectedDesc, receivedDesc),
         stackStartFn: this.rejects,
       });
     }
   }
-};
+}
 
-function defaultMessage(actual: unknown, description: string, expected: unknown): string {
-  return `
 
-${inspect(actual)}
+const INSPECT_OPTIONS = { depth: 10, colors: true, compact: false as const };
 
-${description}
+const inspect = (value: unknown): string => Assert.inspect(value, INSPECT_OPTIONS);
 
-${inspect(expected)}`
+function formatDiff(actual: unknown, expected: unknown): string {
+  const aStr = inspect(actual), bStr = inspect(expected);
+  const aLines = aStr.split('\n'), bLines = bStr.split('\n');
+  if (aLines.length === 1 && bLines.length === 1) return `\n\nActual:   ${aStr}\nExpected: ${bStr}`;
+  const lines = lcsDiff(aLines, bLines).map(([t, line]) =>
+    t === '=' ? `  ${line}` : t === '-' ? `- ${line}` : `+ ${line}`
+  );
+  return `\n\n- Actual  + Expected\n\n${lines.join('\n')}`;
 }
 
-function inspect(value: unknown): string {
-  return Assert.inspect(value, { depth: 10, colors: true, compact: false });
+const formatUnexpectedMatch = (actual: unknown): string => `\n\n${inspect(actual)}`;
+
+const describeExpected = (expected: unknown): string =>
+  expected == null ? '(no pattern)' :
+  typeof expected === 'string' ? expected :
+  typeof expected === 'function' ? ((expected as { name?: string }).name || String(expected)) :
+  String(expected);
+
+const throwsFailMessage = (method: string, pattern: string, received: string): string =>
+  `assert.${method}: thrown error did not match expected:\n\nPattern:  ${pattern}\nReceived: ${received}`;
+
+type DiffEntry = ['=' | '-' | '+', string];
+
+function lcsDiff(a: string[], b: string[]): DiffEntry[] {
+  const m = a.length, n = b.length;
+  const dp: number[][] = Array.from({ length: m + 1 }, () => new Array<number>(n + 1).fill(0));
+  for (let i = 1; i <= m; i++)
+    for (let j = 1; j <= n; j++)
+      dp[i][j] = a[i - 1] === b[j - 1] ? dp[i - 1][j - 1] + 1 : Math.max(dp[i - 1][j], dp[i][j - 1]);
+  const result: DiffEntry[] = [];
+  let i = m, j = n;
+  while (i > 0 || j > 0) {
+    if (i > 0 && j > 0 && a[i - 1] === b[j - 1]) { result.push(['=', a[i - 1]]); i--; j--; }
+    else if (j > 0 && (i === 0 || dp[i][j - 1] >= dp[i - 1][j])) { result.push(['+', b[j - 1]]); j--; }
+    else { result.push(['-', a[i - 1]]); i--; }
+  }
+  return result.reverse();
 }

package/shims/shared/index.ts

@@ -1,4 +1,4 @@
-const hasOwn = Object.prototype.hasOwnProperty
+const hasOwn = Object.prototype.hasOwnProperty;
 
 export function objectType(obj: unknown): string {
   if (typeof obj === 'undefined') {
@@ -32,12 +32,8 @@ export function objectType(obj: unknown): string {
   }
 }
 
-function is(type: string, obj: unknown): boolean {
-  return objectType(obj) === type;
-}
-
 export function objectValues(obj: unknown, allowArray = true): unknown {
-  const vals: Record<string, unknown> | unknown[] = allowArray && is('array', obj) ? [] : {};
+  const vals: Record<string, unknown> | unknown[] = allowArray && objectType(obj) === 'array' ? [] : {};
 
   for (const key in obj as object) {
     if (hasOwn.call(obj, key)) {
@@ -50,13 +46,8 @@ export function objectValues(obj: unknown, allowArray = true): unknown {
 }
 
 /**
- *
  * 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}
+ * subset of own enumerable properties that exist in a given model.
  */
 export function objectValuesSubset(obj: unknown, model: unknown): unknown {
   // Return primitive values unchanged to avoid false positives or confusing
@@ -95,14 +86,15 @@ export function validateExpectedExceptionArgs(
       expected = undefined;
       return [expected, message];
     } else {
-      throw new Error('assert.' + assertionMethod + ' does not accept a string value for the expected argument.\n' + 'Use a non-string object value (e.g. RegExp or validator function) ' + 'instead if necessary.');
+      throw new Error(
+        `assert.${assertionMethod} does not accept a string value for the expected argument.\n` +
+        'Use a non-string object value (e.g. RegExp or validator function) instead if necessary.',
+      );
     }
   }
-  const valid = !expected ||
-  // TODO: be more explicit here
-  expectedType === 'regexp' || expectedType === 'function' || expectedType === 'object';
+  const valid = !expected || expectedType === 'regexp' || expectedType === 'function' || expectedType === 'object';
   if (!valid) {
-    throw new Error('Invalid expected value type (' + expectedType + ') ' + 'provided to assert.' + assertionMethod + '.');
+    throw new Error(`Invalid expected value type (${expectedType}) provided to assert.${assertionMethod}.`);
   }
   return [expected, message];
 }
@@ -170,15 +162,10 @@ function errorString(error: unknown): string {
   // an object literal with name and message properties...
   if (resultErrorString.slice(0, 7) === '[object') {
     // Based on https://es5.github.io/#x15.11.4.4
-    return (
-      ((error as { name?: string }).name || 'Error') +
-      ((error as { message?: string }).message
-        ? ': '.concat((error as { message: string }).message)
-        : '')
-    );
-  } else {
-    return resultErrorString;
+    const name = (error as { name?: string }).name || 'Error';
+    const msg = (error as { message?: string }).message;
+    return msg ? `${name}: ${msg}` : name;
   }
-}
 
-export default { objectValues, objectValuesSubset, validateExpectedExceptionArgs, validateException };
+  return resultErrorString;
+}

package/shims/shared/module-context.ts

@@ -1,5 +1,5 @@
-import type Assert from './assert.ts';
 import type { HookFn } from '../types.ts';
+import type Assert from './assert.ts';
 import TestContext from './test-context.ts';
 
 export default class ModuleContext {
@@ -7,7 +7,7 @@ export default class ModuleContext {
   static currentModuleChain: ModuleContext[] = [];
 
   static get lastModule() {
-    return this.currentModuleChain[this.currentModuleChain.length - 1];
+    return this.currentModuleChain.at(-1);
   }
 
   name!: string;
@@ -15,7 +15,7 @@ export default class ModuleContext {
   userContext!: Record<string, unknown>;
 
   // Internal fallback assert for modules with no direct tests
-  context = new TestContext();
+  testContext = new TestContext();
 
   moduleChain: ModuleContext[] = [];
   beforeEachHooks: HookFn<Assert>[] = [];
@@ -23,11 +23,11 @@ export default class ModuleContext {
   tests: TestContext[] = [];
 
   constructor(name: string) {
-    const parentModule = ModuleContext.currentModuleChain[ModuleContext.currentModuleChain.length - 1];
+    const parentModule = ModuleContext.currentModuleChain.at(-1);
 
     ModuleContext.currentModuleChain.push(this);
 
-    this.moduleChain = ModuleContext.currentModuleChain.slice(0);
+    this.moduleChain = [...ModuleContext.currentModuleChain];
     this.name = parentModule ? `${parentModule.name} > ${name}` : name;
     this.assert = new ModuleContext.Assert(this);
 

package/shims/shared/test-context.ts

@@ -4,50 +4,29 @@ import type ModuleContext from './module-context.ts';
 export default class TestContext {
   static Assert: typeof Assert;
 
-  #name: string | undefined;
-  get name() {
-    return this.#name;
-  }
-  set name(value) {
-    this.#name = value;
-  }
-
-  #module: ModuleContext | undefined;
-  get module() {
-    return this.#module;
-  }
-  set module(value) {
-    this.#module = value;
-  }
-
-  #asyncOps: Promise<void>[] = [];
-  get asyncOps() {
-    return this.#asyncOps;
-  }
-  set asyncOps(value) {
-    this.#asyncOps = value;
-  }
-
-  #assert: Assert | undefined;
-  get assert() {
-    return this.#assert;
-  }
-  set assert(value) {
-    this.#assert = value;
-  }
-
-  #timeout: number | undefined;
-  get timeout() {
-    return this.#timeout;
-  }
-  set timeout(value) {
-    this.#timeout = value;
-  }
+  name: string | undefined;
+  module: ModuleContext | undefined;
+  asyncOps: Promise<void>[] = [];
+  assert: Assert | undefined;
+  timeout: number | undefined;
+  steps: string[] = [];
+  expectedAssertionCount: number | undefined;
+  totalExecutedAssertions = 0;
+  userContext: Record<string, unknown> = {};
 
   rejectTimeout: ((err: Error) => void) | undefined;
   #timeoutHandle: ReturnType<typeof setTimeout> | undefined;
   #timedOut = false;
 
+  constructor(name?: string, moduleContext?: ModuleContext) {
+    if (moduleContext) {
+      this.name = `${moduleContext.name} | ${name}`;
+      this.module = moduleContext;
+      this.module.tests.push(this);
+      this.assert = new TestContext.Assert(moduleContext, this);
+    }
+  }
+
   setTimeoutDuration(ms: number) {
     if (this.#timeoutHandle !== undefined) {
       clearTimeout(this.#timeoutHandle);
@@ -67,65 +46,29 @@ export default class TestContext {
     }
   }
 
-  #steps: string[] = [];
-  get steps() {
-    return this.#steps;
-  }
-  set steps(value) {
-    this.#steps = value;
-  }
-
-  #expectedAssertionCount: number | undefined;
-  get expectedAssertionCount() {
-    return this.#expectedAssertionCount;
-  }
-  set expectedAssertionCount(value) {
-    this.#expectedAssertionCount = value;
-  }
-
-  #totalExecutedAssertions = 0;
-  get totalExecutedAssertions() {
-    return this.#totalExecutedAssertions;
-  }
-  set totalExecutedAssertions(value) {
-    this.#totalExecutedAssertions = value;
-  }
-
-  userContext: Record<string, unknown> = {};
-
-  constructor(name?: string, moduleContext?: ModuleContext) {
-    if (moduleContext) {
-      this.name = `${moduleContext.name} | ${name}`;
-      this.module = moduleContext;
-      this.module.tests.push(this);
-      this.assert = new TestContext.Assert(moduleContext, this);
-    }
-  }
-
   finish() {
     if (this.#timedOut) return;
-    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) {
+    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) {
+    } else if (this.expectedAssertionCount !== undefined && 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}`,
       });
+    } else if (this.expectedAssertionCount === undefined && 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}`,
+      });
     }
   }
 }
-

package/shims/types.ts

@@ -44,7 +44,7 @@ export interface TestState {
 
 /** Minimal module shape that Assert needs to resolve a fallback test context. */
 export interface ModuleState {
-  context: TestState;
+  testContext: TestState;
 }
 
 /** A lifecycle hook callback that receives an {@linkcode Assert} instance and a meta object with the shared context. */