@japa/runner/build/factories/main.js

A simple yet powerful testing framework for Node.js

import { a as GlobalHooks, i as CliParser, n as createTestGroup, o as Planner, r as ConfigManager, t as createTest } from "../create_test-C7_T6lrm.js";
import { a as Emitter, c as Runner, l as Suite } from "../helpers-C1bD1eod.js";
import "../main-CjKU6911.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;
	}
	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();
	}
};
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, /* @__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, /* @__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)];
}
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 };