api-tests-coverage 1.0.21 → 1.0.23

package/dist/src/generation/engine.js

@@ -0,0 +1,378 @@
+"use strict";
+/**
+ * Test Generation Engine (Feature F-TGE)
+ *
+ * Entry point: TestGenerationEngine
+ * CLI commands: generate-tests, export-ai-flows, score-tests
+ *
+ * Every generated file starts with: // AUTO-GENERATED by api-test-coverage-analyzer
+ * expect(response.status) ALWAYS before expect(response.body)
+ * NEVER use toBeTruthy() or toBeDefined() — use specific matchers
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestGenerationEngine = void 0;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const gap_extractor_1 = require("./gap-extractor");
+const context_builder_1 = require("./context-builder");
+const template_renderer_1 = require("./template-renderer");
+const file_router_1 = require("./file-router");
+// ─── Test Generation Engine ──────────────────────────────────────────────────
+class TestGenerationEngine {
+    constructor(projectRoot, reportsDir = 'reports') {
+        this.projectRoot = path.resolve(projectRoot);
+        this.reportsDir = path.resolve(this.projectRoot, reportsDir);
+    }
+    /**
+     * Generate test files for all detected coverage gaps.
+     * In dry-run mode, files are not written to disk.
+     */
+    generateTests(options = {}) {
+        var _a;
+        const gaps = (0, gap_extractor_1.extractGaps)(this.reportsDir);
+        const context = (0, context_builder_1.buildContext)(this.projectRoot, gaps, {
+            baseUrl: options.baseUrl,
+            authHeader: options.authHeader,
+        });
+        const outDir = (_a = options.outDir) !== null && _a !== void 0 ? _a : this.projectRoot;
+        const generated = [];
+        for (const gap of context.gaps) {
+            const content = (0, template_renderer_1.renderTemplate)(gap, context);
+            const outputPath = (0, file_router_1.routeOutputPath)(gap, context, outDir);
+            const templateUsed = (0, template_renderer_1.getTemplateName)(gap, context);
+            generated.push({
+                outputPath,
+                content,
+                gapId: gap.id,
+                templateUsed,
+            });
+            if (!options.dryRun) {
+                fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+                fs.writeFileSync(outputPath, content, 'utf-8');
+            }
+        }
+        // Write manifest
+        const manifest = {
+            generatedAt: new Date().toISOString(),
+            totalFiles: generated.length,
+            files: generated.map((f) => ({
+                outputPath: f.outputPath,
+                gapId: f.gapId,
+                templateUsed: f.templateUsed,
+            })),
+        };
+        if (!options.dryRun) {
+            fs.mkdirSync(this.reportsDir, { recursive: true });
+            fs.writeFileSync(path.join(this.reportsDir, 'generated-tests-manifest.json'), JSON.stringify(manifest, null, 2), 'utf-8');
+        }
+        return generated;
+    }
+    /**
+     * Score existing test files for quality.
+     * Dimensions: statusAssertion, bodyAssertion, errorPath, noGenericMatchers, descriptiveName.
+     */
+    scoreTests(testsGlob) {
+        const testFiles = fast_glob_1.default.sync(testsGlob, { absolute: true })
+            .filter((f) => isTestFile(f));
+        const reports = [];
+        for (const testFile of testFiles) {
+            let content;
+            try {
+                content = fs.readFileSync(testFile, 'utf-8');
+            }
+            catch {
+                continue;
+            }
+            const report = scoreTestFile(testFile, content);
+            reports.push(report);
+        }
+        return reports;
+    }
+    /**
+     * Export AI-ready flows: structured prompts for Copilot / LLM consumption.
+     * RULE-AI05: prompt ≤ 800 tokens (~3200 chars)
+     */
+    exportAiFlows(options = {}) {
+        var _a;
+        const gaps = (0, gap_extractor_1.extractGaps)(this.reportsDir);
+        const context = (0, context_builder_1.buildContext)(this.projectRoot, gaps);
+        const flows = [];
+        const byType = {};
+        for (const gap of gaps) {
+            const outputPath = (0, file_router_1.routeOutputPath)(gap, context, this.projectRoot);
+            // Build a prompt within token budget (RULE-AI05: ≤ 800 tokens ≈ 3200 chars)
+            const prompt = buildCopilotPrompt(gap, context, outputPath);
+            let truncatedPrompt = prompt;
+            if (truncatedPrompt.length > 3200) {
+                const suffix = '\n...';
+                const maxBody = 3200 - suffix.length; // 3196 chars for body, 4 for suffix
+                const cutoff = truncatedPrompt.lastIndexOf('\n', maxBody);
+                truncatedPrompt = truncatedPrompt.substring(0, cutoff > 0 ? cutoff : maxBody) + suffix;
+            }
+            flows.push({
+                id: `flow-${gap.id}`,
+                gapId: gap.id,
+                gapType: gap.type,
+                suggestedOutputPath: outputPath, // RULE-AI01
+                copilotPrompt: truncatedPrompt, // RULE-AI02, AI03, AI05, AI06
+                existingSimilarTests: gap.existingSimilarTests, // RULE-AI04
+                estimatedComplexity: estimateComplexity(gap),
+                riskScore: gap.riskScore,
+            });
+            byType[gap.type] = ((_a = byType[gap.type]) !== null && _a !== void 0 ? _a : 0) + 1;
+        }
+        const manifest = {
+            generatedAt: new Date().toISOString(),
+            totalFlows: flows.length,
+            byType: byType,
+            flows,
+        };
+        // Write JSON
+        fs.mkdirSync(this.reportsDir, { recursive: true });
+        fs.writeFileSync(path.join(this.reportsDir, 'ai-ready-flows.json'), JSON.stringify(manifest, null, 2), 'utf-8');
+        // Write markdown summary
+        const md = renderAiFlowsMarkdown(manifest);
+        fs.writeFileSync(path.join(this.reportsDir, 'ai-ready-flows.md'), md, 'utf-8');
+        return manifest;
+    }
+}
+exports.TestGenerationEngine = TestGenerationEngine;
+// ─── Scoring helpers ─────────────────────────────────────────────────────────
+/** Only score actual test files, not helpers, fixtures, or utility modules. */
+function isTestFile(filePath) {
+    const base = path.basename(filePath);
+    const isTest = /\.(test|spec)\.(ts|js|tsx|jsx)$/.test(base) ||
+        /test\.(ts|js|tsx|jsx)$/.test(base);
+    // Exclude fixture directories — these contain sample test data, not real tests
+    const isFixture = /[/\\]fixtures[/\\]/.test(filePath);
+    return isTest && !isFixture;
+}
+/** HTTP client package names whose presence in imports indicates an API test. */
+const HTTP_CLIENT_PACKAGES = [
+    'supertest', 'axios', 'node-fetch', 'got',
+];
+/** Angular-specific HTTP client identifiers in imports. */
+const HTTP_CLIENT_IDENTIFIERS = [
+    'HttpClient', 'HttpTestingController',
+];
+/**
+ * Detect whether a test file is an API/HTTP integration test (vs a unit/library test).
+ * Only checks the file's own import/require statements —
+ * NOT inline strings that test code might analyze as content.
+ */
+function isApiTest(content) {
+    const importSection = extractImportSection(content);
+    return HTTP_CLIENT_PACKAGES.some((pkg) => new RegExp(`import\\b.*['"]${pkg}['"]`).test(importSection) ||
+        new RegExp(`require\\s*\\(\\s*['"]${pkg}['"]`).test(importSection)) || HTTP_CLIENT_IDENTIFIERS.some((id) => new RegExp(`import\\b.*${id}`).test(importSection));
+}
+/** Extract the import/require section at the top of the file, before any test blocks. */
+function extractImportSection(content) {
+    const lines = content.split('\n');
+    const importLines = [];
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (/^(describe|it|test|beforeAll|beforeEach|afterAll|afterEach)\s*\(/.test(trimmed)) {
+            break;
+        }
+        importLines.push(line);
+    }
+    return importLines.join('\n');
+}
+/** Test name keywords that indicate negative / error / edge-case testing. */
+const ERROR_PATH_NAME_KEYWORDS = [
+    'fail', 'invalid', 'throw', 'missing', 'empty', '\\bnot\\b', 'negative',
+    'reject', 'undefined', 'null', 'zero', 'without', 'default', 'skip',
+    'ignore', '\\bno\\s', 'none', 'unknown', 'error',
+];
+/** Content-level patterns that indicate error/edge-case handling. */
+const ERROR_PATH_CONTENT_PATTERNS = [
+    /\.catch\b/,
+    /expect\([^)]*\.status\)\s*\.toBe\(\s*(4|5)\d{2}\s*\)/,
+    /\.expect\(\s*(4|5)\d{2}\s*\)/,
+    /describe.*error/i,
+    /toThrow/,
+    /rejects\.toThrow/,
+    /throw new Error/,
+    /console\.warn/,
+    /expect\([^)]*\)\.toBe\(\s*false\s*\)/,
+    /expect\([^)]*\)\.toEqual\(\s*\[\s*\]\s*\)/,
+    /expect\([^)]*\)\.toBe\(\s*0\s*\)/,
+    /expect\([^)]*\)\.toBeNull/,
+    /expect\([^)]*\)\.toBeUndefined/,
+];
+/** Specific matcher patterns (as opposed to generic toBeTruthy/toBeDefined). */
+const SPECIFIC_MATCHER_PATTERNS = [
+    /\.toBe\(/, /\.toEqual\(/, /\.toContain\(/, /\.toHaveLength\(/,
+    /\.toMatch\(/, /\.toThrow/, /\.toBeGreaterThan/, /\.toBeLessThan/,
+    /\.toHaveProperty\(/, /\.toHaveBeenCalled/, /\.toBeNull\(/,
+    /\.toBeUndefined\(/, /\.toBeInstanceOf\(/, /\.toStrictEqual\(/,
+    /\.toMatchObject\(/,
+];
+function scoreTestFile(filePath, content) {
+    const apiTest = isApiTest(content);
+    // Status and body assertions only apply to API tests.
+    // For unit/library tests, these are automatically satisfied.
+    const hasStatusAssertion = !apiTest ||
+        /expect\([^)]*\.status\b/.test(content) ||
+        /expect\([^)]*statusCode\b/.test(content) ||
+        /\.expect\(\s*\d{3}\s*\)/.test(content);
+    const hasBodyAssertion = !apiTest ||
+        /expect\([^)]*\.body\b/.test(content) ||
+        /expect\([^)]*\.data\b/.test(content) ||
+        /expect\([^)]*\.text\b/.test(content);
+    const hasErrorPath = ERROR_PATH_CONTENT_PATTERNS.some((p) => p.test(content)) ||
+        ERROR_PATH_NAME_KEYWORDS.some((kw) => new RegExp(`(it|test)\\s*\\(.*${kw}`, 'i').test(content));
+    // For unit/library tests, toBeDefined()/toBeTruthy() are acceptable when
+    // the test also uses specific matchers (toBe, toEqual, toContain, etc.).
+    // Only flag when generic matchers are used without any specific ones.
+    const usesGenericMatchers = /toBeTruthy\(\)/.test(content) || /toBeDefined\(\)/.test(content);
+    const usesSpecificMatchers = SPECIFIC_MATCHER_PATTERNS.some((p) => p.test(content));
+    const hasNoGenericMatchers = !usesGenericMatchers ||
+        (!apiTest && usesSpecificMatchers);
+    const hasDescriptiveName = (/describe\(\s*['"`][^'"`]{5,}['"`]/.test(content) ||
+        /test\(\s*['"`][^'"`]{15,}['"`]/.test(content)) && (/it\(\s*['"`][^'"`]{10,}['"`]/.test(content) ||
+        /test\(\s*['"`][^'"`]{15,}['"`]/.test(content));
+    const dimensions = {
+        hasStatusAssertion,
+        hasBodyAssertion,
+        hasErrorPath,
+        hasNoGenericMatchers,
+        hasDescriptiveName,
+    };
+    const score = Object.values(dimensions).filter(Boolean).length * 20;
+    const violations = [];
+    if (!hasStatusAssertion)
+        violations.push('Missing status code assertion');
+    if (!hasBodyAssertion)
+        violations.push('Missing body/data assertion');
+    if (!hasErrorPath)
+        violations.push('Missing error/negative path');
+    if (!hasNoGenericMatchers)
+        violations.push('Uses toBeTruthy() or toBeDefined() — prefer specific matchers');
+    if (!hasDescriptiveName)
+        violations.push('Test names not sufficiently descriptive');
+    return {
+        file: filePath,
+        overallScore: score,
+        dimensions,
+        violations,
+    };
+}
+// ─── AI Flow helpers ─────────────────────────────────────────────────────────
+/** RULE-AI02: exact import path; RULE-AI03: ALL missing test cases; RULE-AI06: English only */
+function buildCopilotPrompt(gap, ctx, suggestedOutputPath) {
+    // RULE-AI02: derive concrete import path from gap.sourceFile when available
+    const importPath = gap.sourceFile
+        ? path.relative(path.dirname(suggestedOutputPath), gap.sourceFile).replace(/\.[jt]sx?$/, '')
+        : path.relative(path.dirname(suggestedOutputPath), ctx.projectRoot);
+    const lines = [
+        `Write a ${ctx.testFramework} test file at: ${suggestedOutputPath}`, // RULE-AI01
+        `Import from: ${importPath}`, // RULE-AI02
+        '',
+        `Gap type: ${gap.type}`,
+        `Risk score: ${gap.riskScore}/100`,
+    ];
+    // RULE-AI03: ALL missing test cases
+    if (gap.endpoint) {
+        lines.push(`Test: ${gap.endpoint.method} ${gap.endpoint.path}`);
+        lines.push('Include: success case, validation error, auth required');
+    }
+    if (gap.parameter) {
+        lines.push(`Test parameter: ${gap.parameter.name} (${gap.parameter.in}, required: ${gap.parameter.required})`);
+        lines.push('Include: valid value, missing value, invalid type');
+    }
+    if (gap.businessRule) {
+        lines.push(`Test business rule: ${gap.businessRule.description}`);
+        lines.push('Include: rule satisfied, rule violated, edge case');
+    }
+    if (gap.integrationFlow) {
+        lines.push(`Test flow: ${gap.integrationFlow.name} — missing step: ${gap.integrationFlow.missingStep}`);
+    }
+    // RULE-AI04: reference existingSimilarTests[0] when available
+    if (gap.existingSimilarTests.length > 0) {
+        lines.push('');
+        lines.push(`Reference existing test: ${gap.existingSimilarTests[0]}`);
+    }
+    lines.push('');
+    lines.push('Rules:');
+    lines.push('- expect(response.status) ALWAYS before expect(response.body)');
+    lines.push('- NEVER use toBeTruthy() or toBeDefined()');
+    lines.push('- First line: // AUTO-GENERATED by api-test-coverage-analyzer');
+    return lines.join('\n');
+}
+function estimateComplexity(gap) {
+    if (gap.riskScore >= 80)
+        return 'high';
+    if (gap.riskScore >= 50)
+        return 'medium';
+    return 'low';
+}
+function renderAiFlowsMarkdown(manifest) {
+    const lines = [
+        '# AI-Ready Test Generation Flows',
+        '',
+        `Generated: ${manifest.generatedAt}`,
+        `Total flows: ${manifest.totalFlows}`,
+        '',
+        '## By Type',
+        '',
+        '| Gap Type | Count |',
+        '|----------|-------|',
+    ];
+    for (const [type, count] of Object.entries(manifest.byType)) {
+        lines.push(`| ${type} | ${count} |`);
+    }
+    lines.push('');
+    lines.push('## Flows');
+    lines.push('');
+    for (const flow of manifest.flows) {
+        lines.push(`### ${flow.id}`);
+        lines.push('');
+        lines.push(`- **Gap:** ${flow.gapType}`);
+        lines.push(`- **Risk:** ${flow.riskScore}/100`);
+        lines.push(`- **Complexity:** ${flow.estimatedComplexity}`);
+        lines.push(`- **Output:** \`${flow.suggestedOutputPath}\``);
+        if (flow.existingSimilarTests.length > 0) {
+            lines.push(`- **Reference:** ${flow.existingSimilarTests[0]}`);
+        }
+        lines.push('');
+    }
+    return lines.join('\n');
+}

package/dist/src/generation/file-router.d.ts

@@ -0,0 +1,7 @@
+import type { GenerationContext, DetectedGap } from './types';
+/**
+ * Determines the output file path for a generated test based on
+ * the language, framework, and gap type.
+ */
+export declare function routeOutputPath(gap: DetectedGap, context: GenerationContext, outDir: string): string;
+//# sourceMappingURL=file-router.d.ts.map

package/dist/src/generation/file-router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-router.d.ts","sourceRoot":"","sources":["../../../src/generation/file-router.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE9D;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,GAAG,EAAE,WAAW,EAChB,OAAO,EAAE,iBAAiB,EAC1B,MAAM,EAAE,MAAM,GACb,MAAM,CAiBR"}

package/dist/src/generation/file-router.js

@@ -0,0 +1,79 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.routeOutputPath = routeOutputPath;
+const path = __importStar(require("node:path"));
+/**
+ * Determines the output file path for a generated test based on
+ * the language, framework, and gap type.
+ */
+function routeOutputPath(gap, context, outDir) {
+    const { framework, language } = context;
+    let baseDir;
+    if (framework === 'cypress') {
+        baseDir = path.join(outDir, 'cypress', 'e2e', 'generated');
+    }
+    else if (language === 'java' || language === 'kotlin') {
+        baseDir = path.join(outDir, 'src', 'test', 'generated');
+    }
+    else {
+        baseDir = path.join(outDir, 'tests', 'generated');
+    }
+    const ext = getFileExtension(language);
+    const filename = buildFilename(gap, language);
+    return path.join(baseDir, filename + ext);
+}
+function getFileExtension(language) {
+    switch (language) {
+        case 'typescript': return '.test.ts';
+        case 'javascript': return '.test.js';
+        case 'python': return '_test.py';
+        case 'java': return 'Test.java';
+        case 'kotlin': return 'Test.kt';
+        default: return '.test.ts';
+    }
+}
+function buildFilename(gap, language) {
+    // Sanitise the gap id to produce a valid filename
+    const sanitised = gap.id.replace(/[^a-zA-Z0-9_-]/g, '-').replace(/-+/g, '-');
+    // For Java/Kotlin, use PascalCase class names
+    if (language === 'java' || language === 'kotlin') {
+        return sanitised
+            .split('-')
+            .map((p) => p.charAt(0).toUpperCase() + p.slice(1))
+            .join('');
+    }
+    return sanitised;
+}

package/dist/src/generation/gap-extractor.d.ts

@@ -0,0 +1,12 @@
+import type { DetectedGap } from './types';
+/**
+ * Builds 5 synthetic sample gaps for onboarding / dry-run purposes.
+ * Used when coverage-summary.json has zero gaps or does not exist.
+ */
+export declare function buildSampleGaps(): DetectedGap[];
+/**
+ * Reads reports/coverage-summary.json and extracts uncovered items as DetectedGap[].
+ * When there are zero gaps (perfect coverage), returns buildSampleGaps() instead of [].
+ */
+export declare function extractGaps(reportsDir: string): DetectedGap[];
+//# sourceMappingURL=gap-extractor.d.ts.map

package/dist/src/generation/gap-extractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gap-extractor.d.ts","sourceRoot":"","sources":["../../../src/generation/gap-extractor.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAW,MAAM,SAAS,CAAC;AAcpD;;;GAGG;AACH,wBAAgB,eAAe,IAAI,WAAW,EAAE,CA4C/C;AAmBD;;;GAGG;AACH,wBAAgB,WAAW,CAAC,UAAU,EAAE,MAAM,GAAG,WAAW,EAAE,CA6D7D"}