@w-lfpup/jackrabbit 0.2.0 → 0.3.1

package/webdriver/dist/config.js

@@ -0,0 +1,56 @@
+import * as path from "path";
+export async function createConfig(args) {
+    let configFilepath = args[0];
+    let relPath = path.resolve(process.cwd(), configFilepath);
+    try {
+        let { default: json } = await import(`file://${relPath}`, {
+            with: { type: "json" },
+        });
+        let hostAndPort = 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 = [];
+        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) {
+    let { command, url, title, timeout_ms, capabilities } = json;
+    if (typeof command !== "string")
+        return new Error("WebdriverParams: command is not a string");
+    let parsedUrl = 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/dist/eventbus.js

@@ -0,0 +1,18 @@
+export class EventBus {
+    #eventMap = new Map();
+    addListener(type, cb) {
+        let listeners = this.#eventMap.get(type);
+        if (!listeners) {
+            listeners = [];
+            this.#eventMap.set(type, listeners);
+        }
+        listeners.push(cb);
+    }
+    dispatchAction(action) {
+        let listeners = this.#eventMap.get(action.type);
+        if (listeners)
+            for (const listener of listeners) {
+                listener(action);
+            }
+    }
+}

package/webdriver/dist/listeners.js

@@ -0,0 +1,21 @@
+export class Listeners {
+    #eventMap = new Map();
+    addEventListener(eventName, cb) {
+        let eventListeners = this.#eventMap.get(eventName);
+        if (!eventListeners) {
+            eventListeners = [];
+            this.#eventMap.set(eventName, eventListeners);
+        }
+        eventListeners.push(cb);
+    }
+    dispatchEvent(event) {
+        let eventListeners = this.#eventMap.get(event.type);
+        if (eventListeners)
+            for (const listener of eventListeners) {
+                listener instanceof Function
+                    ? listener(event)
+                    : listener.handleEvent(event);
+            }
+        return event.cancelable || event.defaultPrevented;
+    }
+}

package/webdriver/dist/logger.js

@@ -0,0 +1,200 @@
+import { getResultsAsString, isComplete } from "./results.js";
+export class Logger {
+    #eventbus;
+    #sessionResults = {
+        fails: 0,
+        errors: 0,
+        runs: new Map(),
+    };
+    constructor(config, eventbus) {
+        this.#eventbus = eventbus;
+        this.#eventbus.addListener("log", this.#boundLog);
+        this.#eventbus.addListener("session_error", this.#boundError);
+        for (let webdriverParams of config.webdrivers) {
+            this.#sessionResults.runs.set(webdriverParams.jrId, {
+                startTime: 0,
+                fails: 0,
+                errors: 0,
+                expectedTests: 0,
+                expectedModules: 0,
+                endTime: 0,
+                testTime: 0,
+                errorLogs: [],
+                completedTests: 0,
+                completedModules: 0,
+                expectedCollections: 0,
+                completedCollections: 0,
+                webdriverParams,
+                collections: [],
+            });
+        }
+    }
+    get failed() {
+        return this.#sessionResults.fails !== 0;
+    }
+    get errored() {
+        return this.#sessionResults.errors !== 0;
+    }
+    get completed() {
+        return isComplete(this.#sessionResults);
+    }
+    get results() {
+        return getResultsAsString(this.#sessionResults);
+    }
+    #boundError = this.#onError.bind(this);
+    #onError(action) {
+        let runResults = this.#sessionResults.runs.get(action.id);
+        if (runResults) {
+            this.#sessionResults.errors += 1;
+            runResults.errors += 1;
+            runResults.errorLogs.push(action);
+        }
+    }
+    #boundLog = this.#onLog.bind(this);
+    #onLog(action) {
+        let { loggerAction, id } = action;
+        let runResults = this.#sessionResults.runs.get(id);
+        if (!runResults)
+            return;
+        if ("start_run" === loggerAction.type) {
+            runResults.startTime = loggerAction.time;
+            runResults.expectedCollections = loggerAction.expected_collection_count;
+        }
+        if ("end_run" === loggerAction.type) {
+            runResults.endTime = loggerAction.time;
+            this.#eventbus.dispatchAction({
+                type: "run_complete",
+                id,
+            });
+        }
+        if ("run_error" === loggerAction.type) {
+            this.#sessionResults.errors += 1;
+            runResults.errors += 1;
+            runResults.errorLogs.push(action);
+        }
+        if ("start_collection" === loggerAction.type) {
+            runResults.collections[loggerAction.collection_id] = {
+                completedModules: 0,
+                completedTests: 0,
+                errorLogs: [],
+                errors: 0,
+                expectedModules: loggerAction.expected_module_count,
+                expectedTests: 0,
+                fails: 0,
+                loggerAction,
+                modules: [],
+            };
+            runResults.expectedModules += loggerAction.expected_module_count;
+        }
+        if ("end_collection" === loggerAction.type) {
+            let collection = runResults.collections[loggerAction.collection_id];
+            if (!collection)
+                return;
+            runResults.completedCollections += 1;
+        }
+        if ("collection_error" === loggerAction.type) {
+            let collection = runResults.collections[loggerAction.collection_id];
+            if (!collection)
+                return;
+            this.#sessionResults.errors += 1;
+            runResults.errors += 1;
+            collection.errors += 1;
+            collection.errorLogs.push(loggerAction);
+        }
+        if ("start_module" === loggerAction.type) {
+            let collection = runResults.collections[loggerAction.collection_id];
+            if (!collection)
+                return;
+            collection.modules[loggerAction.module_id] = {
+                completedTests: 0,
+                errorLogs: [],
+                errors: 0,
+                expectedTests: loggerAction.expected_test_count,
+                fails: 0,
+                loggerAction,
+                testResults: [],
+            };
+            collection.expectedTests += loggerAction.expected_test_count;
+            runResults.expectedTests += loggerAction.expected_test_count;
+        }
+        if ("end_module" === loggerAction.type) {
+            let collection = runResults.collections[loggerAction.collection_id];
+            if (!collection)
+                return;
+            let module = collection.modules[loggerAction.module_id];
+            if (!module)
+                return;
+            runResults.completedModules += 1;
+            collection.completedModules += 1;
+        }
+        if ("module_error" === loggerAction.type) {
+            let collection = runResults.collections[loggerAction.collection_id];
+            if (!collection)
+                return;
+            let module = collection.modules[loggerAction.module_id];
+            if (!module)
+                return;
+            this.#sessionResults.errors += 1;
+            runResults.errors += 1;
+            collection.errors += 1;
+            module.errors += 1;
+            module.errorLogs.push(loggerAction);
+        }
+        if ("start_test" === loggerAction.type) {
+            let collection = runResults.collections[loggerAction.collection_id];
+            if (!collection)
+                return;
+            let module = collection.modules[loggerAction.module_id];
+            if (!module)
+                return;
+            module.testResults[loggerAction.test_id] = {
+                loggerStartAction: loggerAction,
+                loggerEndAction: undefined,
+            };
+        }
+        if ("end_test" === loggerAction.type) {
+            endTest(this.#sessionResults, runResults, loggerAction);
+        }
+        if ("test_error" === loggerAction.type) {
+            let collection = runResults.collections[loggerAction.collection_id];
+            if (!collection)
+                return;
+            let module = collection.modules[loggerAction.module_id];
+            if (!module)
+                return;
+            let testResult = module.testResults[loggerAction.test_id];
+            if (!testResult)
+                return;
+            testResult.loggerEndAction = loggerAction;
+            this.#sessionResults.errors += 1;
+            runResults.errors += 1;
+            collection.errors += 1;
+            module.errors += 1;
+        }
+    }
+}
+function endTest(sessionResults, runResults, loggerAction) {
+    let collection = runResults.collections[loggerAction.collection_id];
+    if (!collection)
+        return;
+    let module = collection.modules[loggerAction.module_id];
+    if (!module)
+        return;
+    let testResult = module.testResults[loggerAction.test_id];
+    if (!testResult)
+        return;
+    testResult.loggerEndAction = loggerAction;
+    runResults.completedTests += 1;
+    collection.completedTests += 1;
+    module.completedTests += 1;
+    let { assertions } = loggerAction;
+    const isAssertionArray = Array.isArray(assertions) && assertions.length;
+    const isAssertion = !Array.isArray(assertions) && undefined !== assertions;
+    if (isAssertion || isAssertionArray) {
+        sessionResults.fails += 1;
+        runResults.fails += 1;
+        collection.fails += 1;
+        module.fails += 1;
+    }
+    runResults.testTime += Math.max(0, loggerAction.end_time - loggerAction.start_time);
+}

