@w-lfpup/jackrabbit 0.1.0

package/.github/workflows/build_and_test.yml

@@ -0,0 +1,18 @@
+name: Build and Test
+
+on:
+  push:
+    branches: ["main"]
+  pull_request:
+    branches: ["main"]
+
+jobs:
+  build_and_test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+      - uses: actions/setup-node@v4
+      - name: Install
+        run: npm ci
+      - name: Test
+        run: npm run test

package/.prettierignore

@@ -0,0 +1,3 @@
+dist/
+
+package-lock.json

package/.prettierrc

@@ -0,0 +1,5 @@
+{
+	"trailingComma": "all",
+	"useTabs": true,
+	"tabWidth": 2
+}

package/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2021, Taylor Vann
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.md

@@ -0,0 +1,33 @@
+# Jackrabbit-js
+
+Write tests without dependencies (including jackrabbit itself).
+
+## Tests
+
+Read [this guide](./test_guide.md) to create jackrabbit tests.
+
+## Nodejs
+
+### Install
+
+Install jackrabbit with npm.
+
+```sh
+npm install --save-dev @w-lfpup/jackrabbit
+```
+
+Or Install jackrabbit directly from github.
+
+```sh
+npm install --save-dev https://github.com/w-lfpup/jackrabbit-js
+```
+
+### Run Test Collections
+
+```sh
+npx jackrabbit --file ./path/to/test/collection.ts
+```
+
+## License
+
+`Jackrabbit-js` is released under the BSD 3-Clause License.

package/cli/dist/cli.d.ts

@@ -0,0 +1,3 @@
+import type { ConfigInterface, ImporterInterface } from "./cli_types.ts";
+import type { LoggerInterface } from "../../core/dist/mod.ts";
+export declare function run(config: ConfigInterface, importer: ImporterInterface, logger?: LoggerInterface): Promise<void>;

package/cli/dist/cli.js

@@ -0,0 +1,8 @@
+import { startRun } from "../../core/dist/mod.js";
+import { Logger } from "./logger.js";
+export async function run(config, importer, logger = new Logger()) {
+    for (const file of config.files) {
+        const testModules = await importer.load(file);
+        await startRun(logger, testModules);
+    }
+}

package/cli/dist/cli_types.d.ts

@@ -0,0 +1,7 @@
+import type { TestModule } from "../../core/dist/mod.ts";
+export interface ConfigInterface {
+    files: string[];
+}
+export interface ImporterInterface {
+    load(url: string): Promise<TestModule[]>;
+}

package/cli/dist/cli_types.js

@@ -0,0 +1 @@
+export {};

package/cli/dist/config.d.ts

@@ -0,0 +1,5 @@
+import type { ConfigInterface } from "./cli_types.ts";
+export declare class Config implements ConfigInterface {
+    files: string[];
+    constructor(args: string[]);
+}

package/cli/dist/config.js

@@ -0,0 +1,27 @@
+const reactions = {
+    "--file": fileConfig,
+    "-f": fileConfig,
+};
+function fileConfig(config, file) {
+    if (file === undefined)
+        return;
+    config.files.push(file);
+}
+function iterateArgs(config, args) {
+    let index = 0;
+    while (index < args.length) {
+        const flag = args[index];
+        const reaction = reactions[flag];
+        if (reaction === undefined) {
+            throw new Error(`unrecognized argument: ${flag}`);
+        }
+        reaction(config, args[index + 1]);
+        index += 2;
+    }
+}
+export class Config {
+    files = [];
+    constructor(args) {
+        iterateArgs(this, args);
+    }
+}

package/cli/dist/importer.d.ts

@@ -0,0 +1,7 @@
+import type { TestModule } from "../../core/dist/mod.ts";
+import type { ImporterInterface } from "./cli_types.ts";
+export declare class Importer implements ImporterInterface {
+    #private;
+    constructor(cwd: string);
+    load(uri: string): Promise<TestModule[]>;
+}

package/cli/dist/importer.js

