@w-lfpup/jackrabbit 0.1.0 → 0.3.0

package/tests/dist/mod.js

@@ -1,30 +1,50 @@
 import * as FailTests from "./test_fail.test.js";
 import * as PassTests from "./test_pass.test.js";
-import { startRun } from "../../core/dist/mod.js";
+import * as ErrorTests from "./test_error.test.js";
+import { runCollection } from "../../core/dist/mod.js";
 import { TestLogger } from "./test_logger.js";
-// Test pass and fail behavior
-const failTestModules = [FailTests];
-const passTestModules = [PassTests];
 // jackrabbit test run won't pass failing tests
 async function testsFail() {
     let logger = new TestLogger();
-    await startRun(logger, failTestModules);
+    await runCollection(logger, [FailTests], 0, "test_pass.tests.js");
+    if (logger.errored)
+        throw new Error("an error occured");
     if (!logger.failed)
         return "fail tests failed to fail";
 }
 // jackrabbit test run won't fail passing tests
 async function testsPass() {
     let logger = new TestLogger();
-    await startRun(logger, passTestModules);
+    await runCollection(logger, [PassTests], 1, "test_fail.tests.js");
+    if (logger.errored)
+        throw new Error("an error occured");
     if (logger.failed)
         return "passing tests failed to pass";
 }
