@ricsam/isolate-test-environment 0.1.4 → 0.1.6

package/dist/cjs/index.cjs

@@ -1,8 +1,21 @@
 // @bun @bun-cjs
-(function(exports, require, module, __filename, __dirname) {var __defProp = Object.defineProperty;
+(function(exports, require, module, __filename, __dirname) {var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
 var __moduleCache = /* @__PURE__ */ new WeakMap;
 var __toCommonJS = (from) => {
   var entry = __moduleCache.get(from), desc;
@@ -31,9 +44,12 @@ var __export = (target, all) => {
 var exports_src = {};
 __export(exports_src, {
   setupTestEnvironment: () => setupTestEnvironment,
-  runTests: () => runTests
+  runTests: () => runTests,
+  hasTests: () => hasTests,
+  getTestCount: () => getTestCount
 });
 module.exports = __toCommonJS(exports_src);
+var import_isolated_vm = __toESM(require("isolated-vm"));
 var testEnvironmentCode = `
 (function() {
   // ============================================================
@@ -58,6 +74,33 @@ var testEnvironmentCode = `
   let currentSuite = rootSuite;
   const suiteStack = [rootSuite];
 
+  // Event callback (set from host)
+  let eventCallback = null;
+
+  function emitEvent(event) {
+    if (eventCallback) {
+      try {
+        eventCallback(JSON.stringify(event));
+      } catch (e) {
+        // Ignore callback errors
+      }
+    }
+  }
+
+  // ============================================================
+  // TestError class for rich error info
+  // ============================================================
+
+  class TestError extends Error {
+    constructor(message, matcherName, expected, actual) {
+      super(message);
+      this.name = 'TestError';
+      this.matcherName = matcherName;
+      this.expected = expected;
+      this.actual = actual;
+    }
+  }
+
   // ============================================================
   // Deep Equality Helper
   // ============================================================
@@ -157,10 +200,10 @@ var testEnvironmentCode = `
 
   function expect(actual) {
     function createMatchers(negated = false) {
-      const assert = (condition, message) => {
+      const assert = (condition, message, matcherName, expected) => {
         const pass = negated ? !condition : condition;
         if (!pass) {
-          throw new Error(message);
+          throw new TestError(message, matcherName, expected, actual);
         }
       };
 
@@ -170,7 +213,9 @@ var testEnvironmentCode = `
             actual === expected,
             negated
               ? \`Expected \${formatValue(actual)} not to be \${formatValue(expected)}\`
-              : \`Expected \${formatValue(actual)} to be \${formatValue(expected)}\`
+              : \`Expected \${formatValue(actual)} to be \${formatValue(expected)}\`,
+            'toBe',
+            expected
           );
         },
 
@@ -179,7 +224,9 @@ var testEnvironmentCode = `
             deepEqual(actual, expected),
             negated
               ? \`Expected \${formatValue(actual)} not to equal \${formatValue(expected)}\`
-              : \`Expected \${formatValue(actual)} to equal \${formatValue(expected)}\`
+              : \`Expected \${formatValue(actual)} to equal \${formatValue(expected)}\`,
+            'toEqual',
+            expected
           );
         },
 
@@ -188,7 +235,9 @@ var testEnvironmentCode = `
             strictDeepEqual(actual, expected),
             negated
               ? \`Expected \${formatValue(actual)} not to strictly equal \${formatValue(expected)}\`
-              : \`Expected \${formatValue(actual)} to strictly equal \${formatValue(expected)}\`
+              : \`Expected \${formatValue(actual)} to strictly equal \${formatValue(expected)}\`,
+            'toStrictEqual',
+            expected
           );
         },
 
@@ -197,7 +246,9 @@ var testEnvironmentCode = `
             !!actual,
             negated
               ? \`Expected \${formatValue(actual)} not to be truthy\`
-              : \`Expected \${formatValue(actual)} to be truthy\`
+              : \`Expected \${formatValue(actual)} to be truthy\`,
+            'toBeTruthy',
+            true
           );
         },
 
@@ -206,7 +257,9 @@ var testEnvironmentCode = `
             !actual,
             negated
               ? \`Expected \${formatValue(actual)} not to be falsy\`
-              : \`Expected \${formatValue(actual)} to be falsy\`
+              : \`Expected \${formatValue(actual)} to be falsy\`,
+            'toBeFalsy',
+            false
           );
         },
 
@@ -215,7 +268,9 @@ var testEnvironmentCode = `
             actual === null,
             negated
               ? \`Expected \${formatValue(actual)} not to be null\`
-              : \`Expected \${formatValue(actual)} to be null\`
+              : \`Expected \${formatValue(actual)} to be null\`,
+            'toBeNull',
+            null
           );
         },
 
@@ -224,7 +279,9 @@ var testEnvironmentCode = `
             actual === undefined,
             negated
               ? \`Expected \${formatValue(actual)} not to be undefined\`
-              : \`Expected \${formatValue(actual)} to be undefined\`
+              : \`Expected \${formatValue(actual)} to be undefined\`,
+            'toBeUndefined',
+            undefined
           );
         },
 
@@ -233,7 +290,9 @@ var testEnvironmentCode = `
             actual !== undefined,
             negated
               ? \`Expected \${formatValue(actual)} not to be defined\`
-              : \`Expected \${formatValue(actual)} to be defined\`
+              : \`Expected \${formatValue(actual)} to be defined\`,
+            'toBeDefined',
+            'defined'
           );
         },
 
@@ -248,7 +307,9 @@ var testEnvironmentCode = `
             contains,
             negated
               ? \`Expected \${formatValue(actual)} not to contain \${formatValue(item)}\`
-              : \`Expected \${formatValue(actual)} to contain \${formatValue(item)}\`
+              : \`Expected \${formatValue(actual)} to contain \${formatValue(item)}\`,
+            'toContain',
+            item
           );
         },
 
@@ -276,14 +337,18 @@ var testEnvironmentCode = `
               matches,
               negated
                 ? \`Expected function not to throw \${formatValue(expected)}\`
-                : \`Expected function to throw \${formatValue(expected)}, but \${threw ? \`threw: \${error.message}\` : 'did not throw'}\`
+                : \`Expected function to throw \${formatValue(expected)}, but \${threw ? \`threw: \${error.message}\` : 'did not throw'}\`,
+              'toThrow',
+              expected
             );
           } else {
             assert(
               threw,
               negated
                 ? \`Expected function not to throw\`
-                : \`Expected function to throw\`
+                : \`Expected function to throw\`,
+              'toThrow',
+              'any error'
             );
           }
         },
@@ -293,7 +358,9 @@ var testEnvironmentCode = `
             actual instanceof cls,
             negated
               ? \`Expected \${formatValue(actual)} not to be instance of \${cls.name || cls}\`
-              : \`Expected \${formatValue(actual)} to be instance of \${cls.name || cls}\`
+              : \`Expected \${formatValue(actual)} to be instance of \${cls.name || cls}\`,
+            'toBeInstanceOf',
+            cls.name || cls
           );
         },
 
@@ -303,7 +370,9 @@ var testEnvironmentCode = `
             actualLength === length,
             negated
               ? \`Expected length not to be \${length}, but got \${actualLength}\`
-              : \`Expected length to be \${length}, but got \${actualLength}\`
+              : \`Expected length to be \${length}, but got \${actualLength}\`,
+            'toHaveLength',
+            length
           );
         },
 
@@ -318,7 +387,9 @@ var testEnvironmentCode = `
             matches,
             negated
               ? \`Expected \${formatValue(actual)} not to match \${pattern}\`
-              : \`Expected \${formatValue(actual)} to match \${pattern}\`
+              : \`Expected \${formatValue(actual)} to match \${pattern}\`,
+            'toMatch',
+            pattern
           );
         },
 
@@ -331,7 +402,53 @@ var testEnvironmentCode = `
             hasProperty && valueMatches,
             negated
               ? \`Expected \${formatValue(actual)} not to have property \${path}\${arguments.length >= 2 ? \` with value \${formatValue(value)}\` : ''}\`
-              : \`Expected \${formatValue(actual)} to have property \${path}\${arguments.length >= 2 ? \` with value \${formatValue(value)}\` : ''}\`
+              : \`Expected \${formatValue(actual)} to have property \${path}\${arguments.length >= 2 ? \` with value \${formatValue(value)}\` : ''}\`,
+            'toHaveProperty',
+            arguments.length >= 2 ? { path, value } : { path }
+          );
+        },
+
+        toBeGreaterThan(expected) {
+          assert(
+            actual > expected,
+            negated
+              ? \`Expected \${formatValue(actual)} not to be greater than \${formatValue(expected)}\`
+              : \`Expected \${formatValue(actual)} to be greater than \${formatValue(expected)}\`,
+            'toBeGreaterThan',
+            expected
+          );
+        },
+
+        toBeGreaterThanOrEqual(expected) {
+          assert(
+            actual >= expected,
+            negated
+              ? \`Expected \${formatValue(actual)} not to be greater than or equal to \${formatValue(expected)}\`
+              : \`Expected \${formatValue(actual)} to be greater than or equal to \${formatValue(expected)}\`,
+            'toBeGreaterThanOrEqual',
+            expected
+          );
+        },
+
+        toBeLessThan(expected) {
+          assert(
+            actual < expected,
+            negated
+              ? \`Expected \${formatValue(actual)} not to be less than \${formatValue(expected)}\`
+              : \`Expected \${formatValue(actual)} to be less than \${formatValue(expected)}\`,
+            'toBeLessThan',
+            expected
+          );
+        },
+
+        toBeLessThanOrEqual(expected) {
+          assert(
+            actual <= expected,
+            negated
+              ? \`Expected \${formatValue(actual)} not to be less than or equal to \${formatValue(expected)}\`
+              : \`Expected \${formatValue(actual)} to be less than or equal to \${formatValue(expected)}\`,
+            'toBeLessThanOrEqual',
+            expected
           );
         },
       };
@@ -454,7 +571,7 @@ var testEnvironmentCode = `
   }
 
   // ============================================================
-  // Test Runner
+  // Test Runner Helpers
   // ============================================================
 
   function checkForOnly(suite) {
@@ -479,120 +596,273 @@ var testEnvironmentCode = `
     return false;
   }
 
+  function countTests(suite, hasOnly) {
+    let count = 0;
+    if (hasOnly && !suiteHasOnly(suite)) return 0;
+    if (suite.skip) return suite.tests.length;
+
+    for (const t of suite.tests) {
+      if (hasOnly && !t.only && !suite.only) continue;
+      count++;
+    }
+    for (const child of suite.children) {
+      count += countTests(child, hasOnly);
+    }
+    return count;
+  }
+
+  function countSuites(suite, hasOnly) {
+    let count = 0;
+    if (hasOnly && !suiteHasOnly(suite)) return 0;
+
+    for (const child of suite.children) {
+      count++;
+      count += countSuites(child, hasOnly);
+    }
+    return count;
+  }
+
+  // ============================================================
+  // Test Runner
+  // ============================================================
+
   async function __runAllTests() {
-    const results = [];
+    const testResults = [];
+    const suiteResults = [];
     const hasOnly = checkForOnly(rootSuite);
+    const runStart = Date.now();
+
+    // Emit runStart
+    const testCount = countTests(rootSuite, hasOnly);
+    const suiteCount = countSuites(rootSuite, hasOnly);
+    emitEvent({ type: 'runStart', testCount, suiteCount });
 
-    async function runSuite(suite, parentHooks, namePath) {
+    async function runSuite(suite, parentHooks, pathArray, depth) {
       // Skip if this suite doesn't have any .only when .only exists elsewhere
       if (hasOnly && !suiteHasOnly(suite)) return;
 
+      const suitePath = [...pathArray];
+      const fullName = suitePath.join(' > ');
+      const suiteInfo = {
+        name: suite.name,
+        path: suitePath.slice(0, -1),
+        fullName,
+        depth,
+      };
+
+      // Emit suiteStart (only for non-root suites)
+      if (suite !== rootSuite) {
+        emitEvent({ type: 'suiteStart', suite: suiteInfo });
+      }
+
+      const suiteStart = Date.now();
+      let suitePassed = 0;
+      let suiteFailed = 0;
+      let suiteSkipped = 0;
+      let suiteTodo = 0;
+
       // Skip if suite is marked as skip
       if (suite.skip) {
         // Mark all tests in this suite as skipped
         for (const t of suite.tests) {
-          results.push({
-            name: namePath ? namePath + ' > ' + t.name : t.name,
-            passed: true,
-            skipped: true,
+          const testFullName = fullName ? fullName + ' > ' + t.name : t.name;
+          const testInfo = {
+            name: t.name,
+            suitePath: suitePath,
+            fullName: testFullName,
+          };
+          emitEvent({ type: 'testStart', test: testInfo });
+
+          const testResult = {
+            name: t.name,
+            suitePath: suitePath,
+            fullName: testFullName,
+            status: 'skip',
             duration: 0,
-          });
-        }
-        return;
-      }
-
-      // Run beforeAll hooks
-      for (const hook of suite.beforeAll) {
-        await hook();
-      }
-
-      // Run tests
-      for (const t of suite.tests) {
-        const testName = namePath ? namePath + ' > ' + t.name : t.name;
+          };
+          testResults.push(testResult);
+          suiteSkipped++;
 
-        // Skip if .only is used and this test isn't .only AND the suite doesn't have .only
-        if (hasOnly && !t.only && !suite.only) continue;
-
-        // Skip if test is marked as skip
-        if (t.skip) {
-          results.push({
-            name: testName,
-            passed: true,
-            skipped: true,
-            duration: 0,
-          });
-          continue;
+          emitEvent({ type: 'testEnd', test: testResult });
         }
-
-        // Handle todo tests (no function provided)
-        if (t.todo) {
-          results.push({
-            name: testName,
-            passed: true,
-            skipped: true,
-            duration: 0,
-          });
-          continue;
+      } else {
+        // Run beforeAll hooks
+        for (const hook of suite.beforeAll) {
+          await hook();
         }
 
-        const start = Date.now();
-        try {
-          // Run all beforeEach hooks (parent first, then current)
-          for (const hook of [...parentHooks.beforeEach, ...suite.beforeEach]) {
-            await hook();
+        // Run tests
+        for (const t of suite.tests) {
+          const testFullName = fullName ? fullName + ' > ' + t.name : t.name;
+          const testInfo = {
+            name: t.name,
+            suitePath: suitePath,
+            fullName: testFullName,
+          };
+
+          // Skip if .only is used and this test isn't .only AND the suite doesn't have .only
+          if (hasOnly && !t.only && !suite.only) continue;
+
+          emitEvent({ type: 'testStart', test: testInfo });
+
+          // Skip if test is marked as skip
+          if (t.skip) {
+            const testResult = {
+              name: t.name,
+              suitePath: suitePath,
+              fullName: testFullName,
+              status: 'skip',
+              duration: 0,
+            };
+            testResults.push(testResult);
+            suiteSkipped++;
+            emitEvent({ type: 'testEnd', test: testResult });
+            continue;
           }
 
-          // Run test
-          await t.fn();
+          // Handle todo tests (no function provided)
+          if (t.todo) {
+            const testResult = {
+              name: t.name,
+              suitePath: suitePath,
+              fullName: testFullName,
+              status: 'todo',
+              duration: 0,
+            };
+            testResults.push(testResult);
+            suiteTodo++;
+            emitEvent({ type: 'testEnd', test: testResult });
+            continue;
+          }
 
-          // Run all afterEach hooks (current first, then parent)
-          for (const hook of [...suite.afterEach, ...parentHooks.afterEach]) {
-            await hook();
+          const testStart = Date.now();
+          try {
+            // Run all beforeEach hooks (parent first, then current)
+            for (const hook of [...parentHooks.beforeEach, ...suite.beforeEach]) {
+              await hook();
+            }
+
+            // Run test
+            await t.fn();
+
+            // Run all afterEach hooks (current first, then parent)
+            for (const hook of [...suite.afterEach, ...parentHooks.afterEach]) {
+              await hook();
+            }
+
+            const testResult = {
+              name: t.name,
+              suitePath: suitePath,
+              fullName: testFullName,
+              status: 'pass',
+              duration: Date.now() - testStart,
+            };
+            testResults.push(testResult);
+            suitePassed++;
+            emitEvent({ type: 'testEnd', test: testResult });
+          } catch (err) {
+            const testError = {
+              message: err.message || String(err),
+              stack: err.stack,
+            };
+            // If it's a TestError, include matcher info
+            if (err.matcherName !== undefined) {
+              testError.matcherName = err.matcherName;
+              testError.expected = err.expected;
+              testError.actual = err.actual;
+            }
+            const testResult = {
+              name: t.name,
+              suitePath: suitePath,
+              fullName: testFullName,
+              status: 'fail',
+              duration: Date.now() - testStart,
+              error: testError,
+            };
+            testResults.push(testResult);
+            suiteFailed++;
+            emitEvent({ type: 'testEnd', test: testResult });
           }
+        }
 
-          results.push({
-            name: testName,
-            passed: true,
-            duration: Date.now() - start,
-          });
-        } catch (err) {
-          results.push({
-            name: testName,
-            passed: false,
-            error: err.message || String(err),
-            duration: Date.now() - start,
-          });
+        // Run child suites
+        for (const child of suite.children) {
+          const childPath = [...suitePath, child.name];
+          await runSuite(child, {
+            beforeEach: [...parentHooks.beforeEach, ...suite.beforeEach],
+            afterEach: [...suite.afterEach, ...parentHooks.afterEach],
+          }, childPath, depth + 1);
         }
-      }
 
-      // Run child suites
-      for (const child of suite.children) {
-        const childPath = namePath ? namePath + ' > ' + child.name : child.name;
-        await runSuite(child, {
-          beforeEach: [...parentHooks.beforeEach, ...suite.beforeEach],
-          afterEach: [...suite.afterEach, ...parentHooks.afterEach],
-        }, childPath);
+        // Run afterAll hooks
+        for (const hook of suite.afterAll) {
+          await hook();
+        }
       }
 
-      // Run afterAll hooks
-      for (const hook of suite.afterAll) {
-        await hook();
+      // Emit suiteEnd (only for non-root suites)
+      if (suite !== rootSuite) {
+        const suiteResult = {
+          ...suiteInfo,
+          passed: suitePassed,
+          failed: suiteFailed,
+          skipped: suiteSkipped,
+          todo: suiteTodo,
+          duration: Date.now() - suiteStart,
+        };
+        suiteResults.push(suiteResult);
+        emitEvent({ type: 'suiteEnd', suite: suiteResult });
       }
     }
 
-    await runSuite(rootSuite, { beforeEach: [], afterEach: [] }, '');
+    await runSuite(rootSuite, { beforeEach: [], afterEach: [] }, [], -1);
 
-    const passed = results.filter(r => r.passed && !r.skipped).length;
-    const failed = results.filter(r => !r.passed).length;
-    const skipped = results.filter(r => r.skipped).length;
+    const passed = testResults.filter(r => r.status === 'pass').length;
+    const failed = testResults.filter(r => r.status === 'fail').length;
+    const skipped = testResults.filter(r => r.status === 'skip').length;
+    const todo = testResults.filter(r => r.status === 'todo').length;
 
-    return JSON.stringify({
+    const runResults = {
       passed,
       failed,
       skipped,
-      total: results.length,
-      results,
-    });
+      todo,
+      total: testResults.length,
+      duration: Date.now() - runStart,
+      success: failed === 0,
+      suites: suiteResults,
+      tests: testResults,
+    };
+
+    emitEvent({ type: 'runEnd', results: runResults });
+
+    return JSON.stringify(runResults);
+  }
+
+  // ============================================================
+  // Helper Functions
+  // ============================================================
+
+  function __hasTests() {
+    function checkSuite(suite) {
+      if (suite.tests.length > 0) return true;
+      for (const child of suite.children) {
+        if (checkSuite(child)) return true;
+      }
+      return false;
+    }
+    return checkSuite(rootSuite);
+  }
+
+  function __getTestCount() {
+    function countInSuite(suite) {
+      let count = suite.tests.length;
+      for (const child of suite.children) {
+        count += countInSuite(child);
+      }
+      return count;
+    }
+    return countInSuite(rootSuite);
   }
 
   // Reset function to clear state between runs
@@ -608,6 +878,10 @@ var testEnvironmentCode = `
     suiteStack.push(rootSuite);
   }
 
+  function __setEventCallback(callback) {
+    eventCallback = callback;
+  }
+
   // ============================================================
   // Expose Globals
   // ============================================================
@@ -622,10 +896,28 @@ var testEnvironmentCode = `
   globalThis.afterAll = afterAll;
   globalThis.__runAllTests = __runAllTests;
   globalThis.__resetTestEnvironment = __resetTestEnvironment;
+  globalThis.__hasTests = __hasTests;
+  globalThis.__getTestCount = __getTestCount;
+  globalThis.__setEventCallback = __setEventCallback;
 })();
 `;
-async function setupTestEnvironment(context) {
+async function setupTestEnvironment(context, options) {
   context.evalSync(testEnvironmentCode);
+  if (options?.onEvent) {
+    const eventCallbackRef = new import_isolated_vm.default.Reference((eventJson) => {
+      try {
+        const event = JSON.parse(eventJson);
+        options.onEvent(event);
+      } catch {}
+    });
+    const global = context.global;
+    global.setSync("__eventCallbackRef", eventCallbackRef);
+    context.evalSync(`
+      __setEventCallback((eventJson) => {
+        __eventCallbackRef.applySync(undefined, [eventJson]);
+      });
+    `);
+  }
   return {
     dispose() {
       try {
@@ -638,6 +930,12 @@ async function runTests(context) {
   const resultJson = await context.eval("__runAllTests()", { promise: true });
   return JSON.parse(resultJson);
 }
+function hasTests(context) {
+  return context.evalSync("__hasTests()");
+}
+function getTestCount(context) {
+  return context.evalSync("__getTestCount()");
+}
 })
 
-//# debugId=AE2FFE17A1C19B3664756E2164756E21
+//# debugId=424CE17957C8217764756E2164756E21