@japa/runner 4.4.0 → 4.4.1

package/build/factories/main.js

@@ -1,241 +1,191 @@
-import {
-  CliParser,
-  ConfigManager,
-  GlobalHooks,
-  Planner,
-  createTest,
-  createTestGroup
-} from "../chunk-TLYU3GFT.js";
-import "../chunk-RFKFNXTE.js";
-import {
-  Emitter,
-  Runner,
-  Suite
-} from "../chunk-L7YZLDZD.js";
-import "../chunk-2KG3PWR4.js";
-
-// factories/runner.ts
-import { fileURLToPath } from "url";
+import { a as GlobalHooks, i as CliParser, n as createTestGroup, o as Planner, r as ConfigManager, t as createTest } from "../create_test-CuTGNCAf.js";
+import { c as Suite, i as Emitter, s as Runner } from "../helpers-BlHaYYTh.js";
+import "../main-CB1nhl6c.js";
+import { fileURLToPath } from "node:url";
+import assert from "node:assert";
 var RunnerFactory = class {
-  #emitter = new Emitter();
-  #config;
-  #cliArgs;
-  #file = fileURLToPath(import.meta.url);
-  #bail = false;
-  get #refiner() {
-    return this.#config.refiner;
-  }
-  /**
-   * Registers plugins
-   */
-  async #registerPlugins(runner2) {
-    for (let plugin of this.#config.plugins) {
-      await plugin({
-        config: this.#config,
-        runner: runner2,
-        emitter: this.#emitter,
-        cliArgs: this.#cliArgs
-      });
-    }
-  }
-  /**
-   * Configure runner
-   */
-  configure(config, argv) {
-    this.#cliArgs = new CliParser().parse(argv || []);
-    this.#config = new ConfigManager(config, this.#cliArgs).hydrate();
-    return this;
-  }
-  /**
-   * Define a custom emitter instance to use
-   */
-  useEmitter(emitter) {
-    this.#emitter = emitter;
-    return this;
-  }
-  /**
-   * Run a test using the runner
-   */
-  async runTest(title, callback) {
-    return this.runSuites((emitter, refiner, file) => {
-      const defaultSuite = new Suite("default", emitter, refiner);
-      const debuggingError = new Error();
-      createTest(title, emitter, refiner, debuggingError, {
-        suite: defaultSuite,
-        file
-      }).run(callback, debuggingError);
-      return [defaultSuite];
-    });
-  }
-  /**
-   * Enable/disable the bail mode
-   */
-  bail(toggle = true) {
-    this.#bail = toggle;
-    return this;
-  }
-  /**
-   * Run dummy tests. You might use
-   */
-  async runSuites(suites) {
-    const runner2 = new Runner(this.#emitter);
-    runner2.bail(this.#bail);
-    await this.#registerPlugins(runner2);
-    const { config, reporters, refinerFilters } = await new Planner(this.#config).plan();
-    const globalHooks = new GlobalHooks();
-    globalHooks.apply(config);
-    reporters.forEach((reporter) => {
-      runner2.registerReporter(reporter);
-    });
-    refinerFilters.forEach((filter) => {
-      config.refiner.add(filter.layer, filter.filters);
-    });
-    suites(this.#emitter, this.#refiner, this.#file).forEach((suite) => runner2.add(suite));
-    await globalHooks.setup(runner2);
-    await runner2.start();
-    await runner2.exec();
-    await runner2.end();
-    await globalHooks.teardown(null, runner2);
-    return runner2.getSummary();
-  }
+	#emitter = new Emitter();
+	#config;
+	#cliArgs;
+	#file = fileURLToPath(import.meta.url);
+	#bail = false;
+	get #refiner() {
+		return this.#config.refiner;
+	}
+	async #registerPlugins(runner$1) {
+		for (let plugin of this.#config.plugins) await plugin({
+			config: this.#config,
+			runner: runner$1,
+			emitter: this.#emitter,
+			cliArgs: this.#cliArgs
+		});
+	}
+	configure(config, argv) {
+		this.#cliArgs = new CliParser().parse(argv || []);
+		this.#config = new ConfigManager(config, this.#cliArgs).hydrate();
+		return this;
+	}
+	useEmitter(emitter) {
+		this.#emitter = emitter;
+		return this;
+	}
+	async runTest(title, callback) {
+		return this.runSuites((emitter, refiner, file) => {
+			const defaultSuite = new Suite("default", emitter, refiner);
+			const debuggingError = /* @__PURE__ */ new Error();
+			createTest(title, emitter, refiner, debuggingError, {
+				suite: defaultSuite,
+				file
+			}).run(callback, debuggingError);
+			return [defaultSuite];
+		});
+	}
+	bail(toggle = true) {
+		this.#bail = toggle;
+		return this;
+	}
+	async runSuites(suites) {
+		const runner$1 = new Runner(this.#emitter);
+		runner$1.bail(this.#bail);
+		await this.#registerPlugins(runner$1);
+		const { config, reporters, refinerFilters } = await new Planner(this.#config).plan();
+		const globalHooks = new GlobalHooks();
+		globalHooks.apply(config);
+		reporters.forEach((reporter) => {
+			runner$1.registerReporter(reporter);
+		});
+		refinerFilters.forEach((filter) => {
+			config.refiner.add(filter.layer, filter.filters);
+		});
+		suites(this.#emitter, this.#refiner, this.#file).forEach((suite) => runner$1.add(suite));
+		await globalHooks.setup(runner$1);
+		await runner$1.start();
+		await runner$1.exec();
+		await runner$1.end();
+		await globalHooks.teardown(null, runner$1);
+		return runner$1.getSummary();
+	}
 };
-
-// factories/create_dummy_tests.ts
-import assert from "assert";
 function createUnitTestsSuite(emitter, refiner, file) {
-  const suite = new Suite("unit", emitter, refiner);
-  const group = createTestGroup("Maths#add", emitter, refiner, {
-    suite,
-    file
-  });
-  createTest("A top level test inside a suite", emitter, refiner, new Error(), {
-    suite,
-    file
-  }).run(() => {
-  });
-  createTest("add two numbers", emitter, refiner, new Error(), { group, file }).run(() => {
-    assert.equal(2 + 2, 4);
-  });
-  createTest("add three numbers", emitter, refiner, new Error(), {
-    group,
-    file
-  }).run(() => {
-    assert.equal(2 + 2 + 2, 6);
-  });
-  createTest("add group of numbers", emitter, refiner, new Error(), { group, file });
-  createTest("use math.js lib", emitter, refiner, new Error(), { group, file }).skip(
-    true,
-    "Library work pending"
-  );
-  createTest("add multiple numbers", emitter, refiner, new Error(), {
-    file,
-    group
-  }).run(() => {
-    assert.equal(2 + 2 + 2 + 2, 6);
-  });
-  createTest("add floating numbers", emitter, refiner, new Error(), { group, file }).run(() => {
-    assert.equal(2 + 2.2 + 2.1, 6);
-  }).fails("Have to add support for floating numbers");
-  createTest("regression test that is passing", emitter, refiner, new Error(), { group, file }).run(() => {
-    assert.equal(2 + 2.2 + 2.1, 2 + 2.2 + 2.1);
-  }).fails("Have to add support for floating numbers");
-  createTest("A test with an error that is not an AssertionError", emitter, refiner, new Error(), {
-    group,
-    file
-  }).run(() => {
-    throw new Error("This is an error");
-  });
-  return suite;
+	const suite = new Suite("unit", emitter, refiner);
+	const group = createTestGroup("Maths#add", emitter, refiner, {
+		suite,
+		file
+	});
+	createTest("A top level test inside a suite", emitter, refiner, /* @__PURE__ */ new Error(), {
+		suite,
+		file
+	}).run(() => {});
+	createTest("add two numbers", emitter, refiner, /* @__PURE__ */ new Error(), {
+		group,
+		file
+	}).run(() => {
+		assert.equal(4, 4);
+	});
+	createTest("add three numbers", emitter, refiner, /* @__PURE__ */ new Error(), {
+		group,
+		file
+	}).run(() => {
+		assert.equal(6, 6);
+	});
+	createTest("add group of numbers", emitter, refiner, /* @__PURE__ */ new Error(), {
+		group,
+		file
+	});
+	createTest("use math.js lib", emitter, refiner, /* @__PURE__ */ new Error(), {
+		group,
+		file
+	}).skip(true, "Library work pending");
+	createTest("add multiple numbers", emitter, refiner, /* @__PURE__ */ new Error(), {
+		file,
+		group
+	}).run(() => {
+		assert.equal(8, 6);
+	});
+	createTest("add floating numbers", emitter, refiner, /* @__PURE__ */ new Error(), {
+		group,
+		file
+	}).run(() => {
+		assert.equal(6.300000000000001, 6);
+	}).fails("Have to add support for floating numbers");
+	createTest("regression test that is passing", emitter, refiner, /* @__PURE__ */ new Error(), {
+		group,
+		file
+	}).run(() => {
+		assert.equal(6.300000000000001, 6.300000000000001);
+	}).fails("Have to add support for floating numbers");
+	createTest("A test with an error that is not an AssertionError", emitter, refiner, /* @__PURE__ */ new Error(), {
+		group,
+		file
+	}).run(() => {
+		throw new Error("This is an error");
+	});
+	return suite;
 }
 function createFunctionalTestsSuite(emitter, refiner, file) {
-  const suite = new Suite("functional", emitter, refiner);
-  const group = createTestGroup("Users/store", emitter, refiner, {
-    suite,
-    file
-  });
-  createTest("Validate user data", emitter, refiner, new Error(), {
-    group,
-    file
-  }).run(() => {
-  });
-  createTest("Disallow duplicate emails", emitter, refiner, new Error(), {
-    group,
-    file
-  }).run(() => {
-  });
-  createTest("Disallow duplicate emails across tenants", emitter, refiner, new Error(), {
-    group,
-    file
-  }).run(() => {
-    const users = ["", ""];
-    assert.equal(users.length, 1);
-  });
-  createTest("Normalize email before persisting it", emitter, refiner, new Error(), {
-    group,
-    file
-  }).skip(true, "Have to build a normalizer");
-  createTest("Send email verification mail", emitter, refiner, new Error(), {
-    group,
-    file
-  });
-  createTest("Test that times out", emitter, refiner, new Error(), {
-    group,
-    file
-  }).run(() => {
-    return new Promise((resolve) => {
-      setTimeout(resolve, 2100);
-    });
-  });
-  const usersListGroup = createTestGroup("Users/list", emitter, refiner, {
-    suite,
-    file
-  });
-  usersListGroup.setup(() => {
-    throw new Error("Unable to cleanup database");
-  });
-  createTest(
-    "A test that will never run because the group hooks fails",
-    emitter,
-    refiner,
-    new Error(),
-    {
-      group: usersListGroup
-    }
-  );
-  createTest("A top level test inside functional suite", emitter, refiner, new Error(), {
-    suite,
-    file
-  }).run(() => {
-  });
-  return suite;
+	const suite = new Suite("functional", emitter, refiner);
+	const group = createTestGroup("Users/store", emitter, refiner, {
+		suite,
+		file
+	});
+	createTest("Validate user data", emitter, refiner, /* @__PURE__ */ new Error(), {
+		group,
+		file
+	}).run(() => {});
+	createTest("Disallow duplicate emails", emitter, refiner, /* @__PURE__ */ new Error(), {
+		group,
+		file
+	}).run(() => {});
+	createTest("Disallow duplicate emails across tenants", emitter, refiner, /* @__PURE__ */ new Error(), {
+		group,
+		file
+	}).run(() => {
+		assert.equal(2, 1);
+	});
+	createTest("Normalize email before persisting it", emitter, refiner, /* @__PURE__ */ new Error(), {
+		group,
+		file
+	}).skip(true, "Have to build a normalizer");
+	createTest("Send email verification mail", emitter, refiner, /* @__PURE__ */ new Error(), {
+		group,
+		file
+	});
+	createTest("Test that times out", emitter, refiner, /* @__PURE__ */ new Error(), {
+		group,
+		file
+	}).run(() => {
+		return new Promise((resolve) => {
+			setTimeout(resolve, 2100);
+		});
+	});
+	const usersListGroup = createTestGroup("Users/list", emitter, refiner, {
+		suite,
+		file
+	});
+	usersListGroup.setup(() => {
+		throw new Error("Unable to cleanup database");
+	});
+	createTest("A test that will never run because the group hooks fails", emitter, refiner, /* @__PURE__ */ new Error(), { group: usersListGroup });
+	createTest("A top level test inside functional suite", emitter, refiner, /* @__PURE__ */ new Error(), {
+		suite,
+		file
+	}).run(() => {});
+	return suite;
 }
 function createDummyTests(emitter, refiner, file) {
-  return [
-    createUnitTestsSuite(emitter, refiner, file),
-    createFunctionalTestsSuite(emitter, refiner, file)
-  ];
+	return [createUnitTestsSuite(emitter, refiner, file), createFunctionalTestsSuite(emitter, refiner, file)];
 }
-
-// factories/main.ts
-var runner = () => new RunnerFactory();
-var syncReporter = {
-  name: "sync",
-  handler(r, emitter) {
-    emitter.on("runner:end", function() {
-      const summary = r.getSummary();
-      if (summary.hasError) {
-        if (summary.failureTree[0].errors.length) {
-          throw summary.failureTree[0].errors[0].error;
-        }
-        if (summary.failureTree[0].children[0].errors.length) {
-          throw summary.failureTree[0].children[0].errors[0].error;
-        }
-      }
-    });
-  }
-};
-export {
-  createDummyTests,
-  runner,
-  syncReporter
+const runner = () => new RunnerFactory();
+const syncReporter = {
+	name: "sync",
+	handler(r, emitter) {
+		emitter.on("runner:end", function() {
+			const summary = r.getSummary();
+			if (summary.hasError) {
+				if (summary.failureTree[0].errors.length) throw summary.failureTree[0].errors[0].error;
+				if (summary.failureTree[0].children[0].errors.length) throw summary.failureTree[0].children[0].errors[0].error;
+			}
+		});
+	}
 };
+export { createDummyTests, runner, syncReporter };

package/build/factories/runner.d.ts

@@ -1,4 +1,4 @@
-import { Suite, Emitter, TestContext, Refiner } from '../modules/core/main.js';
+import { Suite, Emitter, type TestContext, type Refiner } from '../modules/core/main.js';
 import type { Config, TestExecutor, RunnerSummary } from '../src/types.js';
 /**
  * Runner factory exposes the API to run dummy suites, groups and tests.

package/build/helpers-BlHaYYTh.js

@@ -0,0 +1,241 @@
+import { fileURLToPath } from "node:url";
+import { ErrorsPrinter } from "@japa/errors-printer";
+import { inspect } from "node:util";
+import string from "@poppinss/string";
+import useColors from "@poppinss/colors";
+import supportsColor from "supports-color";
+import { parse } from "error-stack-parser-es";
+import { Emitter, Group, Refiner, Runner, Suite, Test, TestContext } from "@japa/core";
+import { AssertionError } from "node:assert";
+var BaseReporter = class {
+	runner;
+	currentFileName;
+	currentSuiteName;
+	currentGroupName;
+	options;
+	constructor(options = {}) {
+		this.options = Object.assign({ stackLinesCount: 2 }, options);
+	}
+	printAggregates(summary) {
+		const tests = [];
+		if (summary.aggregates.passed) tests.push(colors.green(`${summary.aggregates.passed} passed`));
+		if (summary.aggregates.failed) tests.push(colors.red(`${summary.aggregates.failed} failed`));
+		if (summary.aggregates.todo) tests.push(colors.cyan(`${summary.aggregates.todo} todo`));
+		if (summary.aggregates.skipped) tests.push(colors.yellow(`${summary.aggregates.skipped} skipped`));
+		if (summary.aggregates.regression) tests.push(colors.magenta(`${summary.aggregates.regression} regression`));
+		this.runner.summaryBuilder.use(() => {
+			return [{
+				key: colors.dim("Tests"),
+				value: `${tests.join(", ")} ${colors.dim(`(${summary.aggregates.total})`)}`
+			}, {
+				key: colors.dim("Time"),
+				value: colors.dim(string.milliseconds.format(summary.duration))
+			}];
+		});
+		console.log(this.runner.summaryBuilder.build().join("\n"));
+	}
+	aggregateErrors(summary) {
+		const errorsList = [];
+		summary.failureTree.forEach((suite) => {
+			suite.errors.forEach((error) => errorsList.push({
+				title: suite.name,
+				...error
+			}));
+			suite.children.forEach((testOrGroup) => {
+				if (testOrGroup.type === "test") {
+					testOrGroup.errors.forEach((error) => {
+						errorsList.push({
+							title: `${suite.name} / ${testOrGroup.title}`,
+							...error
+						});
+					});
+					return;
+				}
+				testOrGroup.errors.forEach((error) => {
+					errorsList.push({
+						title: testOrGroup.name,
+						...error
+					});
+				});
+				testOrGroup.children.forEach((test) => {
+					test.errors.forEach((error) => {
+						errorsList.push({
+							title: `${testOrGroup.name} / ${test.title}`,
+							...error
+						});
+					});
+				});
+			});
+		});
+		return errorsList;
+	}
+	async printErrors(summary) {
+		if (!summary.failureTree.length) return;
+		const errorPrinter = new ErrorsPrinter({ framesMaxLimit: this.options.framesMaxLimit });
+		errorPrinter.printSectionHeader("ERRORS");
+		await errorPrinter.printErrors(this.aggregateErrors(summary));
+	}
+	onTestStart(_) {}
+	onTestEnd(_) {}
+	onGroupStart(_) {}
+	onGroupEnd(_) {}
+	onSuiteStart(_) {}
+	onSuiteEnd(_) {}
+	async start(_) {}
+	async end(_) {}
+	async printSummary(summary) {
+		await this.printErrors(summary);
+		console.log("");
+		if (summary.aggregates.total === 0 && !summary.hasError) {
+			console.log(colors.bgYellow().black(" NO TESTS EXECUTED "));
+			return;
+		}
+		if (summary.hasError) console.log(colors.bgRed().black(" FAILED "));
+		else console.log(colors.bgGreen().black(" PASSED "));
+		console.log("");
+		this.printAggregates(summary);
+	}
+	boot(runner, emitter) {
+		this.runner = runner;
+		emitter.on("test:start", (payload) => {
+			this.currentFileName = payload.meta.fileName;
+			this.onTestStart(payload);
+		});
+		emitter.on("test:end", (payload) => {
+			this.onTestEnd(payload);
+		});
+		emitter.on("group:start", (payload) => {
+			this.currentGroupName = payload.title;
+			this.currentFileName = payload.meta.fileName;
+			this.onGroupStart(payload);
+		});
+		emitter.on("group:end", (payload) => {
+			this.currentGroupName = void 0;
+			this.onGroupEnd(payload);
+		});
+		emitter.on("suite:start", (payload) => {
+			this.currentSuiteName = payload.name;
+			this.onSuiteStart(payload);
+		});
+		emitter.on("suite:end", (payload) => {
+			this.currentSuiteName = void 0;
+			this.onSuiteEnd(payload);
+		});
+		emitter.on("runner:start", async (payload) => {
+			await this.start(payload);
+		});
+		emitter.on("runner:end", async (payload) => {
+			await this.end(payload);
+		});
+	}
+};
+var TestContext$1 = class extends TestContext {
+	constructor(test) {
+		super();
+		this.test = test;
+		this.cleanup = (cleanupCallback) => {
+			test.cleanup(cleanupCallback);
+		};
+	}
+};
+var Test$1 = class extends Test {
+	static executedCallbacks = [];
+	static executingCallbacks = [];
+	throws(message, errorConstructor) {
+		const errorInPoint = new AssertionError({});
+		const existingExecutor = this.options.executor;
+		if (!existingExecutor) throw new Error("Cannot use \"test.throws\" method without a test callback");
+		this.options.executor = async (...args) => {
+			let raisedException;
+			try {
+				await existingExecutor(...args);
+			} catch (error) {
+				raisedException = error;
+			}
+			if (!raisedException) {
+				errorInPoint.message = "Expected test to throw an exception";
+				throw errorInPoint;
+			}
+			if (errorConstructor && !(raisedException instanceof errorConstructor)) {
+				errorInPoint.message = `Expected test to throw "${inspect(errorConstructor)}"`;
+				throw errorInPoint;
+			}
+			const exceptionMessage = raisedException.message;
+			if (!exceptionMessage || typeof exceptionMessage !== "string") {
+				errorInPoint.message = "Expected test to throw an exception with message property";
+				throw errorInPoint;
+			}
+			if (typeof message === "string") {
+				if (exceptionMessage !== message) {
+					errorInPoint.message = `Expected test to throw "${message}". Instead received "${raisedException.message}"`;
+					errorInPoint.actual = raisedException.message;
+					errorInPoint.expected = message;
+					throw errorInPoint;
+				}
+				return;
+			}
+			if (!message.test(exceptionMessage)) {
+				errorInPoint.message = `Expected test error to match "${message}" regular expression`;
+				throw errorInPoint;
+			}
+		};
+		return this;
+	}
+};
+var Group$1 = class extends Group {};
+var Suite$1 = class extends Suite {};
+var Runner$1 = class extends Runner {};
+const colors = supportsColor.stdout ? useColors.ansi() : useColors.silent();
+const icons = process.platform === "win32" && !process.env.WT_SESSION ? {
+	tick: "√",
+	cross: "×",
+	bullet: "*",
+	nodejs: "♦",
+	pointer: ">",
+	info: "i",
+	warning: "‼",
+	branch: " -",
+	squareSmallFilled: "[█]"
+} : {
+	tick: "✔",
+	cross: "✖",
+	bullet: "●",
+	nodejs: "⬢",
+	pointer: "❯",
+	info: "ℹ",
+	warning: "⚠",
+	branch: "└──",
+	squareSmallFilled: "◼"
+};
+function formatPinnedTest(test) {
+	let fileName = "";
+	let line = 0;
+	let column = 0;
+	try {
+		test.options.meta.abort("Finding pinned test location");
+	} catch (error) {
+		const frame = parse(error).find((f) => f.fileName && f.lineNumber !== void 0 && f.columnNumber !== void 0 && !f.fileName.includes("node:") && !f.fileName.includes("ext:") && !f.fileName.includes("node_modules/"));
+		if (frame) {
+			fileName = frame.fileName.startsWith("file:") ? string.toUnixSlash(fileURLToPath(frame.fileName)) : string.toUnixSlash(frame.fileName);
+			line = frame.lineNumber;
+			column = frame.columnNumber;
+		}
+	}
+	return `${colors.yellow(` ⁃ ${test.title}`)}\n${colors.dim(`   ${fileName}:${line}:${column}`)}`;
+}
+function printPinnedTests(runner) {
+	let pinnedTests = [];
+	runner.suites.forEach((suite) => {
+		suite.stack.forEach((testOrGroup) => {
+			if (testOrGroup instanceof Group$1) testOrGroup.tests.forEach(($test) => {
+				if ($test.isPinned) pinnedTests.push(formatPinnedTest($test));
+			});
+			else if (testOrGroup.isPinned) pinnedTests.push(formatPinnedTest(testOrGroup));
+		});
+	});
+	if (pinnedTests.length) {
+		console.log(colors.bgYellow().black(` ${pinnedTests.length} pinned test(s) found `));
+		pinnedTests.forEach((row) => console.log(row));
+	} else console.log(colors.bgYellow().black(` No pinned tests found `));
+}
+export { Group$1 as a, Suite$1 as c, BaseReporter as d, Emitter as i, Test$1 as l, icons as n, Refiner as o, printPinnedTests as r, Runner$1 as s, colors as t, TestContext$1 as u };