@w-lfpup/jackrabbit 0.2.0 → 0.3.1

package/webdriver/src/results.ts

@@ -0,0 +1,311 @@
+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;
+}
+
+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)[];
+}
+
+export interface SessionResults {
+	fails: number;
+	errors: number;
+	runs: Map<string, RunResults>;
+}
+
+const SPACE = "  ";
+
+/*
+	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.
+*/
+
+export function getResultsAsString(sessionResults: SessionResults): string {
+	const output: string[] = [];
+
+	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) {
+	if (!sessionResults.runs.size) output.push("\nNo webdrivers were run.");
+
+	for (let [, result] of sessionResults.runs) {
+		if (result.errorLogs.length)
+			output.push(`\n${result.webdriverParams.title}`);
+		for (let errorAction of result.errorLogs) {
+			if ("session_error" === errorAction.type) {
+				output.push(`${SPACE}[session_error] ${errorAction.error}`);
+			}
+		}
+	}
+}
+
+function logRunResults(output: string[], result: RunResults): boolean {
+	output.push(`\n${result.webdriverParams.title}`);
+
+	for (let errorAction of result.errorLogs) {
+		if ("log" !== errorAction.type) continue;
+		if ("run_error" !== errorAction.loggerAction.type) continue;
+
+		output.push(
+			`${SPACE.repeat(2)}[run_error] ${errorAction.loggerAction.error}`,
+		);
+	}
+	if (result.errorLogs.length) output.push("");
+
+	if (!result.collections && !result.expectedTests) {
+		output.push(`${SPACE}No tests were run.`);
+		return true;
+	}
+
+	// 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}`);
+	}
+
+	if (collection.errorLogs.length) output.push("");
+
+	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;
+	}
+
+	output.push(
+		`${SPACE.repeat(3)}${module.completedTests - module.fails}/${module.expectedTests} tests`,
+	);
+
+	output.push("");
+	for (let errorAction of module.errorLogs) {
+		if ("module_error" !== errorAction.type) continue;
+		output.push(`${SPACE.repeat(3)}[module_error] ${errorAction.error}`);
+	}
+
+	if (module.errorLogs.length) output.push("");
+
+	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}`);
+			}
+		}
+	}
+
+	if (undefined === loggerEndAction) {
+		let { test_name } = loggerStartAction;
+
+		output.push(`${SPACE.repeat(3)}${test_name}
+${SPACE.repeat(4)}[incomplete]`);
+	}
+}
+
+function logSummary(output: string[], sessionResults: SessionResults) {
+	let status_with_color = blue("\u{2714} passed");
+
+	if (!isComplete(sessionResults))
+		status_with_color = gray("\u{2717} incomplete");
+	if (sessionResults.fails) status_with_color = yellow("\u{2717} failed");
+	if (sessionResults.errors) status_with_color = gray("\u{2717} errored");
+
+	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
+`);
+}
+
+export function isComplete(sessionResults: SessionResults): boolean {
+	for (const [, result] of sessionResults.runs) {
+		if (
+			!result.expectedTests ||
+			!result.expectedModules ||
+			!result.expectedCollections
+		)
+			return false;
+		if (
+			result.expectedTests !== result.completedTests ||
+			result.expectedModules !== result.completedModules ||
+			result.expectedCollections !== result.completedCollections
+		)
+			return false;
+	}
+
+	return true;
+}
+
+// 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`;
+}

package/webdriver/src/routes.ts

