@w-lfpup/jackrabbit 0.2.0 → 0.3.0

package/nodejs/src/mod.ts

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+
+import { Logger } from "./logger.js";
+import * as path from "path";
+import { runCollection } from "../../core/dist/mod.js";
+
+let filepaths = process.argv.slice(2);
+
+const logger = new Logger();
+
+logger.log({
+	type: "start_run",
+	time: performance.now(),
+	expected_collection_count: filepaths.length,
+});
+
+for (const [collection_id, file] of filepaths.entries()) {
+	try {
+		let filepath = path.join(process.cwd(), file);
+		const { testModules } = await import(filepath);
+		await runCollection(logger, testModules, collection_id, filepath);
+	} catch (e: unknown) {
+		logger.log({
+			type: "collection_error",
+			collection_id,
+			error: e?.toString() ?? "wild horses error",
+		});
+	}
+}
+
+logger.log({
+	type: "end_run",
+	time: performance.now(),
+});
+
+console.log(logger.results);
+logger.failed || logger.errored ? process.exit(1) : process.exit(0);

package/nodejs/src/results_str.ts

@@ -0,0 +1,234 @@
+import type { LoggerAction } from "../../core/dist/mod.js";
+
+export interface TestResults {
+	loggerStartAction: LoggerAction;
+	loggerEndAction: LoggerAction | undefined;
+}
+
+export interface ModuleResults {
+	loggerAction: LoggerAction;
+	fails: number;
+	errors: number;
+	expectedTests: number;
+	completedTests: number;
+	errorLogs: LoggerAction[];
+	testResults: (TestResults | undefined)[];
+}
+
+export interface CollectionResults {
+	loggerAction: LoggerAction;
+	fails: number;
+	errors: number;
+	expectedTests: number;
+	completedTests: number;
+	expectedModules: number;
+	completedModules: number;
+	errorLogs: LoggerAction[];
+	modules: (ModuleResults | undefined)[];
+}
+
+export interface RunResults {
+	fails: number;
+	errors: number;
+	startTime: number;
+	endTime: number;
+	testTime: number;
+	expectedTests: number;
+	completedTests: number;
+	expectedModules: number;
+	completedModules: number;
+	expectedCollections: number;
+	completedCollections: number;
+	errorLogs: LoggerAction[];
+	collections: (CollectionResults | undefined)[];
+}
+
+const SPACE = "  ";
+
+export function getResultsAsString(runResults: RunResults): string {
+	const output: string[] = [];
+
+	for (let errorAction of runResults.errorLogs) {
+		if ("run_error" !== errorAction.type) continue;
+		output.push(`${SPACE}[session_error]\n${errorAction.error}`);
+	}
+
+	// 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.
+
+	if (!logRunResults(output, runResults))
+		for (const collection of runResults.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, runResults);
+
+	return output.join("\n");
+}
+
+function logRunResults(output: string[], result: RunResults): boolean {
+	// When everything goes right :3
+	if (
+		!result.fails &&
+		!result.errors &&
+		result.expectedTests === result.completedTests &&
+		result.expectedModules === result.completedModules &&
+		result.expectedCollections === result.completedCollections
+	) {
+		output.push(`${result.completedTests} tests
+${result.completedModules} modules
+${result.completedCollections} collections`);
+		return true;
+	}
+
+	for (let errorAction of result.errorLogs) {
+		if ("run_error" !== errorAction.type) continue;
+		output.push(`[run_error] ${errorAction.error}`);
+	}
+
+	return false;
+}
+
+function logCollectionResult(
+	output: string[],
+	collection: CollectionResults | undefined,
+): boolean {
+	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(
+			`${collection.expectedTests} tests
+${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}`);
+	}
+
+	return false;
+}
+
+function logModuleResult(
+	output: string[],
+	module: ModuleResults | undefined,
+): boolean {
+	if (!module) return true;
+
+	let { loggerAction } = module;
+	if ("start_module" !== loggerAction.type) return true;
+
+	output.push(`${SPACE}${loggerAction.module_name}`);
+
+	// when everything in the module goes right
+	if (
+		!module.fails &&
+		!module.errors &&
+		module.expectedTests === module.completedTests
+	) {
+		output.push(`${SPACE.repeat(2)}${module.expectedTests} tests`);
+		return true;
+	}
+
+	for (let errorAction of module.errorLogs) {
+		if ("collection_error" !== errorAction.type) continue;
+		output.push(`${SPACE}[module_error] ${errorAction.error}`);
+	}
+
+	return false;
+}
+
+function logTest(output: string[], test: TestResults | undefined) {
+	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(2)}${test_name}
+${SPACE.repeat(3)}[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(2)}${test_name}`);
+		}
+
+		if (isAssertion) {
+			output.push(`${SPACE.repeat(3)}- ${assertions}`);
+		}
+
+		if (isAssertionArray) {
+			for (const assertion of assertions) {
+				output.push(`${SPACE.repeat(3)}- ${assertion}`);
+			}
+		}
+	}
+}
+
+function logSummary(output: string[], runResults: RunResults) {
+	let status_with_color = runResults.fails
+		? yellow("\u{2717} failed")
+		: blue("\u{2714} passed");
+
+	if (runResults.errors) {
+		status_with_color = gray("\u{2717} errored");
+	}
+
+	let totalTime = runResults.endTime - runResults.startTime;
+	output.push(`
+${status_with_color}
+duration: ${runResults.testTime.toFixed(4)} mS
+total: ${totalTime.toFixed(4)} mS
+`);
+}
+
+// 39 - default foreground color
+// 49 - default background color
+function blue(text: string) {
+	return `\x1b[44m\x1b[97m${text}\x1b[0m`;
+}
+
+function yellow(text: string) {
+	return `\x1b[43m\x1b[97m${text}\x1b[0m`;
+}
+
+function gray(text: string) {
+	return `\x1b[100m\x1b[97m${text}\x1b[0m`;
+}

package/{nodejs_cli → nodejs}/tsconfig.json

@@ -2,6 +2,7 @@
 	"extends": "../tsconfig.json",
 	"compilerOptions": {
 		"rootDir": "./src",
-		"outDir": "./dist"
+		"outDir": "./dist",
+		"declaration": false
 	}
 }

package/nodejs/tsconfig.tsbuildinfo

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

package/package.json

@@ -1,16 +1,18 @@
 {
 	"name": "@w-lfpup/jackrabbit",
 	"description": "A test runner without dependencies",
-	"version": "0.2.0",
+	"version": "0.3.0",
 	"license": "BSD-3-Clause",
 	"workspaces": [
 		"core",
 		"tests",
-		"cli",
-		"nodejs_cli"
+		"nodejs",
+		"browser",
+		"webdriver"
 	],
 	"bin": {
-		"jackrabbit": "nodejs_cli/dist/mod.js"
+		"jackrabbit": "nodejs/dist/mod.js",
+		"jackrabbit_webdriver": "webdriver/dist/mod.js"
 	},
 	"scripts": {
 		"prepare": "npm run build",

package/tests/dist/mod.d.ts

@@ -1,9 +1,20 @@
 declare function testsFail(): Promise<"fail tests failed to fail" | undefined>;
 declare function testsPass(): Promise<"passing tests failed to pass" | undefined>;
-export declare const testModules: {
-    tests: (typeof testsFail | typeof testsPass)[];
+declare function testsError(): Promise<"tests failed to error" | "tests should error not fail" | undefined>;
+export declare const testModules: ({
+    tests: (typeof testsFail)[];
     options: {
         title: string;
     };
-}[];
+} | {
+    tests: (typeof testsPass)[];
+    options: {
+        title: string;
+    };
+} | {
+    tests: (typeof testsError)[];
+    options: {
+        title: string;
+    };
+})[];
 export {};

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,