@w-lfpup/jackrabbit 0.3.0 → 0.3.1

package/.github/workflows/browsers.json

@@ -3,8 +3,8 @@
 	"runAsynchronusly": false,
 	"webdrivers": [
 		{
-			"command": "$GECKOWEBDRIVER/geckodriver -p 4001",
 			"title": "Firefox",
+			"command": "$GECKOWEBDRIVER/geckodriver -p 4001",
 			"timeout_ms": 30000,
 			"url": "http://localhost:4001",
 			"capabilities": {
@@ -16,27 +16,37 @@
 			}
 		},
 		{
-			"command": "$CHROMEWEBDRIVER/chromedriver --port=4005",
 			"title": "Chrome",
+			"command": "$CHROMEWEBDRIVER/chromedriver --port=4005",
 			"timeout_ms": 30000,
 			"url": "http://localhost:4005",
 			"capabilities": {
 				"alwaysMatch": {
 					"goog:chromeOptions": {
-						"args": ["--headless"]
+						"args": [
+							"--headless",
+							"--disbale-gpu",
+							"--disable-dev-shm-usage",
+							"--start-maximized"
+						]
 					}
 				}
 			}
 		},
 		{
-			"command": "$EDGEWEBDRIVER/msedgedriver --port=4010",
 			"title": "Edge",
+			"command": "$EDGEWEBDRIVER/msedgedriver --port=4010",
 			"timeout_ms": 30000,
 			"url": "http://localhost:4010",
 			"capabilities": {
 				"alwaysMatch": {
 					"ms:edgeOptions": {
-						"args": ["--headless", "--disable-dev-shm-usage"]
+						"args": [
+							"--headless",
+							"--disbale-gpu",
+							"--disable-dev-shm-usage",
+							"--start-maximized"
+						]
 					}
 				}
 			}

package/.github/workflows/tests.yml

@@ -29,14 +29,3 @@ jobs:
         run: npm run test
       - name: Test browsers
         run: npx jackrabbit_webdriver .github/workflows/browsers.macos.json ./tests/dist/mod.js
-  # build_and_test_windows:
-  #   runs-on: windows-latest
-  #   steps:
-  #     - uses: actions/checkout@v6
-  #     - uses: actions/setup-node@v6
-  #     - name: Install
-  #       run: npm ci
-  #     - name: Test
-  #       run: npm run test
-  #     - name: Test browsers
-  #       run: npx jackrabbit_webdriver .github/workflows/browsers.windows.json ./tests/dist/mod.js

package/browser/dist/mod.js

@@ -5,7 +5,6 @@ try {
     let jackrabbitMap = document.querySelector("script[type=jackrabbit_config]");
     if (null === jackrabbitMap)
         throw new Error("Failed to query jackrabbit_config script");
-    // should be it's own verification and then throw
     let config = JSON.parse(jackrabbitMap.textContent);
     logger.log({
         type: "start_run",

package/nodejs/dist/logger.js

@@ -1,4 +1,4 @@
-import { getResultsAsString } from "./results_str.js";
+import { getResultsAsString } from "./results.js";
 export class Logger {
     #results = {
         startTime: 0,
@@ -21,6 +21,10 @@ export class Logger {
     get errored() {
         return this.#results.errors !== 0;
     }
+    get completed() {
+        return (0 < this.#results.expectedTests &&
+            this.#results.expectedTests === this.#results.completedTests);
+    }
     get results() {
         return getResultsAsString(this.#results);
     }
@@ -150,7 +154,6 @@ function endTest(runResults, loggerAction) {
     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) {
         runResults.fails += 1;

package/nodejs/dist/mod.js

@@ -28,4 +28,6 @@ logger.log({
     time: performance.now(),
 });
 console.log(logger.results);
-logger.failed || logger.errored ? process.exit(1) : process.exit(0);
+logger.failed || logger.errored || !logger.completed
+    ? process.exit(1)
+    : process.exit(0);

package/nodejs/dist/results.js

@@ -39,6 +39,8 @@ ${result.completedCollections} collections`);
             continue;
         output.push(`[run_error] ${errorAction.error}`);
     }
+    if (result.errorLogs.length)
+        output.push("");
     return false;
 }
 function logCollectionResult(output, collection) {
@@ -47,20 +49,22 @@ function logCollectionResult(output, collection) {
     let { loggerAction } = collection;
     if ("start_collection" !== loggerAction.type)
         return true;
-    output.push(`${SPACE}${loggerAction.collection_url}`);
+    output.push(`${loggerAction.collection_url}`);
     if (!collection.fails &&
         !collection.errors &&
         collection.expectedTests === collection.completedTests &&
         collection.expectedModules === collection.completedModules) {
-        output.push(`${collection.expectedTests} tests
-${loggerAction.expected_module_count} modules`);
+        output.push(`${SPACE}${collection.expectedTests} tests
+${SPACE}${loggerAction.expected_module_count} modules`);
         return true;
     }
     for (let errorAction of collection.errorLogs) {
         if ("collection_error" !== errorAction.type)
             continue;
-        output.push(`[collection_error] ${errorAction.error}`);
+        output.push(`${SPACE}[collection_error] ${errorAction.error}`);
     }
+    if (collection.errorLogs.length)
+        output.push("");
     return false;
 }
 function logModuleResult(output, module) {
@@ -79,8 +83,10 @@ function logModuleResult(output, module) {
     for (let errorAction of module.errorLogs) {
         if ("collection_error" !== errorAction.type)
             continue;
-        output.push(`${SPACE}[module_error] ${errorAction.error}`);
+        output.push(`${SPACE.repeat(2)}[module_error] ${errorAction.error}`);
     }
+    if (module.errorLogs.length)
+        output.push("");
     return false;
 }
 function logTest(output, test) {

package/nodejs/dist/results_str.js

@@ -51,20 +51,20 @@ function logCollectionResult(output, collection) {
     let { loggerAction } = collection;
     if ("start_collection" !== loggerAction.type)
         return true;
-    output.push(`${SPACE}${loggerAction.collection_url}`);
+    output.push(`${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(`${collection.expectedTests} tests
-${loggerAction.expected_module_count} modules`);
+        output.push(`${SPACE}${collection.expectedTests} tests
+${SPACE}${loggerAction.expected_module_count} modules`);
         return true;
     }
     for (let errorAction of collection.errorLogs) {
         if ("collection_error" !== errorAction.type)
             continue;
-        output.push(`[collection_error] ${errorAction.error}`);
+        output.push(`${SPACE}[collection_error] ${errorAction.error}`);
     }
     return false;
 }
@@ -85,7 +85,7 @@ function logModuleResult(output, module) {
     for (let errorAction of module.errorLogs) {
         if ("collection_error" !== errorAction.type)
             continue;
-        output.push(`${SPACE}[module_error] ${errorAction.error}`);
+        output.push(`${SPACE.repeat(2)}[module_error] ${errorAction.error}`);
     }
     return false;
 }

package/nodejs/src/logger.ts

@@ -3,9 +3,9 @@ import type {
 	LoggerInterface,
 	EndTest,
 } from "../../core/dist/mod.js";
-import type { RunResults } from "./results_str.js";
+import type { RunResults } from "./results.js";
 
-import { getResultsAsString } from "./results_str.js";
+import { getResultsAsString } from "./results.js";
 
 export class Logger implements LoggerInterface {
 	#results: RunResults = {
@@ -24,14 +24,21 @@ export class Logger implements LoggerInterface {
 		collections: [],
 	};
 
-	get failed() {
+	get failed(): boolean {
 		return this.#results.fails !== 0;
 	}
 
-	get errored() {
+	get errored(): boolean {
 		return this.#results.errors !== 0;
 	}
 
+	get completed(): boolean {
+		return (
+			0 < this.#results.expectedTests &&
+			this.#results.expectedTests === this.#results.completedTests
+		);
+	}
+
 	get results(): string {
 		return getResultsAsString(this.#results);
 	}

package/nodejs/src/mod.ts

@@ -34,4 +34,6 @@ logger.log({
 });
 
 console.log(logger.results);
-logger.failed || logger.errored ? process.exit(1) : process.exit(0);
+logger.failed || logger.errored || !logger.completed
+	? process.exit(1)
+	: process.exit(0);

package/nodejs/src/{results_str.ts → results.ts}

@@ -97,6 +97,8 @@ ${result.completedCollections} collections`);
 		output.push(`[run_error] ${errorAction.error}`);
 	}
 
+	if (result.errorLogs.length) output.push("");
+
 	return false;
 }
 
@@ -109,7 +111,7 @@ function logCollectionResult(
 	let { loggerAction } = collection;
 	if ("start_collection" !== loggerAction.type) return true;
 
-	output.push(`${SPACE}${loggerAction.collection_url}`);
+	output.push(`${loggerAction.collection_url}`);
 
 	// when everything in the collection goes right
 	if (
@@ -119,8 +121,8 @@ function logCollectionResult(
 		collection.expectedModules === collection.completedModules
 	) {
 		output.push(
-			`${collection.expectedTests} tests
-${loggerAction.expected_module_count} modules`,
+			`${SPACE}${collection.expectedTests} tests
+${SPACE}${loggerAction.expected_module_count} modules`,
 		);
 
 		return true;
@@ -128,8 +130,9 @@ ${loggerAction.expected_module_count} modules`,
 
 	for (let errorAction of collection.errorLogs) {
 		if ("collection_error" !== errorAction.type) continue;
-		output.push(`[collection_error] ${errorAction.error}`);
+		output.push(`${SPACE}[collection_error] ${errorAction.error}`);
 	}
+	if (collection.errorLogs.length) output.push("");
 
 	return false;
 }
@@ -157,9 +160,11 @@ function logModuleResult(
 
 	for (let errorAction of module.errorLogs) {
 		if ("collection_error" !== errorAction.type) continue;
-		output.push(`${SPACE}[module_error] ${errorAction.error}`);
+		output.push(`${SPACE.repeat(2)}[module_error] ${errorAction.error}`);
 	}
 
+	if (module.errorLogs.length) output.push("");
+
 	return false;
 }
 

package/nodejs/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["./src/logger.ts","./src/mod.ts","./src/results_str.ts"],"version":"5.9.3"}
+{"root":["./src/logger.ts","./src/mod.ts","./src/results.ts"],"version":"5.9.3"}

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@w-lfpup/jackrabbit",
 	"description": "A test runner without dependencies",
-	"version": "0.3.0",
+	"version": "0.3.1",
 	"license": "BSD-3-Clause",
 	"workspaces": [
 		"core",

package/tests/dist/mod.js

@@ -3,7 +3,6 @@ import * as PassTests from "./test_pass.test.js";
 import * as ErrorTests from "./test_error.test.js";
 import { runCollection } from "../../core/dist/mod.js";
 import { TestLogger } from "./test_logger.js";
-// jackrabbit test run won't pass failing tests
 async function testsFail() {
     let logger = new TestLogger();
     await runCollection(logger, [FailTests], 0, "test_pass.tests.js");
@@ -12,7 +11,6 @@ async function testsFail() {
     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 runCollection(logger, [PassTests], 1, "test_fail.tests.js");

package/tests/dist/test_error.test.js

@@ -14,14 +14,12 @@ 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_fail.test.js

@@ -10,14 +10,12 @@ async function testStuffAndFailAsync() {
 async function testMoreStuffAndFailAsync() {
     return ["this test also failed!"];
 }
-// export tests
 export const tests = [
     testStuffAndFail,
     testMoreStuffAndFail,
     testStuffAndFailAsync,
     testMoreStuffAndFailAsync,
 ];
-// export optional test details
 export const options = {
     title: import.meta.url,
 };

package/tests/dist/test_pass.test.js

@@ -10,14 +10,12 @@ async function testStuffAndPassAsync() {
 async function testMoreStuffAndPassAsync() {
     return [];
 }
-// export tests
 export const tests = [
     testStuffAndPass,
     testMoreStuffAndPass,
     testStuffAndPassAsync,
     testMoreStuffAndPassAsync,
 ];
-// export optional test details
 export const options = {
     title: import.meta.url,
 };

package/tsconfig.json

@@ -4,6 +4,7 @@
 		"module": "nodenext",
 		"target": "esnext",
 		"strict": true,
-		"declaration": true
+		"declaration": true,
+		"removeComments": true
 	}
 }

package/webdriver/dist/config.js

@@ -3,7 +3,6 @@ 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" },
         });

package/webdriver/dist/logger.js

@@ -1,4 +1,4 @@
-import { getResultsAsString } from "./results_str.js";
+import { getResultsAsString, isComplete } from "./results.js";
 export class Logger {
     #eventbus;
     #sessionResults = {
@@ -35,14 +35,12 @@ export class Logger {
     get errored() {
         return this.#sessionResults.errors !== 0;
     }
-    get compeleted() {
-        return false;
+    get completed() {
+        return isComplete(this.#sessionResults);
     }
     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);
@@ -191,7 +189,6 @@ function endTest(sessionResults, runResults, loggerAction) {
     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;

package/webdriver/dist/mod.js

@@ -15,22 +15,21 @@ 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);
+    logger.errored || logger.failed || !logger.completed
+        ? 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();

package/webdriver/dist/results.js

@@ -1 +1,190 @@
-export {};
+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`;
+}