qunitx 1.0.1 → 1.0.2

package/benches/assert.bench.js

@@ -0,0 +1,115 @@
+// Benchmarks for core assertion methods in shims/shared/assert.js.
+// Measures the hot path that runs for every assertion in every test.
+//
+// Run: deno bench --allow-read benches/assert.bench.js
+
+import '../vendor/qunit.js';
+import Assert from '../shims/shared/assert.js';
+import TestContext from '../shims/shared/test-context.js';
+
+class QXAssertionError extends Error {
+  constructor(obj) {
+    super(obj.message);
+  }
+}
+
+Assert.QUnit = globalThis.QUnit;
+Assert.AssertionError = QXAssertionError;
+TestContext.Assert = Assert;
+
+function makeAssert() {
+  const test = { totalExecutedAssertions: 0, steps: [], asyncOps: [] };
+  return new Assert(null, test);
+}
+
+// --- Truthy / falsy ---
+
+const assertOk = makeAssert();
+Deno.bench('ok - passing', () => {
+  assertOk.ok(true);
+});
+
+const assertNotOk = makeAssert();
+Deno.bench('notOk - passing', () => {
+  assertNotOk.notOk(false);
+});
+
+const assertTrue = makeAssert();
+Deno.bench('true - passing', () => {
+  assertTrue.true(true);
+});
+
+const assertFalse = makeAssert();
+Deno.bench('false - passing', () => {
+  assertFalse.false(false);
+});
+
+// --- Equality ---
+
+const assertEqual = makeAssert();
+Deno.bench('equal - passing', () => {
+  assertEqual.equal(1, 1);
+});
+
+const assertStrictEqual = makeAssert();
+Deno.bench('strictEqual - passing', () => {
+  assertStrictEqual.strictEqual('hello', 'hello');
+});
+
+const assertNotStrictEqual = makeAssert();
+Deno.bench('notStrictEqual - passing', () => {
+  assertNotStrictEqual.notStrictEqual(1, '1');
+});
+
+// --- Deep equality ---
+
+const flatObj = { a: 1, b: 2, c: 3 };
+const assertDeepFlat = makeAssert();
+Deno.bench('deepEqual - flat object', () => {
+  assertDeepFlat.deepEqual({ a: 1, b: 2, c: 3 }, flatObj);
+});
+
+const nestedObj = { a: { b: { c: 1 } }, d: [1, 2, 3] };
+const assertDeepNested = makeAssert();
+Deno.bench('deepEqual - nested object', () => {
+  assertDeepNested.deepEqual({ a: { b: { c: 1 } }, d: [1, 2, 3] }, nestedObj);
+});
+
+// --- Prop equality ---
+
+const assertPropEqual = makeAssert();
+Deno.bench('propEqual - flat object', () => {
+  assertPropEqual.propEqual({ a: 1, b: 2 }, { a: 1, b: 2 });
+});
+
+const assertPropContains = makeAssert();
+Deno.bench('propContains - subset', () => {
+  assertPropContains.propContains({ a: 1, b: 2, c: 3 }, { a: 1, b: 2 });
+});
+
+// --- Base method ---
+
+const assertPushResult = makeAssert();
+Deno.bench('pushResult - passing', () => {
+  assertPushResult.pushResult({ result: true, actual: 1, expected: 1, message: 'ok' });
+});
+
+// --- Step tracking ---
+
+const assertStep = makeAssert();
+Deno.bench('step + verifySteps', () => {
+  assertStep.test.steps = [];
+  assertStep.test.totalExecutedAssertions = 0;
+  assertStep.step('a');
+  assertStep.step('b');
+  assertStep.verifySteps(['a', 'b']);
+});
+
+// --- Exception assertion ---
+
+const assertThrows = makeAssert();
+Deno.bench('throws - passing', () => {
+  assertThrows.throws(() => {
+    throw new Error('boom');
+  });
+});

package/benches/context.bench.js

