@w-lfpup/jackrabbit 0.1.0 → 0.3.0

package/webdriver/dist/webdriver.js

@@ -0,0 +1,273 @@
+import { exec } from "child_process";
+let headers = new Headers([["Content-Type", "application/json"]]);
+export class WebDrivers {
+    #config;
+    #eventbus;
+    #webdrivers = [];
+    #currentIndex = 0;
+    constructor(config, 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;
+    #hostAndPort;
+    #eventbus;
+    #process;
+    #signal;
+    #abortController;
+    #sessionId;
+    constructor(params, hostAndPort, 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, eventbus, externalSignal) {
+    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, eventbus, externalSignal) {
+    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, signal) {
+    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, signal) {
+    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, signal, sessionId, hostAndPort) {
+    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, signal, sessionId) {
+    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, signal, sessionId, hostAndPort) {
+    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, signal, eventbus, sessionId) {
+    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) {
+    return new Promise(function (resolve) {
+        setTimeout(function () {
+            resolve();
+        }, timeMs);
+    });
+}

package/webdriver/package.json

@@ -0,0 +1,8 @@
+{
+	"name": "webdriver",
+	"type": "module",
+	"main": "dist/mod.js",
+	"scripts": {
+		"build": "npx tsc --build"
+	}
+}

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