@@ -0,0 +1,16 @@
+export class Importer {
+    #cwd;
+    constructor(cwd) {
+        this.#cwd = cwd;
+    }
+    async load(uri) {
+        let uri_updated = uri;
+        let absolute = uri.startsWith("/");
+        if (!absolute) {
+            uri_updated = this.#cwd + "/" + uri;
+        }
+        const { testModules } = await import(uri_updated);
+        // verify here
+        return testModules;
+    }
+}

package/cli/dist/logger.d.ts

@@ -0,0 +1,7 @@
+import type { LoggerAction, LoggerInterface, TestModule } from "../../core/dist/mod.js";
+export declare class Logger implements LoggerInterface {
+    #private;
+    get failed(): boolean;
+    get cancelled(): boolean;
+    log(testModules: TestModule[], action: LoggerAction): void;
+}

package/cli/dist/logger.js

@@ -0,0 +1,88 @@
+export class Logger {
+    #assertions = new Map();
+    #data = {
+        cancelled: false,
+        failed: false,
+        startTime: -1,
+        testTime: 0,
+    };
+    get failed() {
+        return this.#data.failed;
+    }
+    get cancelled() {
+        return this.#data.cancelled;
+    }
+    log(testModules, action) {
+        if ("start_run" === action.type) {
+            this.#data.startTime = action.time;
+        }
+        if ("cancel_run" === action.type) {
+            this.#data.cancelled = true;
+            logAssertions(testModules, this.#assertions);
+            logResults(this.#data, action.time);
+        }
+        //  add to fails
+        if ("end_test" === action.type && action?.assertions) {
+            if (Array.isArray(action.assertions) && action.assertions.length === 0)
+                return;
+            this.#data.testTime += action.endTime - action.startTime;
+            this.#data.failed = true;
+            let assertions = this.#assertions.get(action.moduleId);
+            if (assertions) {
+                assertions.set(action.testId, action);
+            }
+            else {
+                this.#assertions.set(action.moduleId, new Map([[action.testId, action]]));
+            }
+        }
+        if ("end_run" === action.type) {
+            logAssertions(testModules, this.#assertions);
+            logResults(this.#data, action.time);
+        }
+    }
+}
+function logAssertions(testModules, fails) {
+    for (let [moduleID, module] of testModules.entries()) {
+        let failedTests = fails.get(moduleID);
+        if (undefined === failedTests)
+            continue;
+        const { tests, options } = module;
+        console.log(`${options?.title ?? `module index: ${moduleID}`}`);
+        let numFailedTests = fails.get(moduleID)?.size ?? 0;
+        console.log(`${numFailedTests}/${tests.length} tests failed`);
+        for (let [index, test] of tests.entries()) {
+            let action = failedTests.get(index);
+            if (!action || action.type !== "end_test")
+                continue;
+            console.log(`\t${test.name}\n\t\t${action.assertions}`);
+        }
+        console.log("\n");
+    }
+}
+function logResults(data, time) {
+    let status_with_color = data.failed
+        ? yellow("\u{2717} failed")
+        : blue("\u{2714} passed");
+    if (data.cancelled) {
+        status_with_color = gray("\u{2717} cancelled");
+    }
+    const overhead = time - data.startTime;
+    console.log(`Results:
+${status_with_color}
+  duration: ${data.testTime.toFixed(4)} mS
+  overhead: ${overhead.toFixed(4)} mS`);
+}
+// 39 - default foreground color
+// 49 - default background color
+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`;
+}
+function logTestModule(moduleID, title) {
+    console.log(`module: ${title ?? `module index: ${moduleID}`}`);
+}

package/cli/dist/mod.d.ts

@@ -0,0 +1,6 @@
+export type { ConfigInterface } from "./cli_types.ts";
+export type { ImporterInterface } from "./cli_types.ts";
+export { Config } from "./config.js";
+export { Importer } from "./importer.js";
+export { Logger } from "./logger.js";
+export { run } from "./cli.js";

package/cli/dist/mod.js

@@ -0,0 +1,4 @@
+export { Config } from "./config.js";
+export { Importer } from "./importer.js";
+export { Logger } from "./logger.js";
+export { run } from "./cli.js";

package/cli/package.json

@@ -0,0 +1,8 @@
+{
+	"name": "cli",
+	"type": "module",
+	"main": "dist/mod.js",
+	"scripts": {
+		"build": "npx tsc --build"
+	}
+}

package/cli/src/cli.ts

@@ -0,0 +1,17 @@
+import type { ConfigInterface, ImporterInterface } from "./cli_types.ts";
+import type { LoggerInterface } from "../../core/dist/mod.ts";
+
+import { startRun } from "../../core/dist/mod.js";
+import { Logger } from "./logger.js";
+
+export async function run(
+	config: ConfigInterface,
+	importer: ImporterInterface,
+	logger: LoggerInterface = new Logger(),
+) {
+	for (const file of config.files) {
+		const testModules = await importer.load(file);
+
+		await startRun(logger, testModules);
+	}
+}

package/cli/src/cli_types.ts

@@ -0,0 +1,9 @@
+import type { TestModule } from "../../core/dist/mod.ts";
+
+export interface ConfigInterface {
+	files: string[];
+}
+
+export interface ImporterInterface {
+	load(url: string): Promise<TestModule[]>;
+}

package/cli/src/config.ts

@@ -0,0 +1,36 @@
+import type { ConfigInterface } from "./cli_types.ts";
+
+type Reaction = (config: ConfigInterface, value?: string) => void;
+type Reactions = Record<string, Reaction>;
+
+const reactions: Reactions = {
+	"--file": fileConfig,
+	"-f": fileConfig,
+};
+
+function fileConfig(config: ConfigInterface, file?: string) {
+	if (file === undefined) return;
+	config.files.push(file);
+}
+
+function iterateArgs(config: ConfigInterface, args: string[]) {
+	let index = 0;
+	while (index < args.length) {
+		const flag = args[index];
+		const reaction = reactions[flag];
+		if (reaction === undefined) {
+			throw new Error(`unrecognized argument: ${flag}`);
+		}
+
+		reaction(config, args[index + 1]);
+		index += 2;
+	}
+}
+
+export class Config implements ConfigInterface {
+	files: string[] = [];
+
+	constructor(args: string[]) {
+		iterateArgs(this, args);
+	}
+}

package/cli/src/importer.ts

@@ -0,0 +1,25 @@
+import type { TestModule } from "../../core/dist/mod.ts";
+import type { ImporterInterface } from "./cli_types.ts";
+
+export class Importer implements ImporterInterface {
+	#cwd: string;
+
+	constructor(cwd: string) {
+		this.#cwd = cwd;
+	}
+
+	async load(uri: string): Promise<TestModule[]> {
+		let uri_updated = uri;
+
+		let absolute = uri.startsWith("/");
+		if (!absolute) {
+			uri_updated = this.#cwd + "/" + uri;
+		}
+
+		const { testModules } = await import(uri_updated);
+
+		// verify here
+
+		return testModules;
+	}
+}

package/cli/src/logger.ts

@@ -0,0 +1,126 @@
+import type {
+	LoggerAction,
+	LoggerInterface,
+	TestModule,
+} from "../../core/dist/mod.js";
+
+interface LoggerData {
+	cancelled: boolean;
+	failed: boolean;
+	startTime: number;
+	testTime: number;
+}
+
+export class Logger implements LoggerInterface {
+	#assertions: Map<number, Map<number, LoggerAction>> = new Map();
+	#data: LoggerData = {
+		cancelled: false,
+		failed: false,
+		startTime: -1,
+		testTime: 0,
+	};
+
+	get failed() {
+		return this.#data.failed;
+	}
+
+	get cancelled() {
+		return this.#data.cancelled;
+	}
+
+	log(testModules: TestModule[], action: LoggerAction) {
+		if ("start_run" === action.type) {
+			this.#data.startTime = action.time;
+		}
+
+		if ("cancel_run" === action.type) {
+			this.#data.cancelled = true;
+			logAssertions(testModules, this.#assertions);
+			logResults(this.#data, action.time);
+		}
+
+		//  add to fails
+		if ("end_test" === action.type && action?.assertions) {
+			if (Array.isArray(action.assertions) && action.assertions.length === 0)
+				return;
+
+			this.#data.testTime += action.endTime - action.startTime;
+			this.#data.failed = true;
+
+			let assertions = this.#assertions.get(action.moduleId);
+			if (assertions) {
+				assertions.set(action.testId, action);
+			} else {
+				this.#assertions.set(
+					action.moduleId,
+					new Map([[action.testId, action]]),
+				);
+			}
+		}
+
+		if ("end_run" === action.type) {
+			logAssertions(testModules, this.#assertions);
+			logResults(this.#data, action.time);
+		}
+	}
+}
+
+function logAssertions(
+	testModules: TestModule[],
+	fails: Map<number, Map<number, LoggerAction>>,
+) {
+	for (let [moduleID, module] of testModules.entries()) {
+		let failedTests = fails.get(moduleID);
+		if (undefined === failedTests) continue;
+
+		const { tests, options } = module;
+
+		console.log(`${options?.title ?? `module index: ${moduleID}`}`);
+
+		let numFailedTests = fails.get(moduleID)?.size ?? 0;
+		console.log(`${numFailedTests}/${tests.length} tests failed`);
+
+		for (let [index, test] of tests.entries()) {
+			let action = failedTests.get(index);
+			if (!action || action.type !== "end_test") continue;
+
+			console.log(`\t${test.name}\n\t\t${action.assertions}`);
+		}
+
+		console.log("\n");
+	}
+}
+
+function logResults(data: LoggerData, time: number) {
+	let status_with_color = data.failed
+		? yellow("\u{2717} failed")
+		: blue("\u{2714} passed");
+
+	if (data.cancelled) {
+		status_with_color = gray("\u{2717} cancelled");
+	}
+
+	const overhead = time - data.startTime;
+	console.log(`Results:
+${status_with_color}
+  duration: ${data.testTime.toFixed(4)} mS
+  overhead: ${overhead.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`;
+}
+
+function logTestModule(moduleID: number, title?: string) {
+	console.log(`module: ${title ?? `module index: ${moduleID}`}`);
+}

package/cli/src/mod.ts

@@ -0,0 +1,7 @@
+export type { ConfigInterface } from "./cli_types.ts";
+export type { ImporterInterface } from "./cli_types.ts";
+
+export { Config } from "./config.js";
+export { Importer } from "./importer.js";
+export { Logger } from "./logger.js";
+export { run } from "./cli.js";

package/cli/tsconfig.json

@@ -0,0 +1,7 @@
+{
+	"extends": "../tsconfig.json",
+	"compilerOptions": {
+		"rootDir": "./src",
+		"outDir": "./dist"
+	}
+}

package/cli/tsconfig.tsbuildinfo

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

package/core/dist/jackrabbit_types.d.ts

@@ -0,0 +1,56 @@
+interface Stringable {
+    toString: Object["toString"];
+}
+export type Assertions = Stringable | Stringable[] | undefined;
+type SyncTest = () => Assertions;
+type AsyncTest = () => Promise<Assertions>;
+export type Test = SyncTest | AsyncTest;
+export interface Options {
+    title?: string;
+    runAsynchronously?: boolean;
+    timeoutMs?: number;
+}
+export interface TestModule {
+    tests: Test[];
+    options: Options;
+}
+interface StartRun {
+    type: "start_run";
+    time: number;
+}
+interface EndRun {
+    type: "end_run";
+    time: number;
+}
+interface CancelRun {
+    type: "cancel_run";
+    time: number;
+}
+interface StartModule {
+    type: "start_module";
+    moduleId: number;
+}
+interface EndModule {
+    type: "end_module";
+    moduleId: number;
+}
+interface StartTest {
+    type: "start_test";
+    testId: number;
+    moduleId: number;
+}
+interface EndTest {
+    type: "end_test";
+    testId: number;
+    moduleId: number;
+    startTime: number;
+    endTime: number;
+    assertions: Assertions;
+}
+export type LoggerAction = StartRun | EndRun | CancelRun | StartModule | EndModule | StartTest | EndTest;
+export interface LoggerInterface {
+    readonly failed: boolean;
+    readonly cancelled: boolean;
+    log(testModules: TestModule[], action: LoggerAction): void;
+}
+export {};

package/core/dist/jackrabbit_types.js

@@ -0,0 +1 @@
+export {};

package/core/dist/mod.d.ts

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

package/core/dist/mod.js

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

package/core/dist/run_steps.d.ts

@@ -0,0 +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;