@w-lfpup/jackrabbit 0.2.0 → 0.3.0

package/webdriver/src/logger.ts

@@ -0,0 +1,247 @@
+import type { EndTest } from "../../core/dist/jackrabbit_types.js";
+import type { ConfigInterface } from "./config.js";
+import type {
+	EventBus,
+	WebdriverLogAction,
+	WebdriverSessionErrorAction,
+} from "./eventbus.js";
+import type { SessionResults, RunResults } from "./results.js";
+
+import { getResultsAsString } from "./results_str.js";
+
+export class Logger {
+	#eventbus: EventBus;
+
+	#sessionResults: SessionResults = {
+		fails: 0,
+		errors: 0,
+		runs: new Map(),
+	};
+
+	constructor(config: ConfigInterface, eventbus: EventBus) {
+		this.#eventbus = eventbus;
+		this.#eventbus.addListener("log", this.#boundLog);
+		this.#eventbus.addListener("session_error", this.#boundError);
+
+		for (let webdriverParams of config.webdrivers) {
+			this.#sessionResults.runs.set(webdriverParams.jrId, {
+				startTime: 0,
+				fails: 0,
+				errors: 0,
+				expectedTests: 0,
+				expectedModules: 0,
+				endTime: 0,
+				testTime: 0,
+				errorLogs: [],
+				completedTests: 0,
+				completedModules: 0,
+				expectedCollections: 0,
+				completedCollections: 0,
+				webdriverParams,
+				collections: [],
+			});
+		}
+	}
+
+	get failed() {
+		return this.#sessionResults.fails !== 0;
+	}
+
+	get errored() {
+		return this.#sessionResults.errors !== 0;
+	}
+
+	get compeleted() {
+		return false;
+	}
+
+	get results(): string {
+		return getResultsAsString(this.#sessionResults);
+	}
+
+	// get output
+	// output being a array of a string
+	#boundError = this.#onError.bind(this);
+	#onError(action: WebdriverSessionErrorAction) {
+		let runResults = this.#sessionResults.runs.get(action.id);
+		if (runResults) {
+			this.#sessionResults.errors += 1;
+			runResults.errors += 1;
+			runResults.errorLogs.push(action);
+		}
+	}
+
+	#boundLog = this.#onLog.bind(this);
+	#onLog(action: WebdriverLogAction) {
+		let { loggerAction, id } = action;
+
+		let runResults = this.#sessionResults.runs.get(id);
+		if (!runResults) return;
+
+		if ("start_run" === loggerAction.type) {
+			runResults.startTime = loggerAction.time;
+			runResults.expectedCollections = loggerAction.expected_collection_count;
+		}
+
+		if ("end_run" === loggerAction.type) {
+			runResults.endTime = loggerAction.time;
+			this.#eventbus.dispatchAction({
+				type: "run_complete",
+				id,
+			});
+		}
+
+		if ("run_error" === loggerAction.type) {
+			this.#sessionResults.errors += 1;
+			runResults.errors += 1;
+			runResults.errorLogs.push(action);
+		}
+
+		if ("start_collection" === loggerAction.type) {
+			runResults.collections[loggerAction.collection_id] = {
+				completedModules: 0,
+				completedTests: 0,
+				errorLogs: [],
+				errors: 0,
+				expectedModules: loggerAction.expected_module_count,
+				expectedTests: 0,
+				fails: 0,
+				loggerAction,
+				modules: [],
+			};
+
+			runResults.expectedModules += loggerAction.expected_module_count;
+		}
+
+		if ("end_collection" === loggerAction.type) {
+			let collection = runResults.collections[loggerAction.collection_id];
+			if (!collection) return;
+
+			runResults.completedCollections += 1;
+		}
+
+		if ("collection_error" === loggerAction.type) {
+			let collection = runResults.collections[loggerAction.collection_id];
+			if (!collection) return;
+
+			this.#sessionResults.errors += 1;
+			runResults.errors += 1;
+			collection.errors += 1;
+
+			collection.errorLogs.push(loggerAction);
+		}
+
+		if ("start_module" === loggerAction.type) {
+			let collection = runResults.collections[loggerAction.collection_id];
+			if (!collection) return;
+
+			collection.modules[loggerAction.module_id] = {
+				completedTests: 0,
+				errorLogs: [],
+				errors: 0,
+				expectedTests: loggerAction.expected_test_count,
+				fails: 0,
+				loggerAction,
+				testResults: [],
+			};
+
+			collection.expectedTests += loggerAction.expected_test_count;
+			runResults.expectedTests += loggerAction.expected_test_count;
+		}
+
+		if ("end_module" === loggerAction.type) {
+			let collection = runResults.collections[loggerAction.collection_id];
+			if (!collection) return;
+
+			let module = collection.modules[loggerAction.module_id];
+			if (!module) return;
+
+			runResults.completedModules += 1;
+			collection.completedModules += 1;
+		}
+
+		if ("module_error" === loggerAction.type) {
+			let collection = runResults.collections[loggerAction.collection_id];
+			if (!collection) return;
+
+			let module = collection.modules[loggerAction.module_id];
+			if (!module) return;
+
+			this.#sessionResults.errors += 1;
+			runResults.errors += 1;
+			collection.errors += 1;
+			module.errors += 1;
+			module.errorLogs.push(loggerAction);
+		}
+
+		if ("start_test" === loggerAction.type) {
+			let collection = runResults.collections[loggerAction.collection_id];
+			if (!collection) return;
+
+			let module = collection.modules[loggerAction.module_id];
+			if (!module) return;
+
+			module.testResults[loggerAction.test_id] = {
+				loggerStartAction: loggerAction,
+				loggerEndAction: undefined,
+			};
+		}
+
+		if ("end_test" === loggerAction.type) {
+			endTest(this.#sessionResults, runResults, loggerAction);
+		}
+
+		if ("test_error" === loggerAction.type) {
+			let collection = runResults.collections[loggerAction.collection_id];
+			if (!collection) return;
+
+			let module = collection.modules[loggerAction.module_id];
+			if (!module) return;
+
+			let testResult = module.testResults[loggerAction.test_id];
+			if (!testResult) return;
+
+			testResult.loggerEndAction = loggerAction;
+			this.#sessionResults.errors += 1;
+			runResults.errors += 1;
+			collection.errors += 1;
+			module.errors += 1;
+		}
+	}
+}
+
+function endTest(
+	sessionResults: SessionResults,
+	runResults: RunResults,
+	loggerAction: EndTest,
+) {
+	let collection = runResults.collections[loggerAction.collection_id];
+	if (!collection) return;
+
+	let module = collection.modules[loggerAction.module_id];
+	if (!module) return;
+
+	let testResult = module.testResults[loggerAction.test_id];
+	if (!testResult) return;
+
+	testResult.loggerEndAction = loggerAction;
+	runResults.completedTests += 1;
+	collection.completedTests += 1;
+	module.completedTests += 1;
+
+	let { assertions } = loggerAction;
+	const isAssertionArray = Array.isArray(assertions) && assertions.length;
+	// might be worth just sticking with language standard "none" like "" or 0 or false
+	const isAssertion = !Array.isArray(assertions) && undefined !== assertions;
+	if (isAssertion || isAssertionArray) {
+		sessionResults.fails += 1;
+		runResults.fails += 1;
+		collection.fails += 1;
+		module.fails += 1;
+	}
+
+	runResults.testTime += Math.max(
+		0,
+		loggerAction.end_time - loggerAction.start_time,
+	);
+}

