@w-lfpup/jackrabbit 0.3.0 → 0.3.1

package/webdriver/dist/routes.js

@@ -2,9 +2,7 @@ import * as fs from "fs";
 import * as path from "path";
 import { testHanger } from "./test_hangar.js";
 let cwd = process.cwd();
-// better done with URL? feels weird
-let corePath = path.join(import.meta.url.substring(5), "../../../core/dist/");
-let browserPath = path.join(import.meta.url.substring(5), "../../../browser/dist/");
+const parentPath = path.join(import.meta.url.substring(5), "../../../");
 const MIME_TYPES = {
     octet: "application/octet-stream",
     html: "text/html; charset=UTF-8",
@@ -107,33 +105,27 @@ function logAction(req, res, eventbus) {
 }
 async function serveFile(req, res) {
     let { url, method } = req;
-    if (!url) {
+    if (!url || "GET" !== method) {
         res.setHeader("Content-Type", MIME_TYPES["html"]);
         res.writeHead(400);
         res.end();
         return;
     }
-    let ext = "";
+    let urlFilePath = path.join(url);
+    let extStr = "";
     if (url.endsWith("/"))
-        ext = "index.html";
+        extStr = "index.html";
     let urlNoPrefix = url;
-    if (url.startsWith("/jackrabbit"))
-        urlNoPrefix = url.substring(11);
-    let filePath = path.join(cwd, urlNoPrefix, ext);
-    let stream;
-    if (url.startsWith("/jackrabbit/core/") && "GET" === method) {
-        stream = await getDirectoryScopedFile(filePath, corePath);
+    if (urlFilePath.startsWith("/jackrabbit")) {
+        let strippedUrl = urlFilePath.substring("/jackrabbit".length);
+        urlFilePath = path.join(parentPath, strippedUrl, extStr);
     }
-    if (url.startsWith("/jackrabbit/browser/") && "GET" === method) {
-        stream = await getDirectoryScopedFile(filePath, browserPath);
-    }
-    if (!url.startsWith("/jackrabbit") && "GET" === method) {
-        stream = await getDirectoryScopedFile(filePath, cwd);
+    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(filePath).substring(1).toLowerCase();
+        const ext = path.extname(urlFilePath).substring(1).toLowerCase();
         let mimeType = MIME_TYPES[ext] ?? MIME_TYPES["octet"];
         res.setHeader("Content-Type", mimeType);
         res.writeHead(200);
@@ -161,9 +153,7 @@ function getLoggerActionFromRequestBody(req) {
         });
     });
 }
-async function getDirectoryScopedFile(filePath, basePath) {
-    if (!filePath.startsWith(basePath))
-        return;
+async function getFile(filePath) {
     try {
         await fs.promises.access(filePath);
         return fs.createReadStream(filePath);

package/webdriver/dist/webdriver.js

@@ -134,14 +134,14 @@ function setupProcess(params, eventbus, externalSignal) {
             });
         }
     });
-    process.addListener("error", (error) => {
+    process.addListener("error", function (error) {
         eventbus.dispatchAction({
             id: jrId,
             type: "session_error",
             error: error.toString(),
         });
     });
-    process.addListener("exit", (statusCode) => {
+    process.addListener("exit", function (statusCode) {
         if (statusCode) {
             eventbus.dispatchAction({
                 type: "session_error",
@@ -219,7 +219,6 @@ async function setCookie(params, signal, sessionId) {
             cookie: {
                 name: "jackrabbit",
                 value: jrId,
-                // domain: this.#hostAndPort (issues in firefox)
                 path: "/",
                 httpOnly: true,
             },

package/webdriver/src/logger.ts

@@ -7,7 +7,7 @@ import type {
 } from "./eventbus.js";
 import type { SessionResults, RunResults } from "./results.js";
 
-import { getResultsAsString } from "./results_str.js";
+import { getResultsAsString, isComplete } from "./results.js";
 
 export class Logger {
 	#eventbus: EventBus;
@@ -51,8 +51,8 @@ export class Logger {
 		return this.#sessionResults.errors !== 0;
 	}
 
-	get compeleted() {
-		return false;
+	get completed() {
+		return isComplete(this.#sessionResults);
 	}
 
 	get results(): string {

package/webdriver/src/mod.ts

@@ -25,7 +25,9 @@ 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);
+	logger.errored || logger.failed || !logger.completed
+		? process.exit(1)
+		: process.exit(0);
 });
 eventbus.addListener("end", function () {
 	server.closeAllConnections();

package/webdriver/src/results.ts

@@ -7,7 +7,6 @@ export interface TestResults {
 	loggerEndAction: LoggerAction | undefined;
 }
 
-// remove logger actions
 export interface ModuleResults {
 	loggerAction: LoggerAction;
 	fails: number;
@@ -47,10 +46,266 @@ export interface RunResults {
 	collections: (CollectionResults | undefined)[];
 }
 
-// track if session started or not
-// if browser never launched
 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

@@ -8,13 +8,7 @@ import { testHanger } from "./test_hangar.js";
 import { ConfigInterface } from "./config.js";
 
 let cwd = process.cwd();
-
-// better done with URL? feels weird
-let corePath = path.join(import.meta.url.substring(5), "../../../core/dist/");
-let browserPath = path.join(
-	import.meta.url.substring(5),
-	"../../../browser/dist/",
-);
+const parentPath = path.join(import.meta.url.substring(5), "../../../");
 
 const MIME_TYPES: Record<string, string> = {
 	octet: "application/octet-stream",
@@ -138,35 +132,33 @@ function logAction(
 async function serveFile(req: IncomingMessage, res: ServerResponse) {
 	let { url, method } = req;
 
-	if (!url) {
+	if (!url || "GET" !== method) {
 		res.setHeader("Content-Type", MIME_TYPES["html"]);
 		res.writeHead(400);
 		res.end();
 		return;
 	}
 
-	let ext = "";
-	if (url.endsWith("/")) ext = "index.html";
+	// assume http 1.1
+	let urlFilePath = path.join(url);
+
+	let extStr = "";
+	if (url.endsWith("/")) extStr = "index.html";
 	let urlNoPrefix = url;
-	if (url.startsWith("/jackrabbit")) urlNoPrefix = url.substring(11);
-	let filePath = path.join(cwd, urlNoPrefix, ext);
 
-	let stream: fs.ReadStream | undefined;
-	if (url.startsWith("/jackrabbit/core/") && "GET" === method) {
-		stream = await getDirectoryScopedFile(filePath, corePath);
-	}
-	if (url.startsWith("/jackrabbit/browser/") && "GET" === method) {
-		stream = await getDirectoryScopedFile(filePath, browserPath);
+	if (urlFilePath.startsWith("/jackrabbit")) {
+		let strippedUrl = urlFilePath.substring("/jackrabbit".length);
+		urlFilePath = path.join(parentPath, strippedUrl, extStr);
+	} else {
+		urlFilePath = path.join(cwd, urlNoPrefix, extStr);
 	}
 
-	if (!url.startsWith("/jackrabbit") && "GET" === method) {
-		stream = await getDirectoryScopedFile(filePath, cwd);
-	}
+	let stream = await getFile(urlFilePath);
 
 	if (stream) {
 		// throws errors if not a string
 		// filepath is always a string
-		const ext = path.extname(filePath).substring(1).toLowerCase();
+		const ext = path.extname(urlFilePath).substring(1).toLowerCase();
 		let mimeType = MIME_TYPES[ext] ?? MIME_TYPES["octet"];
 		res.setHeader("Content-Type", mimeType);
 		res.writeHead(200);
@@ -198,12 +190,7 @@ function getLoggerActionFromRequestBody(
 	});
 }
 
-async function getDirectoryScopedFile(
-	filePath: string,
-	basePath: string,
-): Promise<fs.ReadStream | undefined> {
-	if (!filePath.startsWith(basePath)) return;
-
+async function getFile(filePath: string): Promise<fs.ReadStream | undefined> {
 	try {
 		await fs.promises.access(filePath);
 		return fs.createReadStream(filePath);

package/webdriver/src/webdriver.ts

@@ -149,6 +149,7 @@ class WebdriverSession {
 			this.#eventbus,
 			this.#sessionId,
 		);
+
 		this.#process.kill();
 		this.#process = undefined;
 	}
@@ -195,14 +196,14 @@ function setupProcess(
 			}
 		},
 	);
-	process.addListener("error", (error) => {
+	process.addListener("error", function (error) {
 		eventbus.dispatchAction({
 			id: jrId,
 			type: "session_error",
 			error: error.toString(),
 		});
 	});
-	process.addListener("exit", (statusCode) => {
+	process.addListener("exit", function (statusCode) {
 		if (statusCode) {
 			eventbus.dispatchAction({
 				type: "session_error",

package/webdriver/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["./src/config.ts","./src/eventbus.ts","./src/logger.ts","./src/mod.ts","./src/results.ts","./src/results_str.ts","./src/routes.ts","./src/test_hangar.ts","./src/webdriver.ts"],"version":"5.9.3"}
+{"root":["./src/config.ts","./src/eventbus.ts","./src/logger.ts","./src/mod.ts","./src/results.ts","./src/routes.ts","./src/test_hangar.ts","./src/webdriver.ts"],"version":"5.9.3"}