@unrdf/kgn 5.0.1

package/src/injection/tests/integration.test.js

@@ -0,0 +1,392 @@
+/**
+ * KGEN Injection Integration Tests
+ *
+ * Tests for integration with the main KGEN template engine,
+ * including template processing with injection support.
+ */
+
+import { describe, test, expect, beforeEach, afterEach } from 'vitest';
+import { promises as fs } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+
+import { inject, dryRun, processTemplate, initializeInjection } from '../api.js';
+import { enhanceKgenWithInjection } from '../integration.js';
+import { INJECTION_MODES } from '../constants.js';
+
+describe('KGEN Injection Integration', () => {
+  let tempDir;
+  let testFiles;
+
+  beforeEach(async () => {
+    tempDir = await fs.mkdtemp(join(tmpdir(), 'kgen-integration-test-'));
+    await fs.mkdir(join(tempDir, 'src'), { recursive: true });
+
+    testFiles = {
+      routes: join(tempDir, 'src', 'routes.ts'),
+      config: join(tempDir, 'src', 'config.ts'),
+      template: join(tempDir, 'templates', 'route.kgen')
+    };
+
+    // Initialize injection system
+    initializeInjection({
+      projectRoot: tempDir,
+      backupEnabled: true
+    });
+  });
+
+  afterEach(async () => {
+    await fs.rm(tempDir, { recursive: true, force: true });
+  });
+
+  describe('API Functions', () => {
+    test('should inject content using API', async () => {
+      // Setup
+      const initialContent = 'export const config = { port: 3000 };';
+      await fs.writeFile(testFiles.config, initialContent);
+
+      const templateConfig = {
+        to: 'src/config.ts',
+        inject: true,
+        mode: 'append'
+      };
+
+      const content = '\nexport const database = "mongodb://localhost";';
+      const variables = {};
+
+      // Execute
+      const result = await inject(templateConfig, content, variables);
+
+      // Verify
+      expect(result.success).toBe(true);
+      expect(result.operationId).toBeDefined();
+
+      const finalContent = await fs.readFile(testFiles.config, 'utf8');
+      expect(finalContent).toContain('export const database');
+    });
+
+    test('should perform dry run without modifications', async () => {
+      // Setup
+      const initialContent = 'const original = true;';
+      await fs.writeFile(testFiles.config, initialContent);
+
+      const templateConfig = {
+        to: 'src/config.ts',
+        inject: true,
+        mode: 'append'
+      };
+
+      const content = 'const added = true;';
+
+      // Execute dry run
+      const result = await dryRun(templateConfig, content, {});
+
+      // Verify
+      expect(result.targets).toHaveLength(1);
+      expect(result.targets[0].valid).toBe(true);
+
+      // File should not be modified
+      const finalContent = await fs.readFile(testFiles.config, 'utf8');
+      expect(finalContent).toBe(initialContent);
+    });
+
+    test('should process template with frontmatter', async () => {
+      // Setup template with frontmatter
+      const template = `---
+to: src/routes.ts
+inject: true
+mode: before
+target: "export default"
+---
+router.{{method}}('{{path}}', {{handler}});`;
+
+      // Create target file
+      const initialContent = `const router = Router();
+
+export default router;`;
+      await fs.writeFile(testFiles.routes, initialContent);
+
+      const data = {
+        method: 'get',
+        path: '/users',
+        handler: 'getUsers'
+      };
+
+      // Execute
+      const result = await processTemplate(template, data);
+
+      // Verify
+      expect(result.success).toBe(true);
+      expect(result.operationId).toBeDefined();
+
+      const finalContent = await fs.readFile(testFiles.routes, 'utf8');
+      expect(finalContent).toContain("router.get('/users', getUsers);");
+    });
+
+    test('should handle template without frontmatter', async () => {
+      const template = 'Simple template without frontmatter';
+      const data = {};
+
+      // Should throw error since only injection templates are supported
+      await expect(processTemplate(template, data))
+        .rejects.toThrow('Regular template processing not implemented');
+    });
+  });
+
+  describe('Template Engine Enhancement', () => {
+    test('should enhance existing KGEN engine with injection', async () => {
+      // Mock KGEN engine
+      const mockKgenEngine = {
+        render: async (templatePath, data) => `Rendered: ${templatePath}`,
+        renderString: async (templateString, data) => `Rendered: ${templateString}`,
+        getTemplate: async (templatePath) => ({
+          frontmatter: { inject: true, to: 'src/test.ts', mode: 'append' },
+          content: 'test content {{name}}'
+        })
+      };
+
+      // Enhance with injection
+      const enhancedEngine = enhanceKgenWithInjection(mockKgenEngine, {
+        projectRoot: tempDir
+      });
+
+      // Verify new methods are added
+      expect(enhancedEngine.inject).toBeDefined();
+      expect(enhancedEngine.dryRunInjection).toBeDefined();
+      expect(enhancedEngine.getInjectionHistory).toBeDefined();
+      expect(enhancedEngine.undoInjection).toBeDefined();
+      expect(enhancedEngine.processBatch).toBeDefined();
+
+      // Test injection method
+      await fs.writeFile(join(tempDir, 'src', 'test.ts'), 'original content');
+
+      const result = await enhancedEngine.inject(
+        { to: 'src/test.ts', inject: true, mode: 'append' },
+        'injected content',
+        {}
+      );
+
+      expect(result.success).toBe(true);
+    });
+
+    test('should process batch templates with mixed injection/regular', async () => {
+      const mockKgenEngine = {
+        render: async () => 'Regular render result',
+        renderString: async () => 'Regular renderString result',
+        getTemplate: async (templatePath) => {
+          if (templatePath.includes('injection')) {
+            return {
+              frontmatter: { inject: true, to: 'src/test.ts', mode: 'append' },
+              content: 'injected {{content}}'
+            };
+          }
+          return { frontmatter: {}, content: 'regular template' };
+        }
+      };
+
+      const enhancedEngine = enhanceKgenWithInjection(mockKgenEngine, {
+        projectRoot: tempDir
+      });
+
+      // Setup target file
+      await fs.writeFile(join(tempDir, 'src', 'test.ts'), 'original');
+
+      const templates = [
+        {
+          path: 'injection-template.kgen',
+          data: { content: 'test' }
+        },
+        {
+          path: 'regular-template.kgen',
+          data: { name: 'test' }
+        }
+      ];
+
+      const result = await enhancedEngine.processBatch(templates);
+
+      expect(result.total).toBe(2);
+      expect(result.successful).toBeGreaterThan(0);
+    });
+  });
+
+  describe('Error Handling', () => {
+    test('should handle missing template variables', async () => {
+      const templateConfig = {
+        to: 'src/{{filename}}.ts', // Missing filename variable
+        inject: true,
+        mode: 'create'
+      };
+
+      const content = 'test content';
+      const variables = {}; // Missing 'filename'
+
+      await expect(inject(templateConfig, content, variables))
+        .rejects.toThrow(/Variable 'filename' not provided/);
+    });
+
+    test('should handle invalid injection mode', async () => {
+      const templateConfig = {
+        to: 'src/test.ts',
+        inject: true,
+        mode: 'invalid-mode'
+      };
+
+      const content = 'test content';
+
+      await expect(inject(templateConfig, content, variables = {}))
+        .rejects.toThrow(/Unknown injection mode/);
+    });
+
+    test('should handle path traversal attempts', async () => {
+      const templateConfig = {
+        to: '../../../etc/passwd', // Path traversal attempt
+        inject: true,
+        mode: 'create'
+      };
+
+      const content = 'malicious content';
+
+      await expect(inject(templateConfig, content, {}))
+        .rejects.toThrow(/Path traversal blocked/);
+    });
+  });
+
+  describe('Complex Scenarios', () => {
+    test('should handle multi-target injection', async () => {
+      // Setup multiple target files
+      await fs.writeFile(join(tempDir, 'src', 'routes.ts'), 'export const routes = [];');
+      await fs.writeFile(join(tempDir, 'src', 'handlers.ts'), 'export const handlers = {};');
+
+      const templateConfig = {
+        targets: [
+          {
+            to: 'src/routes.ts',
+            inject: true,
+            mode: 'before',
+            target: 'export const routes'
+          },
+          {
+            to: 'src/handlers.ts',
+            inject: true,
+            mode: 'before',
+            target: 'export const handlers'
+          }
+        ]
+      };
+
+      const content = '// Auto-generated code';
+
+      const result = await inject(templateConfig, content, {});
+
+      expect(result.success).toBe(true);
+      expect(result.targets).toBe(2);
+
+      // Verify both files were modified
+      const routesContent = await fs.readFile(join(tempDir, 'src', 'routes.ts'), 'utf8');
+      const handlersContent = await fs.readFile(join(tempDir, 'src', 'handlers.ts'), 'utf8');
+
+      expect(routesContent).toContain('// Auto-generated code');
+      expect(handlersContent).toContain('// Auto-generated code');
+    });
+
+    test('should handle glob patterns with exclusions', async () => {
+      // Setup multiple TypeScript files
+      await fs.mkdir(join(tempDir, 'src', 'components'), { recursive: true });
+      await fs.writeFile(join(tempDir, 'src', 'components', 'Button.ts'), 'export class Button {}');
+      await fs.writeFile(join(tempDir, 'src', 'components', 'Input.ts'), 'export class Input {}');
+      await fs.writeFile(join(tempDir, 'src', 'components', 'Button.test.ts'), 'test code');
+      await fs.writeFile(join(tempDir, 'src', 'components', 'Input.spec.ts'), 'spec code');
+
+      const templateConfig = {
+        to: 'src/components/*.ts',
+        inject: true,
+        mode: 'prepend',
+        exclude: ['*.test.ts', '*.spec.ts']
+      };
+
+      const content = '// Auto-generated imports';
+
+      const result = await inject(templateConfig, content, {});
+
+      expect(result.success).toBe(true);
+      expect(result.targets).toBe(2); // Only Button.ts and Input.ts, not test files
+
+      // Verify only non-test files were modified
+      const buttonContent = await fs.readFile(join(tempDir, 'src', 'components', 'Button.ts'), 'utf8');
+      const inputContent = await fs.readFile(join(tempDir, 'src', 'components', 'Input.ts'), 'utf8');
+      const testContent = await fs.readFile(join(tempDir, 'src', 'components', 'Button.test.ts'), 'utf8');
+
+      expect(buttonContent).toContain('// Auto-generated imports');
+      expect(inputContent).toContain('// Auto-generated imports');
+      expect(testContent).not.toContain('// Auto-generated imports');
+    });
+
+    test('should handle conditional injection with complex skipIf', async () => {
+      // Setup file with existing content
+      const existingContent = `import express from 'express';
+import cors from 'cors';
+
+const app = express();
+app.use(cors());`;
+
+      await fs.writeFile(testFiles.routes, existingContent);
+
+      const templateConfig = {
+        to: 'src/routes.ts',
+        inject: true,
+        mode: 'prepend',
+        skipIf: ['/cors/', 'express'],
+        skipIfLogic: 'OR'
+      };
+
+      const content = 'import helmet from "helmet";';
+
+      const result = await inject(templateConfig, content, {});
+
+      // Should be skipped because file contains 'cors'
+      expect(result.success).toBe(true);
+      expect(result.skipped).toBe(true);
+
+      // File should not be modified
+      const finalContent = await fs.readFile(testFiles.routes, 'utf8');
+      expect(finalContent).toBe(existingContent);
+    });
+
+    test('should handle rollback on partial multi-target failure', async () => {
+      // Setup target files
+      await fs.writeFile(join(tempDir, 'src', 'file1.ts'), 'original content 1');
+      await fs.writeFile(join(tempDir, 'src', 'file2.ts'), 'original content 2');
+
+      // Make file2 read-only to cause failure
+      await fs.chmod(join(tempDir, 'src', 'file2.ts'), 0o444);
+
+      const templateConfig = {
+        targets: [
+          {
+            to: 'src/file1.ts',
+            inject: true,
+            mode: 'append'
+          },
+          {
+            to: 'src/file2.ts',
+            inject: true,
+            mode: 'append'
+          }
+        ]
+      };
+
+      const content = 'new content';
+
+      // Should fail due to read-only file2
+      await expect(inject(templateConfig, content, {}))
+        .rejects.toThrow();
+
+      // file1 should be rolled back to original content
+      const file1Content = await fs.readFile(join(tempDir, 'src', 'file1.ts'), 'utf8');
+      expect(file1Content).toBe('original content 1');
+
+      // Restore permissions for cleanup
+      await fs.chmod(join(tempDir, 'src', 'file2.ts'), 0o644);
+    });
+  });
+});