-const tests = [testsFail, testsPass];
-const options = {
-    title: "Failures and Successes",
+async function testsError() {
+    let logger = new TestLogger();
+    await runCollection(logger, [ErrorTests], 2, "test_error.tests.js");
+    if (!logger.errored)
+        return "tests failed to error";
+    if (logger.failed)
+        return "tests should error not fail";
+}
+const testFailures = {
+    tests: [testsFail],
+    options: {
+        title: "Failures",
+    },
+};
+const testSuccesses = {
+    tests: [testsPass],
+    options: {
+        title: "Sucesses",
+    },
 };
-const testModule = {
-    tests,
-    options,
+const testErrors = {
+    tests: [testsError],
+    options: {
+        title: "Errors",
+    },
 };
-export const testModules = [testModule];
+export const testModules = [testFailures, testSuccesses, testErrors];

package/tests/dist/test_error.test.d.ts

@@ -0,0 +1,9 @@
+declare function testStuffAndError(): undefined;
+declare function testMoreStuffAndError(): string[];
+declare function testStuffAndErrorAsync(): Promise<undefined>;
+declare function testMoreStuffAndErrorAsync(): Promise<string[]>;
+export declare const tests: (typeof testStuffAndError | typeof testMoreStuffAndError | typeof testStuffAndErrorAsync | typeof testMoreStuffAndErrorAsync)[];
+export declare const options: {
+    title: string;
+};
+export {};

package/tests/dist/test_error.test.js

@@ -0,0 +1,27 @@
+function testStuffAndError() {
+    throw Error("yo");
+    return;
+}
+function testMoreStuffAndError() {
+    throw Error("bro");
+    return ["bro"];
+}
+async function testStuffAndErrorAsync() {
+    throw Error("what's");
+    return;
+}
+async function testMoreStuffAndErrorAsync() {
+    throw Error("good");
+    return ["good"];
+}
+// export tests
+export const tests = [
+    testStuffAndError,
+    testMoreStuffAndError,
+    testStuffAndErrorAsync,
+    testMoreStuffAndErrorAsync,
+];
+// export optional test details
+export const options = {
+    title: import.meta.url,
+};

package/tests/dist/test_errors.test.d.ts

@@ -0,0 +1,9 @@
+declare function testStuffAndError(): undefined;
+declare function testMoreStuffAndError(): string[];
+declare function testStuffAndErrorAsync(): Promise<undefined>;
+declare function testMoreStuffAndErrorAsync(): Promise<string[]>;
+export declare const tests: (typeof testStuffAndError | typeof testMoreStuffAndError | typeof testStuffAndErrorAsync | typeof testMoreStuffAndErrorAsync)[];
+export declare const options: {
+    title: string;
+};
+export {};

package/tests/dist/test_errors.test.js

@@ -0,0 +1,27 @@
+function testStuffAndError() {
+    throw Error("yo");
+    return;
+}
+function testMoreStuffAndError() {
+    throw Error("bro");
+    return ["bro"];
+}
+async function testStuffAndErrorAsync() {
+    throw Error("what's");
+    return;
+}
+async function testMoreStuffAndErrorAsync() {
+    throw Error("good");
+    return ["good"];
+}
+// export tests
+export const tests = [
+    testStuffAndError,
+    testMoreStuffAndError,
+    testStuffAndErrorAsync,
+    testMoreStuffAndErrorAsync,
+];
+// export optional test details
+export const options = {
+    title: import.meta.url,
+};

package/tests/dist/test_logger.d.ts

@@ -1,7 +1,8 @@
-import type { LoggerAction, LoggerInterface, TestModule } from "../../core/dist/mod.ts";
+import type { LoggerAction, LoggerInterface } from "../../core/dist/mod.ts";
 declare class TestLogger implements LoggerInterface {
     cancelled: boolean;
+    errored: boolean;
     failed: boolean;
-    log(_testModule: TestModule[], action: LoggerAction): void;
+    log(action: LoggerAction): void;
 }
 export { TestLogger };

package/tests/dist/test_logger.js

@@ -1,10 +1,14 @@
 class TestLogger {
     cancelled = false;
+    errored = false;
     failed = false;
-    log(_testModule, action) {
+    log(action) {
         if (hasTestFailed(action)) {
             this.failed = true;
         }
+        if ("test_error" === action.type) {
+            this.errored = true;
+        }
     }
 }
 function hasTestFailed(action) {

package/tests/src/mod.ts

@@ -1,39 +1,55 @@
 import * as FailTests from "./test_fail.test.js";
 import * as PassTests from "./test_pass.test.js";
+import * as ErrorTests from "./test_error.test.js";
 
-import { startRun } from "../../core/dist/mod.js";
+import { runCollection } from "../../core/dist/mod.js";
 import { TestLogger } from "./test_logger.js";
 
-// Test pass and fail behavior
-
-const failTestModules = [FailTests];
-const passTestModules = [PassTests];
-
 // jackrabbit test run won't pass failing tests
 async function testsFail() {
 	let logger = new TestLogger();
-	await startRun(logger, failTestModules);
+	await runCollection(logger, [FailTests], 0, "test_pass.tests.js");
 
+	if (logger.errored) throw new Error("an error occured");
 	if (!logger.failed) return "fail tests failed to fail";
 }
 
 // jackrabbit test run won't fail passing tests
 async function testsPass() {
 	let logger = new TestLogger();
-	await startRun(logger, passTestModules);
+	await runCollection(logger, [PassTests], 1, "test_fail.tests.js");
 
+	if (logger.errored) throw new Error("an error occured");
 	if (logger.failed) return "passing tests failed to pass";
 }
 
-const tests = [testsFail, testsPass];
+async function testsError() {
+	let logger = new TestLogger();
+	await runCollection(logger, [ErrorTests], 2, "test_error.tests.js");
+
+	if (!logger.errored) return "tests failed to error";
+	if (logger.failed) return "tests should error not fail";
+}
+
+const testFailures = {
+	tests: [testsFail],
+	options: {
+		title: "Failures",
+	},
+};
 
-const options = {
-	title: "Failures and Successes",
+const testSuccesses = {
+	tests: [testsPass],
+	options: {
+		title: "Sucesses",
+	},
 };
 
-const testModule = {
-	tests,
-	options,
+const testErrors = {
+	tests: [testsError],
+	options: {
+		title: "Errors",
+	},
 };
 
-export const testModules = [testModule];
+export const testModules = [testFailures, testSuccesses, testErrors];

package/tests/src/test_error.test.ts

@@ -0,0 +1,32 @@
+function testStuffAndError(): undefined {
+	throw Error("yo");
+	return;
+}
+
+function testMoreStuffAndError() {
+	throw Error("bro");
+	return ["bro"];
+}
+
+async function testStuffAndErrorAsync(): Promise<undefined> {
+	throw Error("what's");
+	return;
+}
+
+async function testMoreStuffAndErrorAsync(): Promise<string[]> {
+	throw Error("good");
+	return ["good"];
+}
+
+// export tests
+export const tests = [
+	testStuffAndError,
+	testMoreStuffAndError,
+	testStuffAndErrorAsync,
+	testMoreStuffAndErrorAsync,
+];
+
+// export optional test details
+export const options = {
+	title: import.meta.url,
+};

package/tests/src/test_logger.ts

@@ -6,12 +6,17 @@ import type {
 
 class TestLogger implements LoggerInterface {
 	cancelled: boolean = false;
+	errored: boolean = false;
 	failed: boolean = false;
 
-	log(_testModule: TestModule[], action: LoggerAction) {
+	log(action: LoggerAction) {
 		if (hasTestFailed(action)) {
 			this.failed = true;
 		}
+
+		if ("test_error" === action.type) {
+			this.errored = true;
+		}
 	}
 }
 

package/tests/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["./src/mod.ts","./src/test_fail.test.ts","./src/test_logger.ts","./src/test_pass.test.ts"],"version":"5.9.3"}
+{"root":["./src/mod.ts","./src/test_error.test.ts","./src/test_fail.test.ts","./src/test_logger.ts","./src/test_pass.test.ts"],"version":"5.9.3"}

package/tsconfig.json

@@ -1,6 +1,6 @@
 {
 	"compilerOptions": {
-		"lib": ["ESNext"],
+		"lib": ["ESNext", "DOM"],
 		"module": "nodenext",
 		"target": "esnext",
 		"strict": true,

package/webdriver/dist/config.js

@@ -0,0 +1,57 @@
+import * as path from "path";
+export async function createConfig(args) {
+    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.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,203 @@
+import { getResultsAsString } from "./results_str.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 compeleted() {
+        return false;
+    }
+    get results() {
+        return getResultsAsString(this.#sessionResults);
+    }
+    // get output
+    // output being a array of a string
+    #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;
+    // might be worth just sticking with language standard "none" like "" or 0 or false
+    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,36 @@
+#!/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);
+// setup server
+let server = http.createServer();
+server.addListener("request", router.route);
+server.addListener("close", function () {
+    console.log(logger.results);
+    logger.errored || logger.failed ? process.exit(1) : process.exit(0);
+});
+eventbus.addListener("end", function () {
+    server.closeAllConnections();
+    server.close();
+});
+// run server
+let { port, hostname } = config.hostAndPort;
+server.listen({
+    port,
+    hostname,
+});
+// start test run
+config.runAsynchronously ? webdrivers.runAll() : webdrivers.run();