@w-lfpup/jackrabbit 0.1.0 → 0.3.0

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

package/webdriver/dist/routes.js

@@ -0,0 +1,172 @@
+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 MIME_TYPES = {
+    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;
+    #eventbus;
+    constructor(config, eventbus) {
+        this.#config = config;
+        this.#eventbus = eventbus;
+    }
+    get route() {
+        return this.#boundRoute;
+    }
+    #boundRoute = this.#route.bind(this);
+    async #route(req, res) {
+        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, res) {
+    let { url } = req;
+    if (url)
+        return false;
+    res.setHeader("Content-Type", "text/html");
+    res.writeHead(400);
+    res.end();
+    return true;
+}
+function servePing(req, res) {
+    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, res, config) {
+    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, res, eventbus) {
+    let { url, method } = req;
+    if (!url?.startsWith("/log/") || "POST" !== method)
+        return false;
+    let id;
+    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) {
+            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, res) {
+    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;
+    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) {
+    return new Promise(function (resolve, reject) {
+        let data = [];
+        req.addListener("data", function (chunk) {
+            data.push(chunk);
+        });
+        req.addListener("end", function () {
+            let actionStr = Buffer.concat(data).toString();
+            let action = JSON.parse(actionStr);
+            resolve(action);
+        });
+        req.addListener("error", function (err) {
+            reject(err);
+        });
+    });
+}
+async function getDirectoryScopedFile(filePath, basePath) {
+    if (!filePath.startsWith(basePath))
+        return;
+    try {
+        await fs.promises.access(filePath);
+        return fs.createReadStream(filePath);
+    }
+    catch { }
+}

package/webdriver/dist/routes2.js

@@ -0,0 +1,163 @@
+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 MIME_TYPES = {
+    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;
+    #eventbus;
+    constructor(config, eventbus) {
+        this.#config = config;
+        this.#eventbus = eventbus;
+    }
+    get route() {
+        return this.#boundRoute;
+    }
+    #boundRoute = this.#route.bind(this);
+    async #route(req, res) {
+        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 getLoggerActionFromRequestBody(req) {
+    return new Promise(function (resolve, reject) {
+        let data = [];
+        req.addListener("data", function (chunk) {
+            data.push(chunk);
+        });
+        req.addListener("end", function () {
+            let actionStr = Buffer.concat(data).toString();
+            let action = JSON.parse(actionStr);
+            resolve(action);
+        });
+        req.addListener("error", function (err) {
+            reject(err);
+        });
+    });
+}
+async function getDirectoryScopedFile(filePath, basePath) {
+    if (!filePath.startsWith(basePath))
+        return;
+    try {
+        await fs.promises.access(filePath);
+        return fs.createReadStream(filePath);
+    }
+    catch { }
+}
+function serveBadRequest(req, res) {
+    let { url } = req;
+    if (url)
+        return false;
+    res.setHeader("Content-Type", "text/html");
+    res.writeHead(400);
+    res.end();
+    return true;
+}
+function servePing(req, res) {
+    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, res, config) {
+    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, res, eventbus) {
+    let { url, method } = req;
+    if (url?.startsWith("/log/") && "POST" === method)
+        return false;
+    let id;
+    let cookies = req.headers.cookie?.split(";") ?? [];
+    for (const cookieLine of cookies) {
+        if (cookieLine.startsWith("jackrabbit=")) {
+            let [_name, value] = cookieLine.split("=");
+            id = value;
+        }
+    }
+    if (!id)
+        return false;
+    getLoggerActionFromRequestBody(req)
+        .then(function (loggerAction) {
+        eventbus.dispatchAction({
+            type: "log",
+            loggerAction,
+            id,
+        });
+        res.writeHead(200);
+    })
+        .catch(function () {
+        res.writeHead(403);
+    })
+        .finally(function () {
+        res.end();
+    });
+    return true;
+}
+async function serveFile(req, res) {
+    let { url, method } = req;
+    if (!url)
+        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;
+    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) {
+        // throwing errors and stuff
+        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();
+    }
+}

package/webdriver/dist/test_hangar.js

@@ -0,0 +1,20 @@
+export function testHanger(params) {
+    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>
+`;
+}