@w-lfpup/jackrabbit 0.1.0 → 0.3.0

package/core/dist/jackrabbit_types.d.ts

@@ -1,56 +1,90 @@
 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 {
-    title?: string;
+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";
 }
-interface StartModule {
+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";
+}
+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 | StartModule | EndModule | StartTest | EndTest;
+export type LoggerAction = StartRun | EndRun | RunError | StartTestCollection | EndTestCollection | TestCollectionError | StartModule | ModuleError | EndModule | StartTest | EndTest | TestError;
 export interface LoggerInterface {
-    readonly failed: boolean;
-    readonly cancelled: boolean;
-    log(testModules: TestModule[], action: LoggerAction): void;
+    log(action: LoggerAction): void;
 }
 export {};

package/core/dist/mod.d.ts

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

package/core/dist/mod.js

@@ -1 +1 @@
-export { startRun, cancelRun } from "./run_steps.js";
+export { runCollection, sleep } from "./run_steps.js";

package/core/dist/run_steps.d.ts

@@ -1,3 +1,3 @@
 import type { LoggerInterface, TestModule } from "./jackrabbit_types.ts";
-export declare function startRun(logger: LoggerInterface, testModules: TestModule[]): Promise<void>;
-export declare function cancelRun(logger: LoggerInterface, testModules: TestModule[]): void;
+export declare function sleep(time: number): Promise<void>;
+export declare function runCollection(logger: LoggerInterface, testModules: TestModule[], collection_id: number, collection_url: string): Promise<void>;

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 {
-	title?: string;
+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";
 }
 
-interface StartModule {
+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";
+}
+
+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";