package/webdriver/src/mod.ts

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+
+import * as http from "http";
+import { createConfig } from "./config.js";
+import { Logger } from "./logger.js";
+import { Router } from "./routes.js";
+import { WebDrivers } from "./webdriver.js";
+import { EventBus } from "./eventbus.js";
+
+let args = process.argv.slice(2);
+
+const config = await createConfig(args);
+if (config instanceof Error) {
+	console.log(config);
+	process.exit(1);
+}
+
+let eventbus = new EventBus();
+let logger = new Logger(config, eventbus);
+let router = new Router(config, eventbus);
+let webdrivers = new WebDrivers(config, eventbus);
+
+// setup server
+let server = http.createServer();
+server.addListener("request", router.route);
+server.addListener("close", function () {
+	console.log(logger.results);
+	logger.errored || logger.failed ? process.exit(1) : process.exit(0);
+});
+eventbus.addListener("end", function () {
+	server.closeAllConnections();
+	server.close();
+});
+
+// run server
+let { port, hostname } = config.hostAndPort;
+server.listen({
+	port,
+	hostname,
+});
+
+// start test run
+config.runAsynchronously ? webdrivers.runAll() : webdrivers.run();

package/webdriver/src/results.ts

@@ -0,0 +1,56 @@
+import type { LoggerAction } from "../../core/dist/jackrabbit_types.js";
+import type { WebdriverParams } from "./config.js";
+import type { WebdriverActions } from "./eventbus.js";
+
+export interface TestResults {
+	loggerStartAction: LoggerAction;
+	loggerEndAction: LoggerAction | undefined;
+}
+
+// remove logger actions
+export interface ModuleResults {
+	loggerAction: LoggerAction;
+	fails: number;
+	errors: number;
+	expectedTests: number;
+	completedTests: number;
+	errorLogs: LoggerAction[];
+	testResults: (TestResults | undefined)[];
+}
+
+export interface CollectionResults {
+	loggerAction: LoggerAction;
+	fails: number;
+	errors: number;
+	expectedTests: number;
+	completedTests: number;
+	expectedModules: number;
+	completedModules: number;
+	errorLogs: LoggerAction[];
+	modules: (ModuleResults | undefined)[];
+}
+
+export interface RunResults {
+	fails: number;
+	errors: number;
+	startTime: number;
+	endTime: number;
+	testTime: number;
+	expectedTests: number;
+	completedTests: number;
+	expectedModules: number;
+	completedModules: number;
+	expectedCollections: number;
+	completedCollections: number;
+	errorLogs: WebdriverActions[];
+	webdriverParams: WebdriverParams;
+	collections: (CollectionResults | undefined)[];
+}
+
+// track if session started or not
+// if browser never launched
+export interface SessionResults {
+	fails: number;
+	errors: number;
+	runs: Map<string, RunResults>;
+}