@@ -0,0 +1,69 @@
+// Benchmarks for TestContext and ModuleContext lifecycle.
+// These objects are created once per test/module, so their construction cost
+// adds directly to suite startup time at scale.
+//
+// Run: deno bench --allow-read benches/context.bench.js
+
+import '../vendor/qunit.js';
+import Assert from '../shims/shared/assert.js';
+import ModuleContext from '../shims/shared/module-context.js';
+import TestContext from '../shims/shared/test-context.js';
+
+class QXAssertionError extends Error {
+  constructor(obj) {
+    super(obj.message);
+  }
+}
+
+Assert.QUnit = globalThis.QUnit;
+Assert.AssertionError = QXAssertionError;
+ModuleContext.Assert = Assert;
+TestContext.Assert = Assert;
+
+// --- ModuleContext ---
+
+Deno.bench('ModuleContext - creation', () => {
+  new ModuleContext('SuiteName');
+  ModuleContext.currentModuleChain.pop();
+});
+
+// --- TestContext ---
+
+// Create a reusable parent module for TestContext benchmarks.
+const parentModule = new ModuleContext('Parent');
+ModuleContext.currentModuleChain.pop();
+
+Deno.bench('TestContext - creation', () => {
+  new TestContext('test name', parentModule);
+  parentModule.tests.pop();
+});
+
+// --- finish() ---
+
+// finish() runs after every test to validate assertion counts & steps.
+// Three paths: at-least-one assertion (fast path), zero assertions (fail), expect mismatch.
+
+function makeFinishableTest(expectedCount) {
+  const ctx = new TestContext('test', parentModule);
+  parentModule.tests.pop();
+  ctx.totalExecutedAssertions = 1;
+  if (expectedCount !== undefined) ctx.expectedAssertionCount = expectedCount;
+  return ctx;
+}
+
+const ctxFinishOk = makeFinishableTest();
+Deno.bench('TestContext - finish (1 assertion, no expect)', () => {
+  // Reset state so it doesn't accumulate across iterations.
+  ctxFinishOk.totalExecutedAssertions = 1;
+  ctxFinishOk.steps = [];
+  ctxFinishOk.expectedAssertionCount = undefined;
+  ctxFinishOk.finish();
+});
+
+const ctxFinishExpect = makeFinishableTest(1);
+Deno.bench('TestContext - finish (expect matches)', () => {
+  ctxFinishExpect.totalExecutedAssertions = 1;
+  ctxFinishExpect.steps = [];
+  ctxFinishExpect.expectedAssertionCount = 1;
+  ctxFinishExpect.finish();
+});

package/benches/results.json

@@ -0,0 +1,35 @@
+{
+  "ok - passing": 6.122285937882127,
+  "notOk - passing": 6.052994656027081,
+  "true - passing": 5.893691627414019,
+  "false - passing": 5.552377309526456,
+  "equal - passing": 6.067946223784695,
+  "strictEqual - passing": 5.416006859987021,
+  "notStrictEqual - passing": 5.483480087623222,
+  "deepEqual - flat object": 718.5170962962962,
+  "deepEqual - nested object": 2024.6826599999997,
+  "propEqual - flat object": 1080.7499910714284,
+  "propContains - subset": 1024.682773333333,
+  "pushResult - passing": 5.657819905052545,
+  "step + verifySteps": 407.4118619402984,
+  "throws - passing": 8620,
+  "ModuleContext - creation": 204.09858320312497,
+  "TestContext - creation": 45.03426628010711,
+  "TestContext - finish (1 assertion, no expect)": 16.970750253807086,
+  "TestContext - finish (expect matches)": 15.684375773679301,
+  "objectType - number": 36.452910065170144,
+  "objectType - string": 51.122222345803905,
+  "objectType - null": 5.467147286229134,
+  "objectType - plain object": 55.7791819184124,
+  "objectType - array": 46.39228097426468,
+  "objectType - Date": 188.61341527272734,
+  "objectType - RegExp": 60.643142703349355,
+  "objectValues - flat object (3 keys)": 146.51978607954544,
+  "objectValues - nested object": 403.55127537313405,
+  "objectValues - array (5 items)": 568.6339551020407,
+  "objectValuesSubset - 2 of 4 keys": 102.92081955645169,
+  "validateException - no expected (always passes)": 5.627593457733817,
+  "validateException - regexp match": 748.3865025641023,
+  "validateException - constructor (instanceof)": 63.09276811955177,
+  "validateException - function validator": 71.31606100981766
+}

package/benches/utils.bench.js