package/webdriver/dist/mod.js

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+import * as http from "http";
+import { createConfig } from "./config.js";
+import { Logger } from "./logger.js";
+import { Router } from "./routes.js";
+import { WebDrivers } from "./webdriver.js";
+import { EventBus } from "./eventbus.js";
+let args = process.argv.slice(2);
+const config = await createConfig(args);
+if (config instanceof Error) {
+    console.log(config);
+    process.exit(1);
+}
+let eventbus = new EventBus();
+let logger = new Logger(config, eventbus);
+let router = new Router(config, eventbus);
+let webdrivers = new WebDrivers(config, eventbus);
+let server = http.createServer();
+server.addListener("request", router.route);
+server.addListener("close", function () {
+    console.log(logger.results);
+    logger.errored || logger.failed || !logger.completed
+        ? process.exit(1)
+        : process.exit(0);
+});
+eventbus.addListener("end", function () {
+    server.closeAllConnections();
+    server.close();
+});
+let { port, hostname } = config.hostAndPort;
+server.listen({
+    port,
+    hostname,
+});
+config.runAsynchronously ? webdrivers.runAll() : webdrivers.run();

package/webdriver/dist/results.js

@@ -0,0 +1,190 @@
+const SPACE = "  ";
+export function getResultsAsString(sessionResults) {
+    const output = [];
+    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, 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, result) {
+    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;
+    }
+    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, collection) {
+    if (!collection)
+        return true;
+    let { loggerAction } = collection;
+    if ("start_collection" !== loggerAction.type)
+        return true;
+    output.push(`${SPACE}${loggerAction.collection_url}`);
+    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, module) {
+    if (!module)
+        return true;
+    let { loggerAction } = module;
+    if ("start_module" !== loggerAction.type)
+        return true;
+    output.push(`${SPACE.repeat(2)}${loggerAction.module_name}`);
+    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, test) {
+    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, 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) {
+    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;
+}
+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`;
+}

package/webdriver/dist/results_str.js

@@ -0,0 +1,167 @@
+const SPACE = "  ";
+export function getResultsAsString(sessionResults) {
+    const output = [];
+    // 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.
+    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, sessionResults) {
+    for (let [, result] of sessionResults.runs) {
+        for (let errorAction of result.errorLogs) {
+            if ("session_error" === errorAction.type) {
+                output.push(`\n[${result.webdriverParams.title}:session_error] ${errorAction.error}`);
+            }
+        }
+    }
+}
+function logRunResults(output, result) {
+    output.push(`
+${result.webdriverParams.title}`);
+    for (let errorAction of result.errorLogs) {
+        if ("log" === errorAction.type) {
+            if ("run_error" === errorAction.loggerAction.type) {
+                output.push(`${SPACE}[run_error] ${errorAction.loggerAction.error}`);
+            }
+        }
+    }
+    if (!result.expectedTests) {
+        output.push(`  No test runs occured.`);
+    }
+    // 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, collection) {
+    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}`);
+    }
+    return false;
+}
+function logModuleResult(output, module) {
+    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;
+    }
+    for (let errorAction of module.errorLogs) {
+        if ("collection_error" !== errorAction.type)
+            continue;
+        output.push(`${SPACE.repeat(2)}[module_error] ${errorAction.error}`);
+    }
+    return false;
+}
+function logTest(output, test) {
+    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}`);
+            }
+        }
+    }
+}
+function logSummary(output, sessionResults) {
+    let status_with_color = blue("\u{2714} passed");
+    if (sessionResults.fails)
+        status_with_color = yellow("\u{2717} failed");
+    if (sessionResults.errors)
+        status_with_color = gray("\u{2717} errored");
+    // expected tests
+    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
+`);
+}
+// 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`;
+}