fragment-ts 1.0.19 → 1.0.21

package/src/cli/commands/test.command.ts

@@ -3,6 +3,7 @@ import chalk from "chalk";
 import * as path from "path";
 import { spawn } from "child_process";
 import * as fs from "fs";
+import chokidar from "chokidar";
 
 export class TestCommand {
   static register(program: Command): void {
@@ -17,6 +18,7 @@ export class TestCommand {
       )
       .option("--pattern <pattern>", "Test file pattern", "**/*.spec.ts")
       .option("--coverage", "Generate coverage report")
+      .option("--no-color", "Disable colored output")
       .action(async (options) => {
         await this.runTests(options);
       });
@@ -57,7 +59,7 @@ export class TestCommand {
       useTypeScript = false;
       mode = "production (dist/)";
       basePath = "dist";
-      pattern = options.pattern.replace(".ts", ".js") || "**/*.spec.js";
+      pattern = options.pattern.replace(/\.ts$/, ".js") || "**/*.spec.js";
     } else {
       // Auto-detect
       if (hasSource) {
@@ -69,7 +71,7 @@ export class TestCommand {
         useTypeScript = false;
         mode = "auto-detected production (dist/)";
         basePath = "dist";
-        pattern = options.pattern.replace(".ts", ".js") || "**/*.spec.js";
+        pattern = options.pattern.replace(/\.ts$/, ".js") || "**/*.spec.js";
       } else {
         console.log(
           chalk.red("No src/ or dist/ directory found. Run: fragment init"),
@@ -78,212 +80,203 @@ export class TestCommand {
       }
     }
 
-    console.log(chalk.gray(`   Mode: ${mode}\n`));
+    console.log(chalk.gray(`   Mode: ${mode}`));
+    console.log(chalk.gray(`   Pattern: ${basePath}/${pattern}`));
 
-    const scriptContent = `
-${useTypeScript ? "require('ts-node/register/transpile-only');" : ""}
-require('reflect-metadata');
+    // Check if we need to use ts-node for TypeScript files
+    const tsConfigPath = path.join(cwd, "tsconfig.json");
+    const hasTsConfig = fs.existsSync(tsConfigPath);
 
-const { glob } = require('glob');
-const path = require('path');
-
-// Global test state
-const testState = {
-  suites: [],
-  currentSuite: null,
-  passed: 0,
-  failed: 0,
-  errors: []
-};
-
-// Global test functions
-global.describe = function(name, fn) {
-  const suite = { name, tests: [] };
-  testState.suites.push(suite);
-  testState.currentSuite = suite;
-  fn();
-  testState.currentSuite = null;
-};
-
-global.it = function(name, fn) {
-  if (!testState.currentSuite) {
-    throw new Error('it() must be called inside describe()');
-  }
-  testState.currentSuite.tests.push({ name, fn });
-};
-
-global.expect = function(actual) {
-  return {
-    toBe(expected) {
-      if (actual !== expected) {
-        throw new Error(\`Expected \${actual} to be \${expected}\`);
-      }
-    },
-    toEqual(expected) {
-      if (JSON.stringify(actual) !== JSON.stringify(expected)) {
-        throw new Error(\`Expected \${JSON.stringify(actual)} to equal \${JSON.stringify(expected)}\`);
-      }
-    },
-    toBeTruthy() {
-      if (!actual) {
-        throw new Error(\`Expected \${actual} to be truthy\`);
-      }
-    },
-    toBeFalsy() {
-      if (actual) {
-        throw new Error(\`Expected \${actual} to be falsy\`);
-      }
-    },
-    toThrow(expectedError) {
-      let threw = false;
-      let error = null;
-      try {
-        actual();
-      } catch (e) {
-        threw = true;
-        error = e;
-      }
-      if (!threw) {
-        throw new Error('Expected function to throw');
-      }
-      if (expectedError && error.message !== expectedError) {
-        throw new Error(\`Expected error message "\${expectedError}" but got "\${error.message}"\`);
-      }
-    },
-    toBeInstanceOf(expected) {
-      if (!(actual instanceof expected)) {
-        throw new Error(\`Expected \${actual} to be instance of \${expected.name}\`);
-      }
-    },
-    toContain(expected) {
-      if (!actual.includes(expected)) {
-        throw new Error(\`Expected \${actual} to contain \${expected}\`);
-      }
-    },
-    toHaveProperty(property, value) {
-      if (!(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) {
-      if (actual.length !== expected) {
-        throw new Error(\`Expected length \${expected} but got \${actual.length}\`);
-      }
-    }
-  };
-};
+    // Create a simple runner script that uses our test runner module
+    const scriptContent = this.generateRunnerScript({
+      useTypeScript,
+      basePath,
+      pattern,
+      hasTsConfig,
+      tsConfigPath,
+      watchMode: options.watch,
+      coverage: options.coverage,
+      noColor: options.color === false,
+    });
 
-async function runTests() {
-  try {
-    // Find and load test files
-    const files = await glob('${basePath}/${pattern}', { cwd: process.cwd() });
-    
-    if (files.length === 0) {
-      console.log('No test files found matching pattern: ${basePath}/${pattern}');
-      process.exit(0);
-    }
+    const scriptPath = path.join(cwd, ".fragment-test-runner.js");
 
-    console.log(\`Found \${files.length} test file(s)\\n\`);
+    try {
+      fs.writeFileSync(scriptPath, scriptContent);
+      fs.chmodSync(scriptPath, "755");
 
-    // Load all test files
-    for (const file of files) {
-      require(path.resolve(file));
-    }
+      // -----------------------
+      // Watch / Coverage / Single Run
+      // -----------------------
+      if (options.watch) {
+        console.log(
+          chalk.green("\n👀 Watch mode enabled. Listening for changes...\n"),
+        );
+
+        const watcher = chokidar.watch(
+          `${basePath}/**/*.spec.${useTypeScript ? "ts" : "js"}`,
+          {
+            ignoreInitial: true,
+          },
+        );
+
+        const runTests = () => {
+          const proc = spawn("node", [scriptPath], { stdio: "inherit" });
 
-    // Run all tests
-    for (const suite of testState.suites) {
-      console.log(\`\\n📦 \${suite.name}\`);
-
-      for (const test of suite.tests) {
-        try {
-          await test.fn();
-          console.log(\`  ✓ \${test.name}\`);
-          testState.passed++;
-        } catch (error) {
-          console.log(\`  ✗ \${test.name}\`);
-          console.error(\`    \${error.message}\`);
-          testState.failed++;
-          testState.errors.push({
-            suite: suite.name,
-            test: test.name,
-            error: error.message,
-            stack: error.stack
+          proc.on("close", (code) => {
+            if (code !== 0)
+              console.log(chalk.red(`Test run exited with code ${code}`));
           });
-        }
-      }
-    }
+        };
 
-    // Print summary
-    console.log(\`\\n\\n📊 Results: \${testState.passed} passed, \${testState.failed} failed\\n\`);
+        runTests(); // Initial run
 
-    if (testState.failed > 0) {
-      console.log('\\n❌ Failed Tests:\\n');
-      testState.errors.forEach(err => {
-        console.log(\`  \${err.suite} > \${err.test}\`);
-        console.log(\`    \${err.error}\\n\`);
-      });
+        watcher.on("all", (event, pathChanged) => {
+          console.log(
+            chalk.blue(`\n🔄 File changed (${event}): ${pathChanged}`),
+          );
+          runTests();
+        });
+      } else if (options.coverage) {
+        console.log(
+          chalk.green(
+            "\n📊 Coverage enabled. Running tests with coverage...\n",
+          ),
+        );
+
+        const proc = spawn(
+          "npx",
+          ["c8", "--reporter=lcov", "--reporter=text", "node", scriptPath],
+          { stdio: "inherit" },
+        );
+
+        proc.on("close", (code) => process.exit(code || 0));
+        proc.on("error", (err) => {
+          console.error(chalk.red("Failed to run coverage:"), err);
+          process.exit(1);
+        });
+      } else {
+        const proc = spawn("node", [scriptPath], { stdio: "inherit" });
+
+        proc.on("close", (code) => process.exit(code || 0));
+        proc.on("error", (err) => {
+          console.error(chalk.red("Failed to run tests:"), err);
+          process.exit(1);
+        });
+      }
+    } catch (error: any) {
+      console.error(chalk.red("Failed to create test runner:"), error.message);
       process.exit(1);
-    } else {
-      console.log('✅ All tests passed!\\n');
-      process.exit(0);
     }
-  } catch (error) {
-    console.error('Error running tests:', error);
-    process.exit(1);
   }
-}
 
-runTests();
-`;
+  private static generateRunnerScript(options: {
+    useTypeScript: boolean;
+    basePath: string;
+    pattern: string;
+    hasTsConfig: boolean;
+    tsConfigPath: string;
+    watchMode: boolean;
+    coverage: boolean;
+    noColor: boolean;
+  }): string {
+    const {
+      useTypeScript,
+      basePath,
+      pattern,
+      hasTsConfig,
+      tsConfigPath,
+      noColor,
+    } = options;
 
-    const scriptPath = path.join(cwd, ".fragment-test-runner.js");
+    let runnerImportPath = "fragment-ts";
 
-    try {
-      fs.writeFileSync(scriptPath, scriptContent);
+    const possiblePaths = [
+      path.join(process.cwd(), "node_modules", "fragment-ts", "testing"),
+      path.join(
+        process.cwd(),
+        "node_modules",
+        "fragment-ts",
+        "dist",
+        "testing",
+      ),
+      path.join(__dirname, "..", "..", "testing"),
+    ];
 
-      const nodeArgs = [scriptPath];
-      const env = {
-        ...process.env,
-        TS_NODE_TRANSPILE_ONLY: "true",
-        NODE_ENV: "test",
-      };
-
-      const proc = spawn("node", nodeArgs, {
-        cwd,
-        stdio: "inherit",
-        env,
-      });
+    let resolvedRunnerPath = runnerImportPath;
+    for (const testPath of possiblePaths) {
+      if (fs.existsSync(testPath + ".ts") || fs.existsSync(testPath + ".js")) {
+        resolvedRunnerPath = testPath;
+        break;
+      }
+    }
 
-      proc.on("close", (code) => {
-        try {
-          fs.unlinkSync(scriptPath);
-        } catch {}
-        process.exit(code || 0);
-      });
+    return `
+"use strict";
 
-      proc.on("error", (error) => {
-        console.error(chalk.red("Failed to run tests:"), error);
-        try {
-          fs.unlinkSync(scriptPath);
-        } catch {}
-        process.exit(1);
-      });
-    } catch (error: any) {
-      console.error(chalk.red("Failed to create test runner:"), error.message);
-      process.exit(1);
+${useTypeScript ? "require('ts-node/register/transpile-only');" : ""}
+require('reflect-metadata');
+
+process.env.NODE_ENV = 'test';
+${noColor ? "process.env.FORCE_COLOR = '0';" : "process.env.FORCE_COLOR = '1';"}
+
+${
+  hasTsConfig && useTypeScript
+    ? `
+try {
+  const tsNode = require('ts-node');
+  tsNode.register({
+    project: '${tsConfigPath}',
+    transpileOnly: true,
+    compilerOptions: {
+      module: 'commonjs',
+      target: 'ES2020',
+      esModuleInterop: true,
+      skipLibCheck: true
     }
+  });
+} catch (error) {}`
+    : ""
+}
+
+let testRunner;
+try {
+  const testModule = require('${resolvedRunnerPath}');
+
+  if (testModule.getTestRunner) {
+    testRunner = testModule.getTestRunner();
+  } else if (testModule.TestRunner) {
+    testRunner = new testModule.TestRunner();
+  } else if (testModule.default && testModule.default.getTestRunner) {
+    testRunner = testModule.default.getTestRunner();
+  } else {
+    testRunner = testModule;
+  }
+} catch (error) {
+  console.error('Failed to load test runner:', error.message);
+  console.error('Make sure fragment-ts is installed as a dependency');
+  process.exit(1);
+}
+
+async function runTests() {
+  try {
+    console.log('Looking for test files...');
+    await testRunner.loadTestFiles('${basePath}/${pattern}');
+    await testRunner.run();
+  } catch (error) {
+    console.error('\\n❌ Error running tests:', error.message);
+    if (error.stack && process.env.DEBUG) console.error(error.stack);
+    process.exit(1);
+  }
+}
+
+process.on('SIGINT', () => { console.log('\\n\\nTest run interrupted'); process.exit(130); });
+process.on('SIGTERM', () => { console.log('\\n\\nTest run terminated'); process.exit(143); });
+
+runTests().catch(error => {
+  console.error('Unhandled error:', error);
+  process.exit(1);
+});
+`;
   }
-}
+}

package/src/testing/runner.ts

@@ -36,6 +36,12 @@ 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 = {
@@ -71,56 +77,144 @@ export class TestRunner {
   }
 
   async run(): Promise<void> {
-    console.log("\nRunning 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(`\nSuite: ${suite.name}`);
+      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(`  PASS ${test.name}`);
+          console.log(`  ✓ ${test.name}`);
           this.passed++;
         } catch (error: any) {
-          console.log(`  FAIL ${test.name}`);
+          console.log(`  ✗ ${test.name}`);
           console.error(`    ${error?.message ?? error}`);
           this.failed++;
+          this.errors.push({
+            suite: suite.name,
+            test: test.name,
+            error: error?.message ?? String(error),
+            stack: error?.stack,
+          });
         }
       }
     }
 
-    console.log(`\nResults: ${this.passed} passed, ${this.failed} failed\n`);
+    // 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 {
   if (!G.__testRunner) {
-    throw new Error("TestRunner not initialized");
+    // 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);
 }
 
@@ -176,21 +270,29 @@ export function expect(actual: any) {
       }
     },
 
-    toThrow() {
+    toThrow(expectedError?: string) {
       if (typeof actual !== "function") {
         throw new Error("toThrow expects a function");
       }
 
       let threw = false;
+      let error = null;
       try {
         actual();
-      } catch {
+      } 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) {
@@ -209,9 +311,15 @@ export function expect(actual: any) {
       }
     },
 
-    toHaveProperty(prop: string) {
-      if (actual == null || !(prop in actual)) {
-        throw new Error(`Expected object to have property "${prop}"`);
+    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]}`,
+        );
       }
     },
 
@@ -240,17 +348,24 @@ export function expect(actual: any) {
 }
 
 /* ======================================================
- * CLI entry
+ * CLI entry (when this file is run directly)
  * ====================================================== */
 if (require.main === module) {
-  const runner = new TestRunner();
-  G.__testRunner = runner;
-
-  runner
-    .loadTestFiles("dist/**/*.spec.js")
-    .then(() => runner.run())
-    .catch((err) => {
-      console.error("Failed to run tests:", err);
+  (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";
+
+      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 {