qunitx 1.2.19 → 1.3.1

package/dist/node/index.js

@@ -22,15 +22,26 @@ Object.freeze(Assert);
 Object.freeze(ModuleContext);
 Object.freeze(TestContext);
 import { default as default2 } from "./module.js";
-const skip = Test.skip;
 import { default as default3 } from "./test.js";
+import { default as default4 } from "./module.js";
+const skip = Test.skip;
+import { default as default5 } from "./test.js";
 const todo = Test.todo;
-var node_default = { AssertionError: Assert.AssertionError, module: Module, test: Test, config: {} };
+var node_default = {
+  AssertionError: Assert.AssertionError,
+  describe: Module,
+  it: Test,
+  module: Module,
+  test: Test,
+  config: {}
+};
 export {
   Assert,
   node_default as default,
-  default2 as module,
+  default2 as describe,
+  default3 as it,
+  default4 as module,
   skip,
-  default3 as test,
+  default5 as test,
   todo
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "qunitx",
   "type": "module",
-  "version": "1.2.19",
+  "version": "1.3.1",
   "description": "Universal test library — run the same test file in Node.js, Deno, and the browser with QUnit's battle-tested assertion API",
   "author": "Izel Nakri",
   "license": "MIT",

package/shims/deno/index.ts

@@ -6,13 +6,16 @@
  *
  * @example
  * ```js
+ * // math_test.js
  * import { module, test } from "qunitx";
  *
  * module("Math", (hooks) => {
- *   hooks.before((assert) => assert.step("setup"));
+ *   hooks.beforeEach(function () {
+ *     this.numbers = [1, 2, 3];
+ *   });
  *
- *   test("addition", (assert) => {
- *     assert.equal(1 + 1, 2);
+ *   test("addition", function (assert) {
+ *     assert.equal(this.numbers.reduce((sum, n) => sum + n, 0), 6);
  *   });
  *
  *   test("async", async (assert) => {
@@ -22,6 +25,52 @@
  * });
  * ```
  *
+ * Both runtimes install it under the same name, so that one file runs on either.
+ * In a Deno project:
+ *
+ * ```sh
+ * deno add qunitx
+ * ```
+ *
+ * In a Node project:
+ *
+ * ```sh
+ * npm install --save-dev qunitx
+ * ```
+ *
+ * Then run it with whichever runner you have:
+ *
+ * ```sh
+ * deno test math_test.js
+ * node --test math_test.js
+ * ```
+ *
+ * @example
+ * ```js
+ * // The same test written with the BDD aliases — describe and it are the same
+ * // function objects as module and test, so everything above applies unchanged.
+ * import { describe, it } from "qunitx";
+ *
+ * describe("Math", (hooks) => {
+ *   hooks.beforeEach(function () {
+ *     this.numbers = [1, 2, 3];
+ *   });
+ *
+ *   it("addition", function (assert) {
+ *     assert.equal(this.numbers.reduce((sum, n) => sum + n, 0), 6);
+ *   });
+ *
+ *   it("async", async (assert) => {
+ *     const n = await Promise.resolve(42);
+ *     assert.strictEqual(n, 42);
+ *   });
+ * });
+ * ```
+ *
+ * `describe.skip`, `it.skip`, `it.todo`, runtime options, and nesting all behave
+ * identically to their `module` / `test` counterparts, and the commands above are
+ * unchanged.
+ *
  * @module
  */
 import '../../vendor/qunit.js';
@@ -123,6 +172,49 @@ export { Assert };
  */
 export { default as module } from './module.ts';
 
+/**
+ * BDD-style alias for {@linkcode module}. The same function object, so
+ * `describe.skip` and `describe.todo` behave exactly like `module.skip` and
+ * `module.todo`.
+ *
+ * @example
+ * ```js
+ * import { describe, it } from "qunitx";
+ *
+ * describe("Math", (hooks) => {
+ *   hooks.beforeEach((assert) => {
+ *     assert.step("setup");
+ *   });
+ *
+ *   it("adds", (assert) => {
+ *     assert.equal(1 + 1, 2);
+ *   });
+ * });
+ * ```
+ */
+export { default as describe } from './module.ts';
+
+/**
+ * BDD-style alias for {@linkcode test}. The same function object, so `it.skip`
+ * and `it.todo` behave exactly like `test.skip` and `test.todo`.
+ *
+ * @example
+ * ```js
+ * import { describe, it } from "qunitx";
+ *
+ * describe("Math", () => {
+ *   it("adds", (assert) => {
+ *     assert.equal(1 + 1, 2);
+ *   });
+ *
+ *   it.skip("divides", (assert) => {
+ *     assert.equal(4 / 2, 2);
+ *   });
+ * });
+ * ```
+ */
+export { default as it } from './test.ts';
+
 /**
  * Registers a skipped test. Equivalent to `test.skip`. The test body is never
  * executed and the test is reported as ignored by Deno's runner.
@@ -213,12 +305,21 @@ export const todo: (testName: string, _testContent?: unknown) => void = Test.tod
  * @property {Function} test - Defines an individual test inside a `module()` callback.
  *   Receives an {@linkcode Assert} instance as its first argument.
  *   See the named {@linkcode test} export for full parameter documentation.
+ * @property {Function} describe - BDD-style alias for `module`. Same function object.
+ * @property {Function} it - BDD-style alias for `test`. Same function object.
  * @property {typeof AssertionError} AssertionError - The error class thrown when an
  *   assertion fails. Extends Deno's built-in `AssertionError`.
  * @property {object} config - Runtime configuration object (currently unused; reserved
  *   for future QUnit config compatibility).
  */
-export default { AssertionError: Assert.AssertionError, module: Module, test: Test, config: {} };
+export default {
+  AssertionError: Assert.AssertionError,
+  describe: Module,
+  it: Test,
+  module: Module,
+  test: Test,
+  config: {},
+};
 
 /** Public types referenced by the signatures above, so consumers can name them. */
 export type { HookFn, HooksObject, PushResultInfo, TestFn } from '../types.ts';