@w-lfpup/jackrabbit 0.1.0 → 0.3.0

package/core/src/run_steps.ts

@@ -2,11 +2,22 @@ import type {
 	Assertions,
 	LoggerInterface,
 	TestModule,
+	Test,
+	TestOptions,
 } from "./jackrabbit_types.ts";
 
+interface ExecTestParams {
+	logger: LoggerInterface;
+	options: TestOptions | undefined;
+	jrTest: Test;
+	collection_id: number;
+	module_id: number;
+	test_id: number;
+}
+
 const TIMEOUT_INTERVAL_MS = 10000;
 
-function sleep(time: number): Promise<void> {
+export function sleep(time: number): Promise<void> {
 	return new Promise((resolve) => {
 		setTimeout(() => {
 			resolve();
@@ -14,125 +25,145 @@ function sleep(time: number): Promise<void> {
 	});
 }
 
-async function createTimeout(
-	timeoutMs: number = TIMEOUT_INTERVAL_MS,
-): Promise<Assertions> {
+async function failAfterTimeout(timeoutMs: number): Promise<Assertions> {
 	await sleep(timeoutMs);
 
 	return `timed out at ${performance.now()} after ${timeoutMs} ms.`;
 }
 
-async function execTest(
-	testModules: TestModule[],
-	logger: LoggerInterface,
-	moduleId: number,
-	testId: number,
-) {
-	if (logger.cancelled) return;
+async function execTest(params: ExecTestParams) {
+	const { logger, options, jrTest, test_id, collection_id, module_id } = params;
+
+	const test_name = jrTest.name ?? test_id.toString();
 
-	logger.log(testModules, {
+	logger.log({
+		collection_id,
+		module_id,
+		test_id,
+		test_name,
 		type: "start_test",
-		moduleId,
-		testId,
 	});
 
-	const { tests, options } = testModules[moduleId];
-
-	const testFunc = tests[testId];
-	const startTime = performance.now();
-	const assertions = await Promise.race([
-		createTimeout(options.timeoutMs),
-		testFunc(),
-	]);
-
-	if (logger.cancelled) return;
-
-	const endTime = performance.now();
-
-	logger.log(testModules, {
-		type: "end_test",
-		assertions,
-		endTime,
-		moduleId,
-		startTime,
-		testId,
-	});
+	let start_time = performance.now();
+
+	let assertions: Assertions;
+	try {
+		assertions = await Promise.race([
+			failAfterTimeout(options?.timeoutMs ?? TIMEOUT_INTERVAL_MS),
+			jrTest(),
+		]);
+
+		let end_time = performance.now();
+
+		logger.log({
+			assertions,
+			collection_id,
+			start_time,
+			end_time,
+			module_id,
+			test_id,
+			type: "end_test",
+		});
+	} catch (e: unknown) {
+		return logger.log({
+			collection_id,
+			error: e?.toString() ?? "wild test error",
+			module_id,
+			test_id,
+			type: "test_error",
+		});
+	}
 }
 
 async function execCollection(
-	testModules: TestModule[],
 	logger: LoggerInterface,
-	moduleId: number,
+	testModule: TestModule,
+	collection_id: number,
+	module_id: number,
 ) {
-	if (logger.cancelled) return;
-
-	const { tests } = testModules[moduleId];
+	const { tests, options } = testModule;
 
 	const wrappedTests = [];
-	for (let [testID] of tests.entries()) {
-		wrappedTests.push(execTest(testModules, logger, moduleId, testID));
+	for (let [test_id, jrTest] of tests.entries()) {
+		wrappedTests.push(function () {
+			return execTest({
+				logger,
+				options,
+				jrTest,
+				collection_id,
+				module_id,
+				test_id,
+			});
+		});
 	}
 
-	if (logger.cancelled) return;
-
 	await Promise.all(wrappedTests);
 }
 
 async function execCollectionOrdered(
-	testModules: TestModule[],
 	logger: LoggerInterface,
-	moduleId: number,
+	testModule: TestModule,
+	collection_id: number,
+	module_id: number,
 ) {
-	const { tests } = testModules[moduleId];
-
-	for (let [testID] of tests.entries()) {
-		if (logger.cancelled) return;
-
-		await execTest(testModules, logger, moduleId, testID);
+	const { tests, options } = testModule;
+
+	for (let [test_id, jrTest] of tests.entries()) {
+		await execTest({
+			logger,
+			options,
+			jrTest,
+			collection_id,
+			module_id,
+			test_id,
+		});
 	}
 }
 
-export async function startRun(
+export async function runCollection(
 	logger: LoggerInterface,
 	testModules: TestModule[],
+	collection_id: number,
+	collection_url: string,
 ) {
-	logger.log(testModules, {
-		type: "start_run",
-		time: performance.now(),
+	logger.log({
+		collection_id,
+		collection_url,
+		expected_module_count: testModules.length,
+		type: "start_collection",
 	});
 
-	for (let [moduleId, testModule] of testModules.entries()) {
-		if (logger.cancelled) return;
+	for (let [module_id, testModule] of testModules.entries()) {
+		const { options } = testModule;
+
+		const module_name = options?.title ?? module_id.toString();
 
-		logger.log(testModules, {
+		logger.log({
 			type: "start_module",
-			moduleId,
+			module_id,
+			module_name,
+			collection_id,
+			expected_test_count: testModule.tests.length,
 		});
 
-		const { options } = testModule;
 		options?.runAsynchronously
-			? await execCollection(testModules, logger, moduleId)
-			: await execCollectionOrdered(testModules, logger, moduleId);
-
-		if (logger.cancelled) return;
-
-		logger.log(testModules, {
+			? await execCollection(logger, testModule, collection_id, module_id)
+			: await execCollectionOrdered(
+					logger,
+					testModule,
+					collection_id,
+					module_id,
+				);
+
+		logger.log({
 			type: "end_module",
-			moduleId,
+			collection_id,
+			module_id,
 		});
 	}
 
-	logger.log(testModules, {
-		type: "end_run",
-		time: performance.now(),
-	});
-}
-
-export function cancelRun(logger: LoggerInterface, testModules: TestModule[]) {
-	if (logger.cancelled) return;
-
-	logger.log(testModules, {
-		type: "cancel_run",
-		time: performance.now(),
+	logger.log({
+		type: "end_collection",
+		collection_id,
 	});
 }

package/examples/hello_world/goodbye_world.ts

@@ -2,7 +2,7 @@ async function test_that_passes() {
 	return [];
 }
 
-async function test_that_fails() {
+function test_that_fails() {
 	return ["this test will fail"];
 }
 

package/examples/hello_world/hello_world.ts

@@ -2,7 +2,7 @@ function test_will_pass() {
 	return;
 }
 
-function test_will_fail() {
+async function test_will_fail() {
 	return "this test will fail";
 }
 

package/nodejs/dist/logger.js

@@ -0,0 +1,161 @@
+import { getResultsAsString } from "./results_str.js";
+export class Logger {
+    #results = {
+        startTime: 0,
+        fails: 0,
+        errors: 0,
+        expectedTests: 0,
+        endTime: 0,
+        testTime: 0,
+        expectedModules: 0,
+        expectedCollections: 0,
+        completedModules: 0,
+        completedCollections: 0,
+        completedTests: 0,
+        errorLogs: [],
+        collections: [],
+    };
+    get failed() {
+        return this.#results.fails !== 0;
+    }
+    get errored() {
+        return this.#results.errors !== 0;
+    }
+    get results() {
+        return getResultsAsString(this.#results);
+    }
+    log(action) {
+        if ("start_run" === action.type) {
+            this.#results.startTime = action.time;
+            this.#results.expectedCollections = action.expected_collection_count;
+        }
+        if ("end_run" === action.type) {
+            this.#results.endTime = action.time;
+        }
+        if ("run_error" === action.type) {
+            this.#results.errors += 1;
+            this.#results.errorLogs.push(action);
+        }
+        if ("start_collection" === action.type) {
+            this.#results.collections[action.collection_id] = {
+                completedModules: 0,
+                completedTests: 0,
+                errorLogs: [],
+                errors: 0,
+                expectedModules: action.expected_module_count,
+                expectedTests: 0,
+                fails: 0,
+                loggerAction: action,
+                modules: [],
+            };
+            this.#results.expectedModules += action.expected_module_count;
+        }
+        if ("end_collection" === action.type) {
+            let collection = this.#results.collections[action.collection_id];
+            if (!collection)
+                return;
+            this.#results.completedCollections += 1;
+        }
+        if ("collection_error" === action.type) {
+            let collection = this.#results.collections[action.collection_id];
+            if (!collection)
+                return;
+            this.#results.errors += 1;
+            collection.errors += 1;
+            collection.errorLogs.push(action);
+        }
+        if ("start_module" === action.type) {
+            let collection = this.#results.collections[action.collection_id];
+            if (!collection)
+                return;
+            collection.modules[action.module_id] = {
+                completedTests: 0,
+                errorLogs: [],
+                errors: 0,
+                expectedTests: action.expected_test_count,
+                fails: 0,
+                loggerAction: action,
+                testResults: [],
+            };
+            collection.expectedTests += action.expected_test_count;
+            this.#results.expectedTests += action.expected_test_count;
+        }
+        if ("end_module" === action.type) {
+            let collection = this.#results.collections[action.collection_id];
+            if (!collection)
+                return;
+            let module = collection.modules[action.module_id];
+            if (!module)
+                return;
+            this.#results.completedModules += 1;
+            collection.completedModules += 1;
+        }
+        if ("module_error" === action.type) {
+            let collection = this.#results.collections[action.collection_id];
+            if (!collection)
+                return;
+            let module = collection.modules[action.module_id];
+            if (!module)
+                return;
+            this.#results.errors += 1;
+            collection.errors += 1;
+            module.errors += 1;
+            module.errorLogs.push(action);
+        }
+        if ("start_test" === action.type) {
+            let collection = this.#results.collections[action.collection_id];
+            if (!collection)
+                return;
+            let module = collection.modules[action.module_id];
+            if (!module)
+                return;
+            module.testResults[action.test_id] = {
+                loggerStartAction: action,
+                loggerEndAction: undefined,
+            };
+        }
+        if ("end_test" === action.type) {
+            endTest(this.#results, action);
+        }
+        if ("test_error" === action.type) {
+            let collection = this.#results.collections[action.collection_id];
+            if (!collection)
+                return;
+            let module = collection.modules[action.module_id];
+            if (!module)
+                return;
+            let testResult = module.testResults[action.test_id];
+            if (!testResult)
+                return;
+            testResult.loggerEndAction = action;
+            this.#results.errors += 1;
+            collection.errors += 1;
+            module.errors += 1;
+        }
+    }
+}
+function endTest(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) {
+        runResults.fails += 1;
+        collection.fails += 1;
+        module.fails += 1;
+    }
+    runResults.testTime += Math.max(0, loggerAction.end_time - loggerAction.start_time);
+}

package/nodejs/dist/mod.js

@@ -0,0 +1,31 @@
+#!/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) {
+        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/dist/results.js

@@ -0,0 +1,139 @@
+const SPACE = "  ";
+export function getResultsAsString(runResults) {
+    const output = [];
+    for (let errorAction of runResults.errorLogs) {
+        if ("run_error" !== errorAction.type)
+            continue;
+        output.push(`${SPACE}[session_error]\n${errorAction.error}`);
+    }
+    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, result) {
+    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, 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(`${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, module) {
+    if (!module)
+        return true;
+    let { loggerAction } = module;
+    if ("start_module" !== loggerAction.type)
+        return true;
+    output.push(`${SPACE}${loggerAction.module_name}`);
+    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, 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(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, 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
+`);
+}
+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`;
+}