fragment-ts 1.0.18 → 1.0.20

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

@@ -17,6 +17,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 +58,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 +70,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,189 +79,62 @@ 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');
-
-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}\`);
-      }
-    }
-  };
-};
-
-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);
-    }
+    // Check if we need to use ts-node for TypeScript files
+    const tsConfigPath = path.join(cwd, "tsconfig.json");
+    const hasTsConfig = fs.existsSync(tsConfigPath);
 
-    console.log(\`Found \${files.length} test file(s)\\n\`);
-
-    // Load all test files
-    for (const file of files) {
-      require(path.resolve(file));
-    }
-
-    // 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
-          });
-        }
-      }
-    }
-
-    // Print summary
-    console.log(\`\\n\\n📊 Results: \${testState.passed} passed, \${testState.failed} failed\\n\`);
-
-    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\`);
-      });
-      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();
-`;
+    // 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,
+    });
 
     const scriptPath = path.join(cwd, ".fragment-test-runner.js");
 
     try {
       fs.writeFileSync(scriptPath, scriptContent);
 
+      // Make the script executable
+      fs.chmodSync(scriptPath, "755");
+
       const nodeArgs = [scriptPath];
       const env = {
         ...process.env,
         TS_NODE_TRANSPILE_ONLY: "true",
         NODE_ENV: "test",
+        // Only set TS_NODE_PROJECT if tsconfig exists
+        ...(hasTsConfig && useTypeScript
+          ? { TS_NODE_PROJECT: tsConfigPath }
+          : {}),
+        // Handle color output
+        FORCE_COLOR: options.color === false ? "0" : "1",
       };
 
+      // Add --watch support
+      if (options.watch) {
+        console.log(
+          chalk.yellow(
+            "\n⚠️  Watch mode is not yet implemented. Running once.\n",
+          ),
+        );
+      }
+
+      // Add --coverage support
+      if (options.coverage) {
+        console.log(
+          chalk.yellow("\n⚠️  Coverage reporting is not yet implemented.\n"),
+        );
+      }
+
       const proc = spawn("node", nodeArgs, {
         cwd,
         stdio: "inherit",
@@ -270,7 +144,9 @@ runTests();
       proc.on("close", (code) => {
         try {
           fs.unlinkSync(scriptPath);
-        } catch {}
+        } catch (e) {
+          // Ignore cleanup errors
+        }
         process.exit(code || 0);
       });
 
@@ -278,7 +154,9 @@ runTests();
         console.error(chalk.red("Failed to run tests:"), error);
         try {
           fs.unlinkSync(scriptPath);
-        } catch {}
+        } catch (e) {
+          // Ignore cleanup errors
+        }
         process.exit(1);
       });
     } catch (error: any) {
@@ -286,4 +164,141 @@ runTests();
       process.exit(1);
     }
   }
-}
+
+  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;
+
+    // Determine the runner path - try to find the actual test runner
+    // This assumes the test runner is installed as a dependency
+    let runnerImportPath = "fragment-ts/testing";
+
+    // Try to find the local test runner first for development
+    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"), // If we're in the fragment-ts package itself
+    ];
+
+    let resolvedRunnerPath = runnerImportPath;
+    for (const testPath of possiblePaths) {
+      if (fs.existsSync(testPath + ".ts") || fs.existsSync(testPath + ".js")) {
+        resolvedRunnerPath = testPath;
+        break;
+      }
+    }
+
+    return `
+"use strict";
+
+${useTypeScript ? "require('ts-node/register/transpile-only');" : ""}
+require('reflect-metadata');
+
+// Set environment
+process.env.NODE_ENV = 'test';
+${noColor ? "process.env.FORCE_COLOR = '0';" : "process.env.FORCE_COLOR = '1';"}
+
+// Set up TypeScript config if available
+${
+  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) {
+  // Ignore, ts-node might not be available
+}`
+    : ""
+}
+
+let testRunner;
+try {
+  // Try to import the test runner
+  const testModule = require('${resolvedRunnerPath}');
+
+  // Handle different export patterns
+  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 {
+    // Fallback to creating a new instance
+    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...');
+
+    // Load test files with the runner
+    await testRunner.loadTestFiles('${basePath}/${pattern}');
+
+    // Run tests
+    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);
+  }
+}
+
+// Handle process termination
+process.on('SIGINT', () => {
+  console.log('\\n\\nTest run interrupted');
+  process.exit(130);
+});
+
+process.on('SIGTERM', () => {
+  console.log('\\n\\nTest run terminated');
+  process.exit(143);
+});
+
+// Run the tests
+runTests().catch(error => {
+  console.error('Unhandled error:', error);
+  process.exit(1);
+});
+`;
+  }
+}