@@ -0,0 +1,91 @@
+// Benchmarks for shared utility functions in shims/shared/index.js.
+// These are called on every propEqual, propContains, throws, and rejects call.
+//
+// Run: deno bench --allow-read benches/utils.bench.js
+
+import {
+  objectType,
+  objectValues,
+  objectValuesSubset,
+  validateException,
+} from '../shims/shared/index.js';
+
+// --- objectType ---
+// Called in validateExpectedExceptionArgs and validateException on every
+// throws/rejects assertion, and internally in objectValues.
+
+Deno.bench('objectType - number', () => {
+  objectType(42);
+});
+
+Deno.bench('objectType - string', () => {
+  objectType('hello');
+});
+
+Deno.bench('objectType - null', () => {
+  objectType(null);
+});
+
+Deno.bench('objectType - plain object', () => {
+  objectType({});
+});
+
+Deno.bench('objectType - array', () => {
+  objectType([]);
+});
+
+Deno.bench('objectType - Date', () => {
+  objectType(new Date());
+});
+
+Deno.bench('objectType - RegExp', () => {
+  objectType(/foo/);
+});
+
+// --- objectValues ---
+// Called on every propEqual / propContains invocation to clone own props.
+
+const flatObj = { a: 1, b: 2, c: 3 };
+Deno.bench('objectValues - flat object (3 keys)', () => {
+  objectValues(flatObj);
+});
+
+const nestedObj = { a: { b: 1, c: { d: 2 } }, e: 3 };
+Deno.bench('objectValues - nested object', () => {
+  objectValues(nestedObj);
+});
+
+const arrayObj = [1, 2, 3, 4, 5];
+Deno.bench('objectValues - array (5 items)', () => {
+  objectValues(arrayObj);
+});
+
+// --- objectValuesSubset ---
+// Called on every propContains / notPropContains.
+
+const fullObj = { a: 1, b: 2, c: 3, d: 4 };
+const model = { a: 1, b: 2 };
+Deno.bench('objectValuesSubset - 2 of 4 keys', () => {
+  objectValuesSubset(fullObj, model);
+});
+
+// --- validateException ---
+// Called on every throws / rejects assertion after the error is caught.
+
+const err = new TypeError('bad value');
+
+Deno.bench('validateException - no expected (always passes)', () => {
+  validateException(err, undefined, 'message');
+});
+
+Deno.bench('validateException - regexp match', () => {
+  validateException(err, /bad value/, 'message');
+});
+
+Deno.bench('validateException - constructor (instanceof)', () => {
+  validateException(err, TypeError, 'message');
+});
+
+Deno.bench('validateException - function validator', () => {
+  validateException(err, (e) => e instanceof TypeError, 'message');
+});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "qunitx",
   "type": "module",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "A universal test framework for testing any js file on node.js, browser or deno with QUnit API",
   "author": "Izel Nakri",
   "license": "MIT",
@@ -83,6 +83,9 @@
     "test:node": "node --test test/index.js",
     "coverage": "deno test --coverage=tmp/coverage --allow-read --allow-env --allow-run test/index.js && deno coverage --lcov --output=tmp/coverage/lcov.info --include='shims/' tmp/coverage && node scripts/check-coverage.js",
     "coverage:report": "npm run coverage && deno coverage --html --include='shims/' tmp/coverage",