package/webdriver/src/results_str.ts

@@ -0,0 +1,222 @@
+import type {
+	SessionResults,
+	RunResults,
+	CollectionResults,
+	ModuleResults,
+	TestResults,
+} from "./results.js";
+
+const SPACE = "  ";
+
+export function getResultsAsString(sessionResults: SessionResults): string {
+	const output: string[] = [];
+
+	// Lots of nested loops because results a nested structure.
+	// I'd rather see composition nested in one function
+	// than have for loops spread across each function.
+
+	logSessionErrors(output, sessionResults);
+
+	for (let [, result] of sessionResults.runs) {
+		if (logRunResults(output, result)) continue;
+
+		for (const collection of result.collections) {
+			if (logCollectionResult(output, collection)) continue;
+
+			if (collection)
+				for (const moduleResult of collection.modules) {
+					if (logModuleResult(output, moduleResult)) continue;
+
+					if (moduleResult)
+						for (const testResult of moduleResult.testResults) {
+							logTest(output, testResult);
+						}
+				}
+		}
+	}
+
+	logSummary(output, sessionResults);
+
+	return output.join("\n");
+}
+
+function logSessionErrors(output: string[], sessionResults: SessionResults) {
+	for (let [, result] of sessionResults.runs) {
+		for (let errorAction of result.errorLogs) {
+			if ("session_error" === errorAction.type) {
+				output.push(
+					`\n[${result.webdriverParams.title}:session_error] ${errorAction.error}`,
+				);
+			}
+		}
+	}
+}
+
+function logRunResults(output: string[], result: RunResults): boolean {
+	output.push(`
+${result.webdriverParams.title}`);
+
+	for (let errorAction of result.errorLogs) {
+		if ("log" === errorAction.type) {
+			if ("run_error" === errorAction.loggerAction.type) {
+				output.push(`${SPACE}[run_error] ${errorAction.loggerAction.error}`);
+			}
+		}
+	}
+
+	if (!result.expectedTests) {
+		output.push(`  No test runs occured.`);
+	}
+	// When everything goes right :3
+	if (
+		!result.fails &&
+		!result.errors &&
+		result.expectedTests === result.completedTests &&
+		result.expectedModules === result.completedModules &&
+		result.expectedCollections === result.completedCollections
+	) {
+		output.push(`${SPACE}${result.completedTests} tests
+${SPACE}${result.completedModules} modules
+${SPACE}${result.completedCollections} collections`);
+		return true;
+	}
+
+	return false;
+}
+
+function logCollectionResult(
+	output: string[],
+	collection: CollectionResults | undefined,
+): boolean {
+	if (!collection) return true;
+
+	let { loggerAction } = collection;
+	if ("start_collection" !== loggerAction.type) return true;
+
+	output.push(`${SPACE}${loggerAction.collection_url}`);
+
+	// when everything in the collection goes right
+	if (
+		!collection.fails &&
+		!collection.errors &&
+		collection.expectedTests === collection.completedTests &&
+		collection.expectedModules === collection.completedModules
+	) {
+		output.push(
+			`${SPACE.repeat(2)}${collection.expectedTests} tests
+${SPACE.repeat(2)}${loggerAction.expected_module_count} modules`,
+		);
+
+		return true;
+	}
+
+	for (let errorAction of collection.errorLogs) {
+		if ("collection_error" !== errorAction.type) continue;
+		output.push(`${SPACE.repeat(2)}[collection_error] ${errorAction.error}`);
+	}
+
+	return false;
+}
+
+function logModuleResult(
+	output: string[],
+	module: ModuleResults | undefined,
+): boolean {
+	if (!module) return true;
+
+	let { loggerAction } = module;
+	if ("start_module" !== loggerAction.type) return true;
+
+	output.push(`${SPACE.repeat(2)}${loggerAction.module_name}`);
+
+	// when everything in the module goes right
+	if (
+		!module.fails &&
+		!module.errors &&
+		module.expectedTests === module.completedTests
+	) {
+		output.push(`${SPACE.repeat(3)}${module.expectedTests} tests`);
+		return true;
+	}
+
+	for (let errorAction of module.errorLogs) {
+		if ("collection_error" !== errorAction.type) continue;
+		output.push(`${SPACE.repeat(2)}[module_error] ${errorAction.error}`);
+	}
+
+	return false;
+}
+
+function logTest(output: string[], test: TestResults | undefined) {
+	if (!test) return;
+
+	let { loggerStartAction, loggerEndAction } = test;
+	if ("start_test" !== loggerStartAction.type) return;
+
+	if ("test_error" === loggerEndAction?.type) {
+		let { test_name } = loggerStartAction;
+		output.push(
+			`${SPACE.repeat(3)}${test_name}
+${SPACE.repeat(4)}[error] ${loggerEndAction.error}`,
+		);
+	}
+
+	if ("end_test" === loggerEndAction?.type) {
+		let { assertions } = loggerEndAction;
+		const isAssertionArray = Array.isArray(assertions) && assertions.length;
+		const isAssertion =
+			!Array.isArray(assertions) &&
+			undefined !== assertions &&
+			null !== assertions;
+
+		if (isAssertion || isAssertionArray) {
+			let { test_name } = loggerStartAction;
+			output.push(`${SPACE.repeat(3)}${test_name}`);
+		}
+
+		if (isAssertion) {
+			output.push(`${SPACE.repeat(4)}- ${assertions}`);
+		}
+
+		if (isAssertionArray) {
+			for (const assertion of assertions) {
+				output.push(`${SPACE.repeat(4)}- ${assertion}`);
+			}
+		}
+	}
+}
+
+function logSummary(output: string[], sessionResults: SessionResults) {
+	let status_with_color = blue("\u{2714} passed");
+	if (sessionResults.fails) status_with_color = yellow("\u{2717} failed");
+	if (sessionResults.errors) status_with_color = gray("\u{2717} errored");
+
+	// expected tests
+
+	let totalTime = 0;
+	let testTime = 0;
+	for (let [, run] of sessionResults.runs) {
+		totalTime += run.endTime - run.startTime;
+		testTime += run.testTime;
+	}
+
+	output.push(`
+${status_with_color}
+duration: ${testTime.toFixed(4)} mS
+total: ${totalTime.toFixed(4)} mS
+`);
+}
+
+// 39 - default foreground color
+// 49 - default background color
+function blue(text: string) {
+	return `\x1b[44m\x1b[97m${text}\x1b[0m`;
+}
+
+function yellow(text: string) {
+	return `\x1b[43m\x1b[97m${text}\x1b[0m`;
+}
+
+function gray(text: string) {
+	return `\x1b[100m\x1b[97m${text}\x1b[0m`;
+}