@w-lfpup/jackrabbit 0.2.0 → 0.3.0

package/core/dist/run_steps.js

@@ -1,95 +1,111 @@
 const TIMEOUT_INTERVAL_MS = 10000;
-function sleep(time) {
+export function sleep(time) {
     return new Promise((resolve) => {
         setTimeout(() => {
             resolve();
         }, time);
     });
 }
-async function createTimeout(timeoutMs = TIMEOUT_INTERVAL_MS) {
+async function failAfterTimeout(timeoutMs) {
     await sleep(timeoutMs);
     return `timed out at ${performance.now()} after ${timeoutMs} ms.`;
 }
-async function execTest(testModules, logger, moduleId, testId) {
-    if (logger.cancelled)
-        return;
-    logger.log(testModules, {
+async function execTest(params) {
+    const { logger, options, jrTest, test_id, collection_id, module_id } = params;
+    const test_name = jrTest.name ?? test_id.toString();
+    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;
+    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) {
+        return logger.log({
+            collection_id,
+            error: e?.toString() ?? "wild test error",
+            module_id,
+            test_id,
+            type: "test_error",
+        });
+    }
 }
-async function execCollection(testModules, logger, moduleId) {
-    if (logger.cancelled)
-        return;
-    const { tests } = testModules[moduleId];
+async function execCollection(logger, testModule, collection_id, module_id) {
+    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, logger, moduleId) {
-    const { tests } = testModules[moduleId];
-    for (let [testID] of tests.entries()) {
-        if (logger.cancelled)
-            return;
-        await execTest(testModules, logger, moduleId, testID);
+async function execCollectionOrdered(logger, testModule, collection_id, module_id) {
+    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(logger, testModules) {
-    logger.log(testModules, {
-        type: "start_run",
-        time: performance.now(),
+export async function runCollection(logger, testModules, collection_id, collection_url) {
+    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;
-        logger.log(testModules, {
+    for (let [module_id, testModule] of testModules.entries()) {
+        const { options } = testModule;
+        const module_name = options?.title ?? module_id.toString();
+        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, testModules) {
-    if (logger.cancelled)
-        return;
-    logger.log(testModules, {
-        type: "cancel_run",
-        time: performance.now(),
+    logger.log({
+        type: "end_collection",
+        collection_id,
     });
 }

package/core/src/jackrabbit_types.ts

@@ -2,74 +2,118 @@ interface Stringable {
 	toString: Object["toString"];
 }
 
-export type Assertions = Stringable | Stringable[] | undefined;
+export type Assertions = Stringable | Stringable[] | undefined | null;
 
 type SyncTest = () => Assertions;
 type AsyncTest = () => Promise<Assertions>;
 export type Test = SyncTest | AsyncTest;
 
-export interface Options {
+export interface TestOptions {
 	runAsynchronously?: boolean;
 	timeoutMs?: number;
 	title?: string;
 }
 
 export interface TestModule {
+	options?: TestOptions;
 	tests: Test[];
-	options: Options;
 }
 
-interface StartRun {
-	type: "start_run";
+export interface StartRun {
+	expected_collection_count: number;
 	time: number;
+	type: "start_run";
 }
 
-interface EndRun {
-	type: "end_run";
+export interface EndRun {
 	time: number;
+	type: "end_run";
 }
 
-interface CancelRun {
-	type: "cancel_run";
-	time: number;
+export interface RunError {
+	error: string;
+	type: "run_error";
+}
+
+export interface StartTestCollection {
+	collection_id: number;
+	collection_url: string;
+	expected_module_count: number;
+	type: "start_collection";
+}
+
+export interface EndTestCollection {
+	collection_id: number;
+	type: "end_collection";
 }
 
-interface StartModule {
+export interface TestCollectionError {
+	collection_id: number;
+	error: string;
+	type: "collection_error";
+}
+
+export interface StartModule {
+	collection_id: number;
+	expected_test_count: number;
+	module_id: number;
+	module_name: string;
 	type: "start_module";
-	moduleId: number;
 }
 
-interface EndModule {
+export interface EndModule {
+	collection_id: number;
+	module_id: number;
 	type: "end_module";
-	moduleId: number;
 }
 
-interface StartTest {
+export interface ModuleError {
+	collection_id: number;
+	error: string;
+	module_id: number;
+	type: "module_error";
+}
+
+export interface StartTest {
+	collection_id: number;
+	module_id: number;
+	test_id: number;
+	test_name: string;
 	type: "start_test";
-	testId: number;
-	moduleId: number;
 }
 
-interface EndTest {
-	type: "end_test";
-	testId: number;
-	moduleId: number;
-	startTime: number;
-	endTime: number;
+export interface EndTest {
 	assertions: Assertions;
+	collection_id: number;
+	module_id: number;
+	test_id: number;
+	start_time: number;
+	end_time: number;
+	type: "end_test";
+}
+
+export interface TestError {
+	collection_id: number;
+	error: string;
+	module_id: number;
+	test_id: number;
+	type: "test_error";
 }
 
 export type LoggerAction =
 	| StartRun
 	| EndRun
-	| CancelRun
+	| RunError
+	| StartTestCollection
+	| EndTestCollection
+	| TestCollectionError
 	| StartModule
+	| ModuleError
 	| EndModule
 	| StartTest
-	| EndTest;
+	| EndTest
+	| TestError;
 
 export interface LoggerInterface {
-	readonly failed: boolean;
-	readonly cancelled: boolean;
-	log(testModules: TestModule[], action: LoggerAction): void;
+	log(action: LoggerAction): void;
 }

package/core/src/mod.ts

@@ -1,9 +1,3 @@
-export type {
-	LoggerAction,
-	LoggerInterface,
-	Test,
-	Options,
-	TestModule,
-} from "./jackrabbit_types.ts";
+export type * from "./jackrabbit_types.ts";
 
-export { startRun, cancelRun } from "./run_steps.js";
+export { runCollection, sleep } from "./run_steps.js";

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";
 }