+    "bench": "deno task bench",
+    "bench:check": "deno task bench:check",
+    "bench:update": "deno task bench:update",
     "docs": "deno doc --html --name=\"QUnitX\" --output=docs/src shims/deno/index.js"
   },
   "devDependencies": {

package/scripts/check-benchmarks.js

@@ -0,0 +1,88 @@
+#!/usr/bin/env -S deno run --allow-read --allow-write --allow-env
+// Regression checker for qunitx benchmarks.
+//
+// Usage:
+//   # Check against saved baseline (fails if any result regresses > threshold):
+//   deno bench --allow-read --json benches/*.bench.js | deno run --allow-read --allow-write --allow-env scripts/check-benchmarks.js
+//
+//   # Save current results as new baseline:
+//   deno bench --allow-read --json benches/*.bench.js | deno run --allow-read --allow-write --allow-env scripts/check-benchmarks.js --save
+
+import { red, green, yellow, dim } from 'jsr:@std/fmt/colors';
+
+const BASELINE_PATH = new URL('../benches/results.json', import.meta.url).pathname;
+const REGRESSION_THRESHOLD = Number(Deno.env.get('REGRESSION_THRESHOLD') ?? '20');
+const isSave = Deno.args.includes('--save');
+
+const raw = await new Response(Deno.stdin.readable).text();
+const data = JSON.parse(raw);
+
+// Flatten results: name → avg nanoseconds
+const current = {};
+for (const bench of data.benches) {
+  const ok = bench.results?.[0]?.ok;
+  if (ok) {
+    current[bench.name] = ok.avg;
+  }
+}
+
+if (isSave) {
+  await Deno.writeTextFile(BASELINE_PATH, JSON.stringify(current, null, 2) + '\n');
+  console.log(`Saved baseline → benches/results.json (${Object.keys(current).length} entries)`);
+  Deno.exit(0);
+}
+
+let baseline;
+try {
+  baseline = JSON.parse(await Deno.readTextFile(BASELINE_PATH));
+} catch {
+  console.log('No baseline found. Run with --save to create one.');
+  Deno.exit(0);
+}
+
+function fmt(ns) {
+  if (ns >= 1e9) return `${(ns / 1e9).toFixed(2)}s`;
+  if (ns >= 1e6) return `${(ns / 1e6).toFixed(2)}ms`;
+  if (ns >= 1e3) return `${(ns / 1e3).toFixed(2)}µs`;
+  return `${ns.toFixed(2)}ns`;
+}
+
+let hasRegression = false;
+const rows = [];
+
+for (const [name, avgNs] of Object.entries(current)) {
+  const baseNs = baseline[name];
+  if (baseNs == null) {
+    rows.push({ name, avgNs, status: 'new' });
+    continue;
+  }
+  const pct = ((avgNs - baseNs) / baseNs) * 100;
+  if (pct > REGRESSION_THRESHOLD) hasRegression = true;
+  rows.push({ name, avgNs, baseNs, pct, status: pct > REGRESSION_THRESHOLD ? 'fail' : 'ok' });
+}
+
+const maxName = Math.max(...rows.map((r) => r.name.length));
+
+for (const row of rows) {
+  const pad = row.name.padEnd(maxName);
+  if (row.status === 'new') {
+    console.log(`  ${yellow('NEW ')} ${pad}  ${fmt(row.avgNs)}`);
+  } else if (row.status === 'fail') {
+    console.log(
+      `  ${red('FAIL')} ${pad}  ${fmt(row.avgNs)}  ${red(`+${row.pct.toFixed(1)}%`)} vs ${dim(fmt(row.baseNs))}`
+    );
+  } else {
+    const sign = row.pct >= 0 ? '+' : '';
+    const pctStr = `${sign}${row.pct.toFixed(1)}%`;
+    console.log(
+      `  ${green('OK  ')} ${pad}  ${fmt(row.avgNs)}  ${row.pct < -5 ? green(pctStr) : dim(pctStr)} vs ${dim(fmt(row.baseNs))}`
+    );
+  }
+}
+
+if (hasRegression) {
+  console.error(`\n${red(`Regressions detected (threshold: ${REGRESSION_THRESHOLD}%)`)}`);
+  Deno.exit(1);
+} else {
+  console.log(`\n${green(`All benchmarks within threshold (${REGRESSION_THRESHOLD}%)`)}`);
+}

package/shims/node/module.js

@@ -37,8 +37,8 @@ export default function module(moduleName, runtimeOptions, moduleContent) {
       }
     });
     afterAll(async () => {
-      for (const assert of moduleContext.tests.map(testContext => testContext.assert)) {
-        await assert.waitForAsyncOps();
+      for (const testContext of moduleContext.tests) {
+        await testContext.assert.waitForAsyncOps();
       }
 
       const targetContext = moduleContext.tests[moduleContext.tests.length - 1];

package/shims/shared/index.js

@@ -1,9 +1,5 @@
 const hasOwn = Object.prototype.hasOwnProperty
 
-const _typeof = typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol'
-  ? (obj) => typeof obj
-  : (obj) => obj && typeof Symbol === 'function' && obj.constructor === Symbol && obj !== Symbol.prototype ? 'symbol' : typeof obj;
-
 export function objectType(obj) {
   if (typeof obj === 'undefined') {
     return 'undefined';
@@ -13,8 +9,8 @@ export function objectType(obj) {
   if (obj === null) {
     return 'null';
   }
-  const match = toString.call(obj).match(/^\[object\s(.*)\]$/);
-  const type = match && match[1];
+  // slice(8, -1) extracts the type name from "[object Foo]" without a regex
+  const type = toString.call(obj).slice(8, -1);
   switch (type) {
     case 'Number':
       if (isNaN(obj)) {
@@ -32,7 +28,7 @@ export function objectType(obj) {
     case 'Symbol':
       return type.toLowerCase();
     default:
-      return _typeof(obj);
+      return typeof obj;
   }
 }
 
@@ -40,8 +36,7 @@ function is(type, obj) {
   return objectType(obj) === type;
 }
 
-export function objectValues(obj) {
-  const allowArray = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+export function objectValues(obj, allowArray = true) {
   const vals = allowArray && is('array', obj) ? [] : {};
 
   for (const key in obj) {