package/src/injection/tests/run-tests.js

@@ -0,0 +1,283 @@
+/**
+ * KGEN Injection Tests Runner
+ *
+ * Comprehensive test runner for the injection system with
+ * coverage reporting and BDD scenario validation.
+ */
+
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { promises as fs } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const execAsync = promisify(exec);
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const rootDir = join(__dirname, '../../..');
+
+async function runTests() {
+  console.log('🚀 Starting KGEN Injection System Tests');
+  console.log('=' .repeat(50));
+
+  const results = {
+    unit: null,
+    integration: null,
+    bdd: null,
+    coverage: null,
+    errors: []
+  };
+
+  try {
+    // 1. Run unit tests
+    console.log('\n📦 Running Unit Tests...');
+    try {
+      const unitResult = await execAsync('npm test', {
+        cwd: rootDir,
+        env: { ...process.env, NODE_ENV: 'test' }
+      });
+
+      results.unit = {
+        success: true,
+        output: unitResult.stdout,
+        duration: extractTestDuration(unitResult.stdout)
+      };
+
+      console.log('✅ Unit tests passed');
+    } catch (error) {
+      results.unit = {
+        success: false,
+        error: error.message,
+        output: error.stdout || error.stderr
+      };
+      results.errors.push('Unit tests failed');
+      console.log('❌ Unit tests failed:', error.message);
+    }
+
+    // 2. Run integration tests
+    console.log('\n🔗 Running Integration Tests...');
+    try {
+      const integrationResult = await execAsync('npm run test:integration', {
+        cwd: rootDir,
+        env: { ...process.env, NODE_ENV: 'test' }
+      });
+
+      results.integration = {
+        success: true,
+        output: integrationResult.stdout,
+        duration: extractTestDuration(integrationResult.stdout)
+      };
+
+      console.log('✅ Integration tests passed');
+    } catch (error) {
+      results.integration = {
+        success: false,
+        error: error.message,
+        output: error.stdout || error.stderr
+      };
+      results.errors.push('Integration tests failed');
+      console.log('❌ Integration tests failed:', error.message);
+    }
+
+    // 3. Run BDD feature tests
+    console.log('\n🥒 Running BDD Feature Tests...');
+    try {
+      const bddResult = await execAsync('npm run test:cucumber', {
+        cwd: rootDir,
+        env: { ...process.env, NODE_ENV: 'test' }
+      });
+
+      results.bdd = {
+        success: true,
+        output: bddResult.stdout,
+        scenarios: extractBddScenarios(bddResult.stdout)
+      };
+
+      console.log('✅ BDD feature tests passed');
+    } catch (error) {
+      results.bdd = {
+        success: false,
+        error: error.message,
+        output: error.stdout || error.stderr
+      };
+      results.errors.push('BDD tests failed');
+      console.log('❌ BDD tests failed:', error.message);
+    }
+
+    // 4. Generate coverage report
+    console.log('\n📊 Generating Coverage Report...');
+    try {
+      const coverageResult = await execAsync('npm run test:coverage', {
+        cwd: rootDir,
+        env: { ...process.env, NODE_ENV: 'test' }
+      });
+
+      const coverage = extractCoverageStats(coverageResult.stdout);
+      results.coverage = {
+        success: true,
+        ...coverage
+      };
+
+      console.log(`✅ Coverage: ${coverage.statements}% statements, ${coverage.branches}% branches`);
+    } catch (error) {
+      results.coverage = {
+        success: false,
+        error: error.message
+      };
+      console.log('⚠️ Coverage generation failed:', error.message);
+    }
+
+    // 5. Generate final report
+    await generateTestReport(results);
+
+  } catch (error) {
+    console.error('❌ Test runner failed:', error);
+    results.errors.push(`Runner error: ${error.message}`);
+  }
+
+  // 6. Print summary
+  printTestSummary(results);
+
+  // Exit with appropriate code
+  const hasFailures = results.errors.length > 0;
+  process.exit(hasFailures ? 1 : 0);
+}
+
+function extractTestDuration(output) {
+  const match = output.match(/Tests?.*?(\d+(?:\.\d+)?(?:m?s))/i);
+  return match ? match[1] : 'unknown';
+}
+
+function extractBddScenarios(output) {
+  const scenarioMatch = output.match(/(\d+) scenarios?/i);
+  const passedMatch = output.match(/(\d+) passed/i);
+  const failedMatch = output.match(/(\d+) failed/i);
+
+  return {
+    total: scenarioMatch ? parseInt(scenarioMatch[1]) : 0,
+    passed: passedMatch ? parseInt(passedMatch[1]) : 0,
+    failed: failedMatch ? parseInt(failedMatch[1]) : 0
+  };
+}
+
+function extractCoverageStats(output) {
+  const statementsMatch = output.match(/Statements\s*:\s*(\d+(?:\.\d+)?)%/);
+  const branchesMatch = output.match(/Branches\s*:\s*(\d+(?:\.\d+)?)%/);
+  const functionsMatch = output.match(/Functions\s*:\s*(\d+(?:\.\d+)?)%/);
+  const linesMatch = output.match(/Lines\s*:\s*(\d+(?:\.\d+)?)%/);
+
+  return {
+    statements: statementsMatch ? parseFloat(statementsMatch[1]) : 0,
+    branches: branchesMatch ? parseFloat(branchesMatch[1]) : 0,
+    functions: functionsMatch ? parseFloat(functionsMatch[1]) : 0,
+    lines: linesMatch ? parseFloat(linesMatch[1]) : 0
+  };
+}
+
+async function generateTestReport(results) {
+  const report = {
+    timestamp: new Date().toISOString(),
+    component: 'KGEN Injection System',
+    version: '1.0.0',
+    summary: {
+      total_test_suites: 0,
+      passed_test_suites: 0,
+      failed_test_suites: 0,
+      coverage_percentage: results.coverage?.statements || 0,
+      errors: results.errors
+    },
+    results: {
+      unit_tests: results.unit,
+      integration_tests: results.integration,
+      bdd_tests: results.bdd,
+      coverage: results.coverage
+    }
+  };
+
+  // Count test suites
+  [results.unit, results.integration, results.bdd].forEach(result => {
+    if (result) {
+      report.summary.total_test_suites++;
+      if (result.success) {
+        report.summary.passed_test_suites++;
+      } else {
+        report.summary.failed_test_suites++;
+      }
+    }
+  });
+
+  // Write report to file
+  const reportPath = join(rootDir, 'test-results', 'injection-test-report.json');
+  await fs.mkdir(dirname(reportPath), { recursive: true });
+  await fs.writeFile(reportPath, JSON.stringify(report, null, 2));
+
+  console.log(`\n📄 Test report written to: ${reportPath}`);
+}
+
+function printTestSummary(results) {
+  console.log('\n' + '='.repeat(50));
+  console.log('🏁 Test Summary');
+  console.log('='.repeat(50));
+
+  const suites = [
+    { name: 'Unit Tests', result: results.unit },
+    { name: 'Integration Tests', result: results.integration },
+    { name: 'BDD Feature Tests', result: results.bdd }
+  ];
+
+  suites.forEach(suite => {
+    const status = suite.result?.success ? '✅ PASS' : '❌ FAIL';
+    console.log(`${suite.name}: ${status}`);
+  });
+
+  if (results.coverage?.success) {
+    console.log(`\nCode Coverage:`);
+    console.log(`  Statements: ${results.coverage.statements}%`);
+    console.log(`  Branches: ${results.coverage.branches}%`);
+    console.log(`  Functions: ${results.coverage.functions}%`);
+    console.log(`  Lines: ${results.coverage.lines}%`);
+
+    // Check if coverage meets requirements
+    const meetsRequirements = results.coverage.statements >= 90 &&
+                             results.coverage.branches >= 85 &&
+                             results.coverage.functions >= 90;
+
+    console.log(`\nCoverage Requirements: ${meetsRequirements ? '✅ MET' : '❌ NOT MET'}`);
+    console.log(`  Target: 90% statements, 85% branches, 90% functions`);
+  }
+
+  if (results.bdd?.scenarios) {
+    console.log(`\nBDD Scenarios:`);
+    console.log(`  Total: ${results.bdd.scenarios.total}`);
+    console.log(`  Passed: ${results.bdd.scenarios.passed}`);
+    console.log(`  Failed: ${results.bdd.scenarios.failed}`);
+  }
+
+  if (results.errors.length > 0) {
+    console.log(`\n❌ Errors (${results.errors.length}):`);
+    results.errors.forEach((error, index) => {
+      console.log(`  ${index + 1}. ${error}`);
+    });
+  }
+
+  const overallStatus = results.errors.length === 0 ? '✅ SUCCESS' : '❌ FAILURE';
+  console.log(`\nOverall Result: ${overallStatus}`);
+
+  // Recommendations
+  if (results.coverage?.statements < 90) {
+    console.log('\n💡 Recommendation: Increase test coverage to meet 90% target');
+  }
+
+  if (results.errors.length > 0) {
+    console.log('\n💡 Recommendation: Fix failing tests before deployment');
+  }
+
+  console.log('='.repeat(50));
+}
+
+// Run tests if this file is executed directly
+if (process.argv[1] === __filename) {
+  runTests().catch(console.error);
+}
+
+export { runTests };