fragment-ts 1.0.18 → 1.0.20

package/src/testing/runner.ts

@@ -1,6 +1,6 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { glob } from 'glob';
+import * as fs from "fs";
+import * as path from "path";
+import { glob } from "glob";
 
 /* ======================================================
  * Global augmentation
@@ -8,6 +8,8 @@ import { glob } from 'glob';
 type GlobalWithTestRunner = typeof globalThis & {
   __testRunner?: TestRunner;
   it?: (name: string, fn: () => void | Promise<void>) => void;
+  beforeEach?: (fn: () => void | Promise<void>) => void;
+  afterEach?: (fn: () => void | Promise<void>) => void;
 };
 
 const G = global as GlobalWithTestRunner;
@@ -18,6 +20,8 @@ const G = global as GlobalWithTestRunner;
 export interface TestSuite {
   name: string;
   tests: Test[];
+  beforeEachHooks: Array<() => void | Promise<void>>;
+  afterEachHooks: Array<() => void | Promise<void>>;
 }
 
 export interface Test {
@@ -32,71 +36,212 @@ export class TestRunner {
   private suites: TestSuite[] = [];
   private passed = 0;
   private failed = 0;
+  private errors: Array<{
+    suite: string;
+    test: string;
+    error: string;
+    stack?: string;
+  }> = [];
 
   describe(name: string, fn: () => void): void {
-    const suite: TestSuite = { name, tests: [] };
+    const suite: TestSuite = {
+      name,
+      tests: [],
+      beforeEachHooks: [],
+      afterEachHooks: [],
+    };
+
     this.suites.push(suite);
 
-    const currentSuite = suite;
     const originalIt = G.it;
+    const originalBeforeEach = G.beforeEach;
+    const originalAfterEach = G.afterEach;
 
     G.it = (testName: string, testFn: () => void | Promise<void>) => {
-      currentSuite.tests.push({ name: testName, fn: testFn });
+      suite.tests.push({ name: testName, fn: testFn });
+    };
+
+    G.beforeEach = (hook: () => void | Promise<void>) => {
+      suite.beforeEachHooks.push(hook);
+    };
+
+    G.afterEach = (hook: () => void | Promise<void>) => {
+      suite.afterEachHooks.push(hook);
     };
 
     fn();
 
     G.it = originalIt;
+    G.beforeEach = originalBeforeEach;
+    G.afterEach = originalAfterEach;
   }
 
   async run(): Promise<void> {
-    console.log('\n🧪 Running Fragment Tests\n');
+    console.log("\n🧪 Running Fragment Tests\n");
+
+    if (this.suites.length === 0) {
+      console.log("No test suites found");
+      return;
+    }
 
     for (const suite of this.suites) {
       console.log(`\n📦 ${suite.name}`);
 
+      if (suite.tests.length === 0) {
+        console.log("  (no tests)");
+        continue;
+      }
+
       for (const test of suite.tests) {
         try {
+          // Run beforeEach hooks
+          for (const hook of suite.beforeEachHooks) {
+            await hook();
+          }
+
+          // Run the test
           await test.fn();
+
+          // Run afterEach hooks
+          for (const hook of suite.afterEachHooks) {
+            await hook();
+          }
+
           console.log(`  ✓ ${test.name}`);
           this.passed++;
-        } catch (error) {
+        } catch (error: any) {
           console.log(`  ✗ ${test.name}`);
-          console.error(`    ${error}`);
+          console.error(`    ${error?.message ?? error}`);
           this.failed++;
+          this.errors.push({
+            suite: suite.name,
+            test: test.name,
+            error: error?.message ?? String(error),
+            stack: error?.stack,
+          });
         }
       }
     }
 
+    // Print summary
     console.log(
       `\n\n📊 Results: ${this.passed} passed, ${this.failed} failed\n`,
     );
 
     if (this.failed > 0) {
+      console.log("❌ Failed Tests:\n");
+      this.errors.forEach((err) => {
+        console.log(`  ${err.suite} > ${err.test}`);
+        console.log(`    ${err.error}\n`);
+      });
       process.exit(1);
+    } else {
+      console.log("✅ All tests passed!\n");
+      process.exit(0);
     }
   }
 
   async loadTestFiles(pattern: string): Promise<void> {
-    const files = await glob(pattern);
+    const files = await glob(pattern, { cwd: process.cwd() });
+
+    if (files.length === 0) {
+      console.log(`No test files found matching pattern: ${pattern}`);
+      return;
+    }
+
+    console.log(`Found ${files.length} test file(s)\n`);
+
+    // Set the global runner before loading any files
+    G.__testRunner = this;
 
     for (const file of files) {
-      require(path.resolve(file));
+      const fullPath = path.resolve(file);
+
+      // Clear require cache for this file to allow hot reloading
+      delete require.cache[fullPath];
+
+      try {
+        require(fullPath);
+      } catch (error: any) {
+        console.error(`Error loading test file ${file}:`, error.message);
+        throw error;
+      }
     }
   }
 }
 
+/* ======================================================
+ * Singleton instance
+ * ====================================================== */
+let runnerInstance: TestRunner | null = null;
+
+export function getTestRunner(): TestRunner {
+  if (!runnerInstance) {
+    runnerInstance = new TestRunner();
+    G.__testRunner = runnerInstance;
+  }
+  return runnerInstance;
+}
+
+export function initTestRunner(): TestRunner {
+  return getTestRunner();
+}
+
+/* ======================================================
+ * Auto-initialization for test environment
+ * ====================================================== */
+// Auto-initialize when in test environment
+if (
+  process.env.NODE_ENV === "test" ||
+  process.argv.some((arg) => arg.includes("test"))
+) {
+  if (!G.__testRunner) {
+    getTestRunner();
+  }
+}
+
 /* ======================================================
  * Global test helpers
  * ====================================================== */
 export function describe(name: string, fn: () => void): void {
-  G.__testRunner?.describe(name, fn);
+  if (!G.__testRunner) {
+    // Try to auto-initialize
+    getTestRunner();
+  }
+
+  if (!G.__testRunner) {
+    throw new Error(
+      "TestRunner not initialized. Make sure to call initTestRunner() or run tests via 'fragment test' command",
+    );
+  }
+
+  G.__testRunner.describe(name, fn);
 }
 
 export function it(name: string, fn: () => void | Promise<void>): void {
-  // Implemented dynamically by TestRunner.describe
+  if (!G.it) {
+    throw new Error('"it" must be called inside describe()');
+  }
+  G.it(name, fn);
+}
+
+export function beforeEach(fn: () => void | Promise<void>): void {
+  if (!G.beforeEach) {
+    throw new Error('"beforeEach" must be called inside describe()');
+  }
+  G.beforeEach(fn);
+}
+
+export function afterEach(fn: () => void | Promise<void>): void {
+  if (!G.afterEach) {
+    throw new Error('"afterEach" must be called inside describe()');
+  }
+  G.afterEach(fn);
 }
 
+/* ======================================================
+ * Expect / Assertions
+ * ====================================================== */
 export function expect(actual: any) {
   return {
     toBe(expected: any) {
@@ -104,40 +249,123 @@ export function expect(actual: any) {
         throw new Error(`Expected ${actual} to be ${expected}`);
       }
     },
+
     toEqual(expected: any) {
-      if (JSON.stringify(actual) !== JSON.stringify(expected)) {
-        throw new Error(
-          `Expected ${JSON.stringify(actual)} to equal ${JSON.stringify(expected)}`,
-        );
+      const a = JSON.stringify(actual);
+      const e = JSON.stringify(expected);
+      if (a !== e) {
+        throw new Error(`Expected ${a} to equal ${e}`);
       }
     },
+
     toBeTruthy() {
       if (!actual) {
         throw new Error(`Expected ${actual} to be truthy`);
       }
     },
+
     toBeFalsy() {
       if (actual) {
         throw new Error(`Expected ${actual} to be falsy`);
       }
     },
-    toThrow() {
+
+    toThrow(expectedError?: string) {
+      if (typeof actual !== "function") {
+        throw new Error("toThrow expects a function");
+      }
+
+      let threw = false;
+      let error = null;
       try {
         actual();
-        throw new Error('Expected function to throw');
-      } catch {
-        /* expected */
+      } catch (e: any) {
+        threw = true;
+        error = e;
+      }
+
+      if (!threw) {
+        throw new Error("Expected function to throw an error");
+      }
+
+      if (expectedError && error?.message !== expectedError) {
+        throw new Error(
+          `Expected error message "${expectedError}" but got "${error?.message}"`,
+        );
+      }
+    },
+
+    toBeInstanceOf(expected: any) {
+      if (!(actual instanceof expected)) {
+        throw new Error(`Expected object to be instance of ${expected?.name}`);
+      }
+    },
+
+    toContain(expected: any) {
+      if (!Array.isArray(actual) && typeof actual !== "string") {
+        throw new Error("toContain works only on arrays or strings");
+      }
+
+      if (!actual.includes(expected)) {
+        throw new Error(`Expected ${actual} to contain ${expected}`);
+      }
+    },
+
+    toHaveProperty(property: string, value?: any) {
+      if (actual == null || !(property in actual)) {
+        throw new Error(`Expected object to have property "${property}"`);
+      }
+
+      if (value !== undefined && actual[property] !== value) {
+        throw new Error(
+          `Expected property "${property}" to be ${value} but got ${actual[property]}`,
+        );
+      }
+    },
+
+    toBeNull() {
+      if (actual !== null) {
+        throw new Error(`Expected ${actual} to be null`);
+      }
+    },
+
+    toBeUndefined() {
+      if (actual !== undefined) {
+        throw new Error(`Expected ${actual} to be undefined`);
+      }
+    },
+
+    toHaveLength(expected: number) {
+      if (actual == null || typeof actual.length !== "number") {
+        throw new Error("toHaveLength works only on arrays or strings");
+      }
+
+      if (actual.length !== expected) {
+        throw new Error(`Expected length ${expected}, got ${actual.length}`);
       }
     },
   };
 }
 
 /* ======================================================
- * CLI entry
+ * CLI entry (when this file is run directly)
  * ====================================================== */
 if (require.main === module) {
-  const runner = new TestRunner();
-  G.__testRunner = runner;
+  (async () => {
+    try {
+      const runner = getTestRunner();
+
+      // Auto-detect TypeScript based on arguments
+      const isTsNode = process.argv.some(
+        (arg) => arg.includes("ts-node") || arg.includes("ts-node/register"),
+      );
+      const pattern = isTsNode ? "src/**/*.spec.ts" : "dist/**/*.spec.js";
 
-  runner.loadTestFiles('dist/**/*.spec.js').then(() => runner.run());
+      await runner.loadTestFiles(pattern);
+      await runner.run();
+    } catch (err: any) {
+      console.error("Failed to run tests:", err.message);
+      process.exit(1);
+    }
+  })();
 }

package/src/web/application.ts

@@ -20,6 +20,7 @@ export class FragmentWebApplication {
     this.container = DIContainer.getInstance();
     this.metadataStorage = MetadataStorage.getInstance();
     this.setupMiddleware();
+    this
   }
 
   private setupMiddleware(): void {