WIP

Author: Hexagon

.gitignore

@@ -130,4 +130,7 @@ dist
 .pnp.*
 
 .npmrc
-.deno.lock
+deno.lock
+bun.lockb
+package.json
+bunfig.toml

README.md

@@ -8,10 +8,15 @@ Truly cross runtime minimal testing framework working in collaboration with @std
 
 ## Install
 
-Example for deno and node
+Node:
 
 ```
 npx jsr add @cross/test @std/assert
+```
+
+Deno:
+
+```
 deno add @cross/test @std/assert
 ```
 
@@ -23,16 +28,32 @@ my.test.js
 import { test } from "@cross/test";
 import { assertEquals, assertNotEquals } from "@std/assert";
 
-test("Addition", {}, () => {
-  assertEquals(2 + 3, 5);
-  assertEquals(10 + -5, 5);
+// Simple test
+test("Multiplication", () => {
+  assertEquals(5 * 4, 20);
 });
 
-test("Multiplication", {}, () => {
-  assertNotEquals(5 * 5, 20);
+// Simple test with timeout
+test("Multiplication with timeout", () => {
+  assertEquals(5 * 4, 20);
+}, { timeout: 1000 });
+
+// Test with done callback (useful for async operations)
+test("Async test", (context, done) => {
+   setTimeout(() => {
+     done(); // Signal test completion
+   }, 500); 
+
+   assertEquals(2 + 2, 4); 
 });
 ```
 
 ## Running the tests
 
-Deno: `deno test` Node: `node --test`
+Node:
+
+`node --test`
+
+Deno:
+
+`deno test`

deno.json

@@ -1,6 +1,6 @@
 {
   "name": "@cross/test",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "exports": "./mod.ts",
   "fmt": {
     "lineWidth": 200

deno.lock

@@ -0,0 +1,20 @@
+import { test } from "./mod.ts";
+import { assertEquals, assertNotEquals, assertThrows } from "@std/assert";
+
+// Simple test
+test("Multiplication", () => {
+  assertEquals(5 * 4, 20);
+});
+
+// Simple test with timeout
+test("Multiplication with timeout", () => {
+  assertEquals(5 * 4, 20);
+}, { timeout: 1000 });
+
+// Test with done callback (useful for async operations)
+test("Async test", (_context, done) => {
+   setTimeout(() => {
+     assertNotEquals(2 + 2, 4); 
+     done(); // Signal test completion
+   }, 500); 
+}, { waitForCallback: true});

mod.test.js

@@ -1,10 +1,15 @@
 import { CurrentRuntime, Runtime } from "@cross/runtime";
 
+/**
+ * Test subject
+ */
+export type TestSubject = (context: unknown | undefined, done: (value?: unknown) => void) => void | Promise<void>;
+
 /**
  * Runtime independent test function
  */
 export interface WrappedTest {
-  (name: string, options: WrappedTestOptions, testFn: () => Promise<void>): Promise<void>;
+  (name: string, testFn: TestSubject, options?: WrappedTestOptions): Promise<void>;
 }
 
 /**
@@ -13,26 +18,31 @@ export interface WrappedTest {
 export interface WrappedTestOptions {
   timeout?: number; // Timeout duration in milliseconds (optional)
   skip?: boolean; // Whether to skip the test (optional)
+  waitForCallback?: boolean; // Whether to wait for the done-callback to be called
 }
 
-let wrappedTestToUse: WrappedTest | undefined;
+let wrappedTestToUse: WrappedTest;
 if (CurrentRuntime == Runtime.Deno) {
-  const { wrappedTest } = await import("./shims/deno.js");
+  const { wrappedTest } = await import("./shims/deno.ts");
   // @ts-ignore js
   wrappedTestToUse = wrappedTest;
 } else if (CurrentRuntime == Runtime.Node) {
-  const { wrappedTest } = await import("./shims/node.js");
+  const { wrappedTest } = await import("./shims/node.ts");
+  // @ts-ignore js
+  wrappedTestToUse = wrappedTest;
+} else if (CurrentRuntime == Runtime.Bun) {
+  const { wrappedTest } = await import("./shims/bun.ts");
   // @ts-ignore js
   wrappedTestToUse = wrappedTest;
 } else {
   throw new Error("Unsupported runtime");
 }
 /**
  * Defines and executes a single test.
- * @param {string} name - The name of the test.
- * @param {any} options - Options for the test (structure depends on your shim)
- * @param {() => Promise<void>} testFn - The function containing the test logic.
+ * @param name - The name of the test.
+ * @param options? - Options for the test (structure depends on your shim)
+ * @param testFn - The function containing the test logic.
  */
-export async function test(name: string, options: WrappedTestOptions, testFn: () => Promise<void>) {
-  if (wrappedTestToUse) await wrappedTestToUse(name, options, testFn);
+export async function test(name: string, testFn: TestSubject, options: WrappedTestOptions = {}) {
+  await wrappedTestToUse(name, testFn, options);
 }

mod.test.ts

@@ -0,0 +1,37 @@
+import { test } from "bun:test";
+import { TestSubject, WrappedTestOptions } from "../mod.ts";
+
+export async function wrappedTest(
+  name: string, 
+  testFn: TestSubject, 
+  options: WrappedTestOptions
+) {
+  return await test(name, async () => { 
+    // Adapt the context here
+    let testFnPromise = undefined;
+    const callbackPromise = new Promise((resolve, reject) => { 
+      testFnPromise = testFn(undefined, (e) => { if (e) { reject(e) } else { resolve(0) }});
+    });
+    let timeoutId: number = -1; // Store the timeout ID
+    try {
+      if (options.timeout) {
+        const timeoutPromise = new Promise((_, reject) => {
+          timeoutId = setTimeout(() => {
+            reject(new Error("Test timed out"));
+          }, options.timeout);
+        });
+        await Promise.race([options.waitForCallback ? callbackPromise : testFnPromise, timeoutPromise]);
+      } else {
+        // No timeout, just await testFn
+        await options.waitForCallback ? callbackPromise : testFnPromise;
+      } 
+    } catch (error) {
+      throw error;
+    } finally {
+      if (timeoutId) clearTimeout(timeoutId); 
+      // Make sure testFnPromise has completed
+      await testFnPromise;
+      if (options.waitForCallback) await callbackPromise;
+    }
+  }); 
+}

mod.ts

@@ -0,0 +1,34 @@
+import { TestSubject, WrappedTestOptions } from "../mod.ts"; // Assuming cross runtime types are here
+
+export function wrappedTest(name: string, testFn: TestSubject, options: WrappedTestOptions) {
+  Deno.test({
+    name,
+    ignore: options?.skip || false,
+    async fn(context) {
+      // Adapt the context here
+      let testFnPromise = undefined;
+      const callbackPromise = new Promise((resolve, reject) => { 
+          testFnPromise = testFn(context, (e) => { if (e) { reject(e) } else { resolve(0) }});
+      });
+      let timeoutId: number = -1; // Store the timeout ID
+      try {
+        if (options.timeout) {
+          const timeoutPromise = new Promise((_, reject) => {
+            timeoutId = setTimeout(() => {
+              reject(new Error("Test timed out"));
+            }, options.timeout);
+          });
+          await Promise.race([options.waitForCallback ? callbackPromise : testFnPromise, timeoutPromise]);
+        } else {
+          await options.waitForCallback ? callbackPromise : testFnPromise;
+        }
+      } catch (error) {
+        throw error;
+      } finally {
+        if (timeoutId) clearTimeout(timeoutId);
+        await testFnPromise;
+        if (options.waitForCallback) await callbackPromise;
+      }
+    },
+  });
+}