@@ -0,0 +1,198 @@
+import type { IncomingMessage, ServerResponse } from "http";
+import type { EventBus } from "./eventbus.js";
+import type { LoggerAction } from "../../core/dist/jackrabbit_types.js";
+
+import * as fs from "fs";
+import * as path from "path";
+import { testHanger } from "./test_hangar.js";
+import { ConfigInterface } from "./config.js";
+
+let cwd = process.cwd();
+const parentPath = path.join(import.meta.url.substring(5), "../../../");
+
+const MIME_TYPES: Record<string, string> = {
+	octet: "application/octet-stream",
+	html: "text/html; charset=UTF-8",
+	js: "text/javascript",
+	json: "application/json",
+	css: "text/css",
+	png: "image/png",
+	jpg: "image/jpeg",
+	ico: "image/x-icon",
+	svg: "image/svg+xml",
+};
+
+export class Router {
+	#config: ConfigInterface;
+	#eventbus: EventBus;
+
+	constructor(config: ConfigInterface, eventbus: EventBus) {
+		this.#config = config;
+		this.#eventbus = eventbus;
+	}
+
+	get route() {
+		return this.#boundRoute;
+	}
+
+	#boundRoute = this.#route.bind(this);
+	async #route(req: IncomingMessage, res: ServerResponse) {
+		if (serveBadRequest(req, res)) return;
+		if (servePing(req, res)) return;
+		if (serveTestPage(req, res, this.#config)) return;
+		if (logAction(req, res, this.#eventbus)) return;
+
+		await serveFile(req, res);
+	}
+}
+
+function serveBadRequest(req: IncomingMessage, res: ServerResponse): boolean {
+	let { url } = req;
+	if (url) return false;
+
+	res.setHeader("Content-Type", "text/html");
+	res.writeHead(400);
+	res.end();
+
+	return true;
+}
+
+function servePing(req: IncomingMessage, res: ServerResponse): boolean {
+	let { url, method } = req;
+	if (url !== "/ping" || "GET" !== method) return false;
+
+	res.setHeader("Content-Type", "text/html");
+	res.writeHead(200);
+	res.end("The cookie train has arrived!");
+
+	return true;
+}
+
+function serveTestPage(
+	req: IncomingMessage,
+	res: ServerResponse,
+	config: ConfigInterface,
+): boolean {
+	let { url, method } = req;
+	if (url !== "/" || "GET" !== method) return false;
+
+	let hangar = testHanger({
+		jackrabbit_url: config.hostAndPort,
+		test_collections: process.argv.slice(3),
+	});
+
+	res.setHeader("Content-Type", "text/html");
+	res.writeHead(200);
+	res.end(hangar);
+
+	return true;
+}
+
+function logAction(
+	req: IncomingMessage,
+	res: ServerResponse,
+	eventbus: EventBus,
+): boolean {
+	let { url, method } = req;
+	if (!url?.startsWith("/log/") || "POST" !== method) return false;
+
+	let id: string | undefined;
+	let cookies = req.headers.cookie?.split(";") ?? [];
+	for (const cookieLine of cookies) {
+		if (cookieLine.startsWith("jackrabbit=")) {
+			let [_name, value] = cookieLine.split("=");
+			id = value;
+		}
+	}
+
+	if (id) {
+		getLoggerActionFromRequestBody(req)
+			.then(function (loggerAction: LoggerAction) {
+				eventbus.dispatchAction({
+					type: "log",
+					loggerAction,
+					id,
+				});
+				res.writeHead(201);
+			})
+			.catch(function () {
+				res.writeHead(401);
+			})
+			.finally(function () {
+				res.end();
+			});
+	} else {
+		res.writeHead(401);
+		res.end();
+	}
+
+	return true;
+}
+
+async function serveFile(req: IncomingMessage, res: ServerResponse) {
+	let { url, method } = req;
+
+	if (!url || "GET" !== method) {
+		res.setHeader("Content-Type", MIME_TYPES["html"]);
+		res.writeHead(400);
+		res.end();
+		return;
+	}
+
+	// assume http 1.1
+	let urlFilePath = path.join(url);
+
+	let extStr = "";
+	if (url.endsWith("/")) extStr = "index.html";
+	let urlNoPrefix = url;
+
+	if (urlFilePath.startsWith("/jackrabbit")) {
+		let strippedUrl = urlFilePath.substring("/jackrabbit".length);
+		urlFilePath = path.join(parentPath, strippedUrl, extStr);
+	} else {
+		urlFilePath = path.join(cwd, urlNoPrefix, extStr);
+	}
+
+	let stream = await getFile(urlFilePath);
+
+	if (stream) {
+		// throws errors if not a string
+		// filepath is always a string
+		const ext = path.extname(urlFilePath).substring(1).toLowerCase();
+		let mimeType = MIME_TYPES[ext] ?? MIME_TYPES["octet"];
+		res.setHeader("Content-Type", mimeType);
+		res.writeHead(200);
+		stream.pipe(res);
+	} else {
+		res.setHeader("Content-Type", MIME_TYPES["html"]);
+		res.writeHead(404);
+		res.end();
+	}
+}
+
+function getLoggerActionFromRequestBody(
+	req: IncomingMessage,
+): Promise<LoggerAction> {
+	return new Promise(function (resolve, reject) {
+		let data: Uint8Array[] = [];
+		req.addListener("data", function (chunk) {
+			data.push(chunk);
+		});
+		req.addListener("end", function () {
+			let actionStr = Buffer.concat(data).toString();
+			let action = JSON.parse(actionStr) as LoggerAction;
+
+			resolve(action);
+		});
+		req.addListener("error", function (err: Error) {
+			reject(err);
+		});
+	});
+}
+
+async function getFile(filePath: string): Promise<fs.ReadStream | undefined> {
+	try {
+		await fs.promises.access(filePath);
+		return fs.createReadStream(filePath);
+	} catch {}
+}

package/webdriver/src/test_hangar.ts

@@ -0,0 +1,25 @@
+interface TestHangerParams {
+	jackrabbit_url: URL;
+	test_collections: string[];
+}
+
+export function testHanger(params: TestHangerParams) {
+	return `<!DOCTYPE html>
+<html>
+	<head>
+		<script type="jackrabbit_config">
+			${JSON.stringify(params)}
+		</script>
+		<script type="importmap">
+			{
+				"imports": {
+					"jackrabbit/core/": "/jackrabbit/core/"
+				}
+			}
+		</script>
+		<script type="module" src="/jackrabbit/browser/dist/mod.js"></script>
+	</head>
+	<body></body>
+</html>
+`;
+}