@w-lfpup/jackrabbit 0.2.0 → 0.3.1

package/webdriver/src/webdriver.ts

@@ -0,0 +1,373 @@
+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", function (error) {
+		eventbus.dispatchAction({
+			id: jrId,
+			type: "session_error",
+			error: error.toString(),
+		});
+	});
+	process.addListener("exit", function (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/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/cli_types.js

@@ -1 +0,0 @@
-export {};

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;
-}

package/cli/dist/logger.js

@@ -1,88 +0,0 @@
-export class Logger {
-    #assertions = new Map();
-    #data = {
-        cancelled: false,
-        failed: false,
-        startTime: -1,
-        testTime: 0,
-    };
-    get failed() {
-        return this.#data.failed;
-    }
-    get cancelled() {
-        return this.#data.cancelled;
-    }
-    log(testModules, action) {
-        if ("start_run" === action.type) {
-            this.#data.startTime = action.time;
-        }
-        if ("cancel_run" === action.type) {
-            this.#data.cancelled = true;
-            logAssertions(testModules, this.#assertions);
-            logResults(this.#data, action.time);
-        }
-        //  add to fails
-        if ("end_test" === action.type && action?.assertions) {
-            if (Array.isArray(action.assertions) && action.assertions.length === 0)
-                return;
-            this.#data.testTime += action.endTime - action.startTime;
-            this.#data.failed = true;
-            let assertions = this.#assertions.get(action.moduleId);
-            if (assertions) {
-                assertions.set(action.testId, action);
-            }
-            else {
-                this.#assertions.set(action.moduleId, new Map([[action.testId, action]]));
-            }
-        }
-        if ("end_run" === action.type) {
-            logAssertions(testModules, this.#assertions);
-            logResults(this.#data, action.time);
-        }
-    }
-}
-function logAssertions(testModules, fails) {
-    for (let [moduleID, module] of testModules.entries()) {
-        let failedTests = fails.get(moduleID);
-        if (undefined === failedTests)
-            continue;
-        const { tests, options } = module;
-        console.log(`${options?.title ?? `module index: ${moduleID}`}`);
-        let numFailedTests = fails.get(moduleID)?.size ?? 0;
-        console.log(`${numFailedTests}/${tests.length} tests failed`);
-        for (let [index, test] of tests.entries()) {
-            let action = failedTests.get(index);
-            if (!action || action.type !== "end_test")
-                continue;
-            console.log(`\t${test.name}\n\t\t${action.assertions}`);
-        }
-        console.log("\n");
-    }
-}
-function logResults(data, time) {
-    let status_with_color = data.failed
-        ? yellow("\u{2717} failed")
-        : blue("\u{2714} passed");
-    if (data.cancelled) {
-        status_with_color = gray("\u{2717} cancelled");
-    }
-    const overhead = time - data.startTime;
-    console.log(`Results:
-${status_with_color}
-  duration: ${data.testTime.toFixed(4)} mS
-  overhead: ${overhead.toFixed(4)} mS`);
-}
-// 39 - default foreground color
-// 49 - default background color
-function blue(text) {
-    return `\x1b[44m\x1b[97m${text}\x1b[0m`;
-}
-function yellow(text) {
-    return `\x1b[43m\x1b[97m${text}\x1b[0m`;
-}
-function gray(text) {
-    return `\x1b[100m\x1b[97m${text}\x1b[0m`;
-}
-function logTestModule(moduleID, title) {
-    console.log(`module: ${title ?? `module index: ${moduleID}`}`);
-}

package/cli/dist/mod.d.ts

@@ -1,6 +0,0 @@
-export type { ConfigInterface } from "./cli_types.ts";
-export type { ImporterInterface } from "./cli_types.ts";
-export { Config } from "./config.js";
-export { Importer } from "./importer.js";
-export { Logger } from "./logger.js";
-export { run } from "./cli.js";

package/cli/dist/mod.js

@@ -1,4 +0,0 @@
-export { Config } from "./config.js";
-export { Importer } from "./importer.js";
-export { Logger } from "./logger.js";
-export { run } from "./cli.js";

package/cli/src/cli.ts

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

package/cli/src/cli_types.ts

@@ -1,9 +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/src/config.ts

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

package/cli/src/importer.ts

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