@w-lfpup/jackrabbit 0.2.0 → 0.3.0

package/webdriver/src/routes.ts

@@ -0,0 +1,211 @@
+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();
+
+// 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 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) {
+		res.setHeader("Content-Type", MIME_TYPES["html"]);
+		res.writeHead(400);
+		res.end();
+		return;
+	}
+
+	let ext = "";
+	if (url.endsWith("/")) ext = "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 (!url.startsWith("/jackrabbit") && "GET" === method) {
+		stream = await getDirectoryScopedFile(filePath, cwd);
+	}
+
+	if (stream) {
+		// throws errors if not a string
+		// filepath is always a string
+		const ext = path.extname(filePath).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 getDirectoryScopedFile(
+	filePath: string,
+	basePath: string,
+): Promise<fs.ReadStream | undefined> {
+	if (!filePath.startsWith(basePath)) return;
+
+	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>
+`;
+}

package/webdriver/src/webdriver.ts

@@ -0,0 +1,372 @@
+import type { ChildProcess } from "child_process";
+import type { ConfigInterface, WebdriverParams } from "./config.js";
+import type { EventBus } from "./eventbus.js";
+
+import { exec } from "child_process";
+
+let headers = new Headers([["Content-Type", "application/json"]]);
+
+export class WebDrivers {
+	#config: ConfigInterface;
+	#eventbus: EventBus;
+	#webdrivers: WebdriverSession[] = [];
+	#currentIndex = 0;
+
+	constructor(config: ConfigInterface, eventbus: EventBus) {
+		this.#eventbus = eventbus;
+		this.#config = config;
+
+		for (const params of config.webdrivers) {
+			this.#webdrivers.push(
+				new WebdriverSession(params, config.hostAndPort, eventbus),
+			);
+		}
+	}
+
+	run() {
+		this.#eventbus.addListener("session_closed", (action) => {
+			if (action.id !== this.#config.webdrivers[this.#currentIndex]?.jrId)
+				return;
+
+			this.#currentIndex += 1;
+			let webdriver = this.#webdrivers[this.#currentIndex];
+			webdriver
+				? webdriver.run()
+				: this.#eventbus.dispatchAction({
+						type: "end",
+					});
+		});
+
+		let webdriver = this.#webdrivers[this.#currentIndex];
+		webdriver
+			? webdriver.run()
+			: this.#eventbus.dispatchAction({
+					type: "end",
+				});
+	}
+
+	runAll() {
+		this.#eventbus.addListener("session_closed", (action) => {
+			let { id } = action;
+			let [indexStr] = id.split(":");
+			let index = parseInt(indexStr);
+			if (this.#webdrivers[index]) {
+				if (id === this.#config.webdrivers[index]?.jrId)
+					this.#currentIndex += 1;
+			}
+
+			if (this.#currentIndex === this.#webdrivers.length) {
+				this.#eventbus.dispatchAction({
+					type: "end",
+				});
+			}
+		});
+
+		for (let webdriver of this.#webdrivers) {
+			webdriver.run();
+		}
+	}
+}
+
+class WebdriverSession {
+	#params: WebdriverParams;
+	#hostAndPort: URL;
+	#eventbus: EventBus;
+	#process: ChildProcess | undefined;
+	#signal: AbortSignal | undefined;
+	#abortController: AbortController;
+	#sessionId: string | undefined;
+
+	constructor(params: WebdriverParams, hostAndPort: URL, eventbus: EventBus) {
+		this.#params = params;
+		this.#hostAndPort = hostAndPort;
+		this.#eventbus = eventbus;
+		this.#abortController = new AbortController();
+
+		this.#eventbus.addListener("run_complete", (action) => {
+			if (action.id === this.#params.jrId) this.#down();
+		});
+	}
+
+	async run() {
+		if (this.#process) return;
+
+		let { jrId } = this.#params;
+
+		this.#eventbus.dispatchAction({
+			id: jrId,
+			type: "session_start",
+		});
+
+		this.#signal = setupSignal(
+			this.#params,
+			this.#eventbus,
+			this.#abortController.signal,
+		);
+		this.#process = setupProcess(
+			this.#params,
+			this.#eventbus,
+			this.#abortController.signal,
+		);
+
+		try {
+			await untilWebdriverReady(this.#params, this.#signal);
+			this.#sessionId = await getSession(this.#params, this.#signal);
+			await goToPing(
+				this.#params,
+				this.#signal,
+				this.#sessionId,
+				this.#hostAndPort,
+			);
+			await setCookie(this.#params, this.#signal, this.#sessionId);
+			await goToTestPage(
+				this.#params,
+				this.#signal,
+				this.#sessionId,
+				this.#hostAndPort,
+			);
+		} catch (e) {
+			let errOutput;
+			if (e instanceof Error) {
+				errOutput = e.name + "\n" + e.message + (e.cause ? "\n" + e.cause : "");
+			}
+			if (!errOutput) errOutput = e?.toString();
+
+			this.#eventbus.dispatchAction({
+				type: "session_error",
+				id: this.#params.jrId,
+				error: errOutput ?? "Unknown error creating browser session",
+			});
+			this.#abortController.abort();
+		}
+	}
+
+	async #down() {
+		if (!this.#process) return;
+		await deleteSession(
+			this.#params,
+			this.#signal,
+			this.#eventbus,
+			this.#sessionId,
+		);
+		this.#process.kill();
+		this.#process = undefined;
+	}
+}
+
+function setupSignal(
+	params: WebdriverParams,
+	eventbus: EventBus,
+	externalSignal: AbortSignal,
+): AbortSignal {
+	let { jrId, timeoutMs } = params;
+
+	let signal = AbortSignal.any([
+		externalSignal,
+		AbortSignal.timeout(timeoutMs),
+	]);
+	signal.addEventListener("abort", function () {
+		eventbus.dispatchAction({
+			type: "session_closed",
+			id: jrId,
+		});
+	});
+
+	return signal;
+}
+
+function setupProcess(
+	params: WebdriverParams,
+	eventbus: EventBus,
+	externalSignal: AbortSignal,
+): ChildProcess {
+	let { command, jrId } = params;
+
+	let process = exec(
+		command,
+		{ signal: externalSignal },
+		(error, _stdout, stderr) => {
+			if (stderr) {
+				eventbus.dispatchAction({
+					id: jrId,
+					type: "stderr",
+					output: stderr,
+				});
+			}
+		},
+	);
+	process.addListener("error", (error) => {
+		eventbus.dispatchAction({
+			id: jrId,
+			type: "session_error",
+			error: error.toString(),
+		});
+	});
+	process.addListener("exit", (statusCode) => {
+		if (statusCode) {
+			eventbus.dispatchAction({
+				type: "session_error",
+				id: jrId,
+				error: `Process returned status code: ${statusCode}`,
+			});
+		}
+		eventbus.dispatchAction({
+			type: "session_closed",
+			id: jrId,
+		});
+	});
+
+	return process;
+}
+
+async function untilWebdriverReady(
+	params: WebdriverParams,
+	signal: AbortSignal | undefined,
+): Promise<void> {
+	let { url } = params;
+
+	while (signal && !signal.aborted) {
+		try {
+			let res = await fetch(new URL("/status", url), {
+				method: "GET",
+				headers,
+				body: null,
+				signal,
+			});
+
+			if (200 === res.status) {
+				let json = await res.json();
+				let { ready } = json?.value;
+				if (typeof ready === "boolean" && ready) return;
+			}
+		} catch {}
+
+		await sleep(30);
+	}
+
+	throw new Error("Webdriver was never ready.");
+}
+
+async function getSession(params: WebdriverParams, signal: AbortSignal) {
+	let { url, capabilities } = params;
+
+	let res = await fetch(new URL("/session", url), {
+		method: "POST",
+		headers,
+		body: JSON.stringify({ capabilities: capabilities ?? {} }),
+		signal,
+	});
+	if (200 !== res.status) {
+		let cause = await res.text();
+		throw new Error("Failed to create a session", { cause });
+	}
+
+	let json = await res.json();
+	let { sessionId } = json?.value;
+	if (typeof sessionId !== "string") throw new Error("session is not a string");
+
+	return sessionId;
+}
+
+async function goToPing(
+	params: WebdriverParams,
+	signal: AbortSignal,
+	sessionId: string,
+	hostAndPort: URL,
+) {
+	let { url } = params;
+
+	let pingUrl = new URL("/ping", hostAndPort);
+	let getCookie = await fetch(new URL(`/session/${sessionId}/url`, url), {
+		method: "POST",
+		headers,
+		body: JSON.stringify({ url: pingUrl }),
+		signal,
+	});
+
+	if (200 !== getCookie.status) {
+		let cause = await getCookie.json();
+		throw new Error("go-to-cookie request failed", { cause });
+	}
+}
+
+async function setCookie(
+	params: WebdriverParams,
+	signal: AbortSignal,
+	sessionId: string,
+) {
+	let { url, jrId } = params;
+
+	let cookieReq = await fetch(new URL(`/session/${sessionId}/cookie`, url), {
+		method: "POST",
+		headers,
+		body: JSON.stringify({
+			cookie: {
+				name: "jackrabbit",
+				value: jrId,
+				// domain: this.#hostAndPort (issues in firefox)
+				path: "/",
+				httpOnly: true,
+			},
+		}),
+		signal,
+	});
+
+	if (200 !== cookieReq.status) {
+		let cause = await cookieReq.json();
+		throw new Error("set-cookie request failed", { cause });
+	}
+}
+
+async function goToTestPage(
+	params: WebdriverParams,
+	signal: AbortSignal,
+	sessionId: string,
+	hostAndPort: URL,
+) {
+	let { url } = params;
+
+	let goToUrlRes = await fetch(new URL(`/session/${sessionId}/url`, url), {
+		method: "POST",
+		headers,
+		body: JSON.stringify({ url: hostAndPort }),
+		signal,
+	});
+
+	if (200 !== goToUrlRes.status) throw new Error("go-to-url request failed");
+}
+
+async function deleteSession(
+	params: WebdriverParams,
+	signal: AbortSignal | undefined,
+	eventbus: EventBus,
+	sessionId: string | undefined,
+) {
+	let { url } = params;
+	try {
+		let delReqest = await fetch(new URL(`/session/${sessionId}`, url), {
+			method: "DELETE",
+			headers,
+			body: null,
+			signal: signal,
+		});
+		if (200 !== delReqest.status) {
+			let cause = await delReqest.json();
+			throw new Error("delete-cookie request failed", { cause });
+		}
+	} catch (e) {
+		eventbus.dispatchAction({
+			type: "session_error",
+			id: params.jrId,
+			error: e?.toString() ?? "failed to delete browser session error",
+		});
+	}
+}
+
+function sleep(timeMs: number): Promise<void> {
+	return new Promise(function (resolve) {
+		setTimeout(function () {
+			resolve();
+		}, timeMs);
+	});
+}

package/{cli → webdriver}/tsconfig.json

@@ -1,6 +1,7 @@
 {
 	"extends": "../tsconfig.json",
 	"compilerOptions": {
+		"declaration": false,
 		"rootDir": "./src",
 		"outDir": "./dist"
 	}

package/webdriver/tsconfig.tsbuildinfo

@@ -0,0 +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"}

package/cli/dist/cli.d.ts

@@ -1,3 +0,0 @@
-import type { ConfigInterface, ImporterInterface } from "./cli_types.ts";
-import type { LoggerInterface } from "../../core/dist/mod.ts";
-export declare function run(config: ConfigInterface, importer: ImporterInterface, logger?: LoggerInterface): Promise<void>;

package/cli/dist/cli.js

@@ -1,8 +0,0 @@
-import { startRun } from "../../core/dist/mod.js";
-import { Logger } from "./logger.js";
-export async function run(config, importer, logger = new Logger()) {
-    for (const file of config.files) {
-        const testModules = await importer.load(file);
-        await startRun(logger, testModules);
-    }
-}

package/cli/dist/cli_types.d.ts

@@ -1,7 +0,0 @@
-import type { TestModule } from "../../core/dist/mod.ts";
-export interface ConfigInterface {
-    files: string[];
-}
-export interface ImporterInterface {
-    load(url: string): Promise<TestModule[]>;
-}

package/cli/dist/config.d.ts

@@ -1,5 +0,0 @@
-import type { ConfigInterface } from "./cli_types.ts";
-export declare class Config implements ConfigInterface {
-    files: string[];
-    constructor(args: string[]);
-}

package/cli/dist/config.js

@@ -1,6 +0,0 @@
-export class Config {
-    files = [];
-    constructor(args) {
-        this.files = args;
-    }
-}

package/cli/dist/importer.d.ts

@@ -1,7 +0,0 @@
-import type { TestModule } from "../../core/dist/mod.ts";
-import type { ImporterInterface } from "./cli_types.ts";
-export declare class Importer implements ImporterInterface {
-    #private;
-    constructor(cwd: string);
-    load(uri: string): Promise<TestModule[]>;
-}

package/cli/dist/importer.js

@@ -1,16 +0,0 @@
-export class Importer {
-    #cwd;
-    constructor(cwd) {
-        this.#cwd = cwd;
-    }
-    async load(uri) {
-        let uri_updated = uri;
-        let absolute = uri.startsWith("/");
-        if (!absolute) {
-            uri_updated = this.#cwd + "/" + uri;
-        }
-        const { testModules } = await import(uri_updated);
-        // verify here
-        return testModules;
-    }
-}

package/cli/dist/logger.d.ts

@@ -1,7 +0,0 @@
-import type { LoggerAction, LoggerInterface, TestModule } from "../../core/dist/mod.js";
-export declare class Logger implements LoggerInterface {
-    #private;
-    get failed(): boolean;
-    get cancelled(): boolean;
-    log(testModules: TestModule[], action: LoggerAction): void;
-}