@w-lfpup/jackrabbit 0.2.0 → 0.3.1

package/webdriver/src/config.ts

@@ -0,0 +1,89 @@
+import * as path from "path";
+
+interface WebdriverConfig {
+	command: string;
+	url: URL;
+	title: string;
+	timeoutMs: number;
+	capabilities?: unknown;
+}
+
+export interface WebdriverParams extends WebdriverConfig {
+	jrId: string;
+}
+
+export interface ConfigInterface {
+	hostAndPort: URL;
+	runAsynchronously?: boolean;
+	webdrivers: WebdriverParams[];
+}
+
+export async function createConfig(
+	args: string[],
+): Promise<ConfigInterface | Error> {
+	let configFilepath = args[0];
+	let relPath = path.resolve(process.cwd(), configFilepath);
+
+	try {
+		// windows might need a "file://<relPath>" situation
+		let { default: json } = await import(`file://${relPath}`, {
+			with: { type: "json" },
+		});
+
+		let hostAndPort: URL | null = URL.parse(json.host_and_port);
+		if (!hostAndPort)
+			throw new Error(`Config: invalid host_and_port json property`);
+
+		let { run_asynchronously: runAsynchronously } = json;
+		if (
+			typeof runAsynchronously !== "boolean" &&
+			undefined !== runAsynchronously
+		)
+			throw new Error(
+				"Config: the property runAsynchronously is not a boolean or undefined",
+			);
+
+		let webdrivers: WebdriverParams[] = [];
+		if (Array.isArray(json.webdrivers))
+			for (const [index, webdriverParams] of json.webdrivers.entries()) {
+				let params = createWebdriverParams(webdriverParams);
+				if (params instanceof Error) return params;
+
+				let session = Math.floor(Math.random() * Number.MAX_SAFE_INTEGER);
+				let jrId = `${index}:${session.toString(32)}`;
+
+				webdrivers.push({ ...params, jrId });
+			}
+		return {
+			hostAndPort,
+			runAsynchronously,
+			webdrivers,
+		};
+	} catch (e) {
+		if (e instanceof Error) return e;
+		return new Error("Config: failed to parse config params from string");
+	}
+}
+
+export function createWebdriverParams(json: any): WebdriverConfig | Error {
+	let { command, url, title, timeout_ms, capabilities } = json;
+
+	if (typeof command !== "string")
+		return new Error("WebdriverParams: command is not a string");
+
+	let parsedUrl: URL | null = URL.parse(url);
+	if (null === parsedUrl)
+		return new Error("WebdriverParams: url is not a valid URL");
+	if (typeof title !== "string")
+		return new Error("WebdriverParams: title is not a string");
+	if (typeof timeout_ms !== "number")
+		return new Error("WebdriverParams: timeout_ms is not a number");
+
+	return {
+		command,
+		url: parsedUrl,
+		title,
+		timeoutMs: timeout_ms,
+		capabilities,
+	};
+}

package/webdriver/src/eventbus.ts

@@ -0,0 +1,104 @@
+import type { LoggerAction } from "../../core/dist/jackrabbit_types.js";
+
+export interface WebdriverSessionAction {
+	id: string;
+}
+
+export interface WebdriverSessionStartAction extends WebdriverSessionAction {
+	type: "session_start";
+}
+
+export interface WebdriverSessionErrorAction extends WebdriverSessionAction {
+	type: "session_error";
+	error: string;
+}
+
+export interface WebdriverSessionClosedAction extends WebdriverSessionAction {
+	type: "session_closed";
+}
+
+export interface WebdriverRunCompleteAction extends WebdriverSessionAction {
+	type: "run_complete";
+}
+
+export interface WebdriverLogAction extends WebdriverSessionAction {
+	type: "log";
+	loggerAction: LoggerAction;
+}
+
+export interface WebdriverCliOutpuAction extends WebdriverSessionAction {
+	type: "stdout";
+	output: string;
+}
+
+export interface WebdriverCliErrorOutpuAction extends WebdriverSessionAction {
+	type: "stderr";
+	output: string;
+}
+
+export interface WebdriverEndAction {
+	type: "end";
+}
+
+export interface WebdriverActionMap {
+	end: WebdriverEndAction;
+	log: WebdriverLogAction;
+	run_complete: WebdriverRunCompleteAction;
+	session_closed: WebdriverSessionClosedAction;
+	session_error: WebdriverSessionErrorAction;
+	session_start: WebdriverSessionStartAction;
+	stderr: WebdriverCliErrorOutpuAction;
+	stdout: WebdriverCliOutpuAction;
+}
+
+export type WebdriverActions =
+	| WebdriverCliErrorOutpuAction
+	| WebdriverCliOutpuAction
+	| WebdriverEndAction
+	| WebdriverLogAction
+	| WebdriverRunCompleteAction
+	| WebdriverSessionClosedAction
+	| WebdriverSessionErrorAction
+	| WebdriverSessionStartAction;
+
+interface TypedEventBusListener<
+	K extends keyof WebdriverActionMap = keyof WebdriverActionMap,
+> {
+	(action: WebdriverActionMap[K]): void;
+}
+
+interface EventBusListener extends TypedEventBusListener {
+	(action: WebdriverActions): void;
+}
+
+export interface EventBusInterface {
+	addListener<K extends keyof WebdriverActionMap>(
+		type: K,
+		listener: TypedEventBusListener<K>,
+	): void;
+	dispatchAction(action: WebdriverActions): void;
+}
+
+export class EventBus implements EventBusInterface {
+	#eventMap: Map<string, EventBusListener[]> = new Map();
+
+	addListener<K extends keyof WebdriverActionMap>(
+		type: K,
+		cb: TypedEventBusListener<K>,
+	) {
+		let listeners = this.#eventMap.get(type);
+		if (!listeners) {
+			listeners = [];
+			this.#eventMap.set(type, listeners);
+		}
+		listeners.push(cb as EventBusListener);
+	}
+
+	dispatchAction(action: WebdriverActions) {
+		let listeners = this.#eventMap.get(action.type);
+		if (listeners)
+			for (const listener of listeners) {
+				listener(action);
+			}
+	}
+}

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, isComplete } from "./results.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 completed() {
+		return isComplete(this.#sessionResults);
+	}
+
+	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,45 @@
+#!/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 || !logger.completed
+		? 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();