api-tests-coverage 1.0.23 → 1.0.25

package/dist/src/pipeline/stages/tia/testEndpointMapper.js

@@ -10,6 +10,8 @@
  * 5. Framework metadata: Framework annotations link test to endpoint
  * 6. Helper traversal: URL resolved through helper function chain
  * 7. Page object: URL resolved through page object pattern
+ * 8. Service call: test covers a service method that is linked to an endpoint via call graph
+ * 9. Business rule: test method name implies a business rule covered by the test
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -46,89 +48,401 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mapTestsToEndpoints = mapTestsToEndpoints;
+const testLayerClassifier_1 = require("./testLayerClassifier");
+const parameterizedTestExpander_1 = require("./parameterizedTestExpander");
+const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 /**
  * Map test files to endpoints using available evidence in the graph.
  *
  * @param graph - The coverage knowledge graph (from AST stage)
  * @param testFiles - List of test file paths
+ * @param fileContents - Optional test file contents keyed by file path. When absent,
+ * the mapper falls back to graph node metadata and finally to the filesystem.
  */
-function mapTestsToEndpoints(graph, testFiles) {
-    var _a, _b;
+function mapTestsToEndpoints(graph, testFiles, fileContents = {}) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
     const mappings = [];
-    // Get all endpoint nodes
     const endpointNodes = graph.getNodesByType('endpoint');
-    if (endpointNodes.length === 0)
-        return mappings;
+    const seen = new Set();
     for (const testFile of testFiles) {
         const fileNodeId = `file:${testFile}`;
-        // 1. Check for existing 'tests' edges from AST stage
+        const content = resolveTestContent(graph, testFile, fileContents);
+        const insights = analyzeTestFile(graph, testFile, content);
+        const pushMapping = (mapping) => {
+            var _a, _b, _c, _d;
+            const key = [
+                mapping.testFilePath,
+                (_a = mapping.endpointId) !== null && _a !== void 0 ? _a : '',
+                (_b = mapping.serviceId) !== null && _b !== void 0 ? _b : '',
+                (_c = mapping.coveredMethod) !== null && _c !== void 0 ? _c : '',
+                (_d = mapping.businessRule) !== null && _d !== void 0 ? _d : '',
+                mapping.evidenceType,
+            ].join('|');
+            if (seen.has(key))
+                return;
+            seen.add(key);
+            mappings.push({
+                ...mapping,
+                layer: insights.layer,
+                mockLibrary: insights.mockLibrary,
+                qualityScore: insights.qualityScore,
+                parameterizedExpansions: insights.parameterizedExpansions,
+                assertionCount: insights.assertionCount,
+            });
+        };
         if (graph.hasNode(fileNodeId)) {
             const testEdges = graph.getEdgesFrom(fileNodeId).filter((e) => e.type === 'tests');
             for (const edge of testEdges) {
-                mappings.push({
+                const endpointNode = graph.getNode(edge.targetNodeId);
+                pushMapping({
                     testFilePath: testFile,
                     endpointId: edge.targetNodeId,
                     evidenceType: 'explicit-url',
                     confidence: 'high',
+                    coversEndpoint: (_a = endpointNode === null || endpointNode === void 0 ? void 0 : endpointNode.label) !== null && _a !== void 0 ? _a : edge.targetNodeId,
+                    businessRule: insights.businessRules[0],
+                    serviceId: (_b = insights.coveredMethods[0]) === null || _b === void 0 ? void 0 : _b.serviceId,
+                    coveredMethod: (_c = insights.coveredMethods[0]) === null || _c === void 0 ? void 0 : _c.qualifiedMethod,
                 });
             }
         }
-        // 2. Check for 'asserts' edges (higher confidence than just 'tests')
         if (graph.hasNode(fileNodeId)) {
             const assertEdges = graph.getEdgesFrom(fileNodeId).filter((e) => e.type === 'asserts');
             for (const edge of assertEdges) {
-                // Don't duplicate if already mapped via 'tests'
-                if (!mappings.some((m) => m.testFilePath === testFile && m.endpointId === edge.targetNodeId)) {
-                    mappings.push({
-                        testFilePath: testFile,
-                        endpointId: edge.targetNodeId,
-                        evidenceType: 'explicit-url',
-                        confidence: 'high',
-                    });
-                }
+                const endpointNode = graph.getNode(edge.targetNodeId);
+                pushMapping({
+                    testFilePath: testFile,
+                    endpointId: edge.targetNodeId,
+                    evidenceType: 'explicit-url',
+                    confidence: 'high',
+                    coversEndpoint: (_d = endpointNode === null || endpointNode === void 0 ? void 0 : endpointNode.label) !== null && _d !== void 0 ? _d : edge.targetNodeId,
+                    businessRule: insights.businessRules[0],
+                    serviceId: (_e = insights.coveredMethods[0]) === null || _e === void 0 ? void 0 : _e.serviceId,
+                    coveredMethod: (_f = insights.coveredMethods[0]) === null || _f === void 0 ? void 0 : _f.qualifiedMethod,
+                });
             }
         }
-        // 3. Naming convention matching
         const testBasename = path.basename(testFile, path.extname(testFile))
             .replace(/\.(test|spec|Test|Tests|Spec|IT)$/, '')
             .replace(/^test_|_test$/, '')
             .replace(/^Test|Test$/, '');
         for (const endpoint of endpointNodes) {
-            const handlerName = (_b = (_a = endpoint.metadata) === null || _a === void 0 ? void 0 : _a.handlerFunction) !== null && _b !== void 0 ? _b : '';
-            const endpointLabel = endpoint.label.toLowerCase();
-            // Match test file name to handler/controller name
-            if (testBasename.toLowerCase().includes(handlerName.toLowerCase()) && handlerName.length > 3) {
-                if (!mappings.some((m) => m.testFilePath === testFile && m.endpointId === endpoint.id)) {
-                    mappings.push({
-                        testFilePath: testFile,
-                        endpointId: endpoint.id,
-                        evidenceType: 'naming-convention',
-                        confidence: 'low',
-                    });
-                }
+            const handlerName = String((_h = (_g = endpoint.metadata) === null || _g === void 0 ? void 0 : _g.handlerFunction) !== null && _h !== void 0 ? _h : '');
+            if (handlerName.length > 3 &&
+                testBasename.toLowerCase().includes(handlerName.toLowerCase())) {
+                pushMapping({
+                    testFilePath: testFile,
+                    endpointId: endpoint.id,
+                    evidenceType: 'naming-convention',
+                    confidence: 'low',
+                    coversEndpoint: endpoint.label,
+                    businessRule: insights.businessRules[0],
+                    serviceId: (_j = insights.coveredMethods[0]) === null || _j === void 0 ? void 0 : _j.serviceId,
+                    coveredMethod: (_k = insights.coveredMethods[0]) === null || _k === void 0 ? void 0 : _k.qualifiedMethod,
+                });
             }
         }
-        // 4. Import graph traversal: follow imports from test file to find endpoint connections
         if (graph.hasNode(fileNodeId)) {
             const importEdges = graph.getEdgesFrom(fileNodeId).filter((e) => e.type === 'imports-helper');
             for (const importEdge of importEdges) {
-                // Check if the imported file defines any endpoints
-                const importedFileEdges = graph.getEdgesFrom(importEdge.targetNodeId);
-                for (const fileEdge of importedFileEdges) {
+                for (const fileEdge of graph.getEdgesFrom(importEdge.targetNodeId)) {
                     if (fileEdge.type === 'tests' || fileEdge.type === 'defines') {
-                        if (!mappings.some((m) => m.testFilePath === testFile && m.endpointId === fileEdge.targetNodeId)) {
-                            mappings.push({
-                                testFilePath: testFile,
-                                endpointId: fileEdge.targetNodeId,
-                                evidenceType: 'import-graph',
-                                confidence: 'medium',
-                            });
-                        }
+                        const endpointNode = graph.getNode(fileEdge.targetNodeId);
+                        pushMapping({
+                            testFilePath: testFile,
+                            endpointId: fileEdge.targetNodeId,
+                            evidenceType: 'import-graph',
+                            confidence: 'medium',
+                            coversEndpoint: (_l = endpointNode === null || endpointNode === void 0 ? void 0 : endpointNode.label) !== null && _l !== void 0 ? _l : fileEdge.targetNodeId,
+                            businessRule: insights.businessRules[0],
+                            serviceId: (_m = insights.coveredMethods[0]) === null || _m === void 0 ? void 0 : _m.serviceId,
+                            coveredMethod: (_o = insights.coveredMethods[0]) === null || _o === void 0 ? void 0 : _o.qualifiedMethod,
+                        });
                     }
                 }
             }
         }
+        for (const coveredMethod of insights.coveredMethods) {
+            const endpoints = resolveEndpointsForMethod(graph, coveredMethod);
+            if (endpoints.length > 0) {
+                for (const endpoint of endpoints) {
+                    pushMapping({
+                        testFilePath: testFile,
+                        endpointId: endpoint.id,
+                        evidenceType: 'service-call',
+                        confidence: 'medium',
+                        serviceId: coveredMethod.serviceId,
+                        coveredMethod: coveredMethod.qualifiedMethod,
+                        businessRule: insights.businessRules[0],
+                        coversEndpoint: endpoint.label,
+                    });
+                }
+            }
+            else {
+                pushMapping({
+                    testFilePath: testFile,
+                    evidenceType: 'service-call',
+                    confidence: 'medium',
+                    serviceId: coveredMethod.serviceId,
+                    coveredMethod: coveredMethod.qualifiedMethod,
+                    businessRule: insights.businessRules[0],
+                });
+            }
+        }
+        for (const businessRule of insights.businessRules) {
+            pushMapping({
+                testFilePath: testFile,
+                evidenceType: 'business-rule',
+                confidence: insights.coveredMethods.length > 0 ? 'medium' : 'low',
+                serviceId: (_p = insights.coveredMethods[0]) === null || _p === void 0 ? void 0 : _p.serviceId,
+                coveredMethod: (_q = insights.coveredMethods[0]) === null || _q === void 0 ? void 0 : _q.qualifiedMethod,
+                businessRule,
+                coversEndpoint: (_r = mappings.find((m) => m.testFilePath === testFile)) === null || _r === void 0 ? void 0 : _r.coversEndpoint,
+            });
+        }
     }
     return mappings;
 }
+function resolveTestContent(graph, testFile, fileContents) {
+    var _a;
+    if (typeof fileContents[testFile] === 'string') {
+        return fileContents[testFile];
+    }
+    const fileNode = graph.getNode(`file:${testFile}`);
+    if (typeof ((_a = fileNode === null || fileNode === void 0 ? void 0 : fileNode.metadata) === null || _a === void 0 ? void 0 : _a.content) === 'string') {
+        return fileNode.metadata.content;
+    }
+    try {
+        if (fs.existsSync(testFile)) {
+            return fs.readFileSync(testFile, 'utf-8');
+        }
+    }
+    catch {
+        return '';
+    }
+    return '';
+}
+function analyzeTestFile(graph, testFile, content) {
+    const language = detectLanguageFromPath(testFile);
+    const expandedTests = (0, parameterizedTestExpander_1.expandParameterizedTests)(testFile, content, language);
+    const injectedTargets = extractInjectedTargets(content);
+    const coveredMethods = extractCoveredMethods(content, injectedTargets);
+    const layer = (0, testLayerClassifier_1.classifyTestLayer)(testFile, content).layer;
+    return {
+        layer,
+        mockLibrary: detectMockLibrary(content),
+        qualityScore: scoreUnitTestFile(content),
+        parameterizedExpansions: expandedTests.reduce((sum, test) => typeof test.variantCount === 'number' ? sum + test.variantCount : sum, 0),
+        assertionCount: countAssertions(content, graph, testFile),
+        injectedTargets,
+        coveredMethods,
+        businessRules: extractBusinessRules(content),
+    };
+}
+function detectLanguageFromPath(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    if (ext === '.java')
+        return 'java';
+    if (ext === '.kt' || ext === '.kts')
+        return 'kotlin';
+    if (ext === '.py')
+        return 'python';
+    if (ext === '.ts' || ext === '.tsx')
+        return 'typescript';
+    return 'javascript';
+}
+function extractInjectedTargets(content) {
+    const targets = [];
+    const regex = /@InjectMocks[\s\S]{0,1000}?(?:private|protected|public|internal)?\s*([A-Z]\w*)\s+([a-zA-Z_]\w*)\s*(?:=|;)/g;
+    let match;
+    while ((match = regex.exec(content)) !== null) {
+        targets.push({ className: match[1], variableName: match[2] });
+    }
+    const kotlinRegex = /@InjectMocks[\s\S]{0,1000}?(?:private|protected|public|internal)?\s*(?:lateinit\s+)?var\s+([a-zA-Z_]\w*)\s*:\s*([A-Z]\w*)/g;
+    while ((match = kotlinRegex.exec(content)) !== null) {
+        targets.push({ className: match[2], variableName: match[1] });
+    }
+    return dedupeBy(targets, (target) => `${target.className}:${target.variableName}`);
+}
+function extractCoveredMethods(content, injectedTargets) {
+    const methods = [];
+    for (const target of injectedTargets) {
+        const callRegex = new RegExp(`${target.variableName}\\.([a-zA-Z_]\\w*)\\s*\\(`, 'g');
+        let match;
+        while ((match = callRegex.exec(content)) !== null) {
+            methods.push({
+                serviceId: target.className,
+                methodName: match[1],
+                qualifiedMethod: `${target.className}.${match[1]}`,
+            });
+        }
+    }
+    return dedupeBy(methods, (method) => method.qualifiedMethod);
+}
+function extractBusinessRules(content) {
+    const names = [];
+    const testNameRegexes = [
+        /@Test[\s\S]{0,120}?(?:void|fun)\s+(\w+)\s*\(/g,
+        /@ParameterizedTest[\s\S]{0,120}?(?:void|fun)\s+(\w+)\s*\(/g,
+        /@DisplayName\(\s*["'`]([^"'`]+)["'`]\s*\)/g,
+    ];
+    for (const regex of testNameRegexes) {
+        let match;
+        while ((match = regex.exec(content)) !== null) {
+            const normalized = normalizeBusinessRule(match[1]);
+            if (normalized) {
+                names.push(normalized);
+            }
+        }
+    }
+    return dedupeBy(names, (name) => name);
+}
+function normalizeBusinessRule(rawName) {
+    const words = rawName
+        .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+        .replace(/[_-]+/g, ' ')
+        .toLowerCase()
+        .split(/\s+/)
+        .filter(Boolean)
+        .filter((word) => ![
+        'should',
+        'test',
+        'successfully',
+        'when',
+        'then',
+        'given',
+        'throws',
+        'throw',
+        'exception',
+        'returns',
+        'return',
+        'with',
+        'method',
+        'case',
+    ].includes(word));
+    if (words.length === 0)
+        return undefined;
+    return words.slice(0, 4).join(' ');
+}
+function detectMockLibrary(content) {
+    if (/@Mock\b|Mockito\.|@InjectMocks\b|@ExtendWith\(MockitoExtension/i.test(content)) {
+        return 'mockito';
+    }
+    if (/mockk|every\s*\{|verify\s*\{|\.should\(\)\.have\./i.test(content)) {
+        return 'mockk';
+    }
+    if (/jest\.mock|jest\.spyOn/.test(content)) {
+        return 'jest';
+    }
+    if (/mocker\.|unittest\.mock|pytest-mock/.test(content)) {
+        return 'pytest-mock';
+    }
+    return undefined;
+}
+function countAssertions(graphContent, graph, testFile) {
+    var _a, _b, _c;
+    const matches = graphContent.match(/assertThat\s*\(|assertEquals\s*\(|assertNotNull\s*\(|assertTrue\s*\(|assertFalse\s*\(|assertThrows\s*\(|expect\s*\(|Mockito\.verify\s*\(|verify\s*\(/g);
+    const contentCount = (_a = matches === null || matches === void 0 ? void 0 : matches.length) !== null && _a !== void 0 ? _a : 0;
+    const assertionNode = graph.getNode(`assertion:${testFile}`);
+    const graphCount = Number((_c = (_b = assertionNode === null || assertionNode === void 0 ? void 0 : assertionNode.metadata) === null || _b === void 0 ? void 0 : _b.assertionCount) !== null && _c !== void 0 ? _c : 0);
+    return Math.max(contentCount, graphCount);
+}
+function scoreUnitTestFile(content) {
+    let score = 0;
+    const hasSpecificAssertions = /assertThat\s*\(|assertEquals\s*\(|expect\([^)]*\)\.(?:toEqual|toBe|toContain|toStrictEqual)/.test(content);
+    const hasFluentAssertions = /assertThat\s*\([\s\S]*?\)\.is|\.should\(\)\.have\./i.test(content);
+    const hasWeakAssertions = /assertTrue\s*\(|assertNotNull\s*\(/.test(content);
+    const hasAnyAssertion = hasSpecificAssertions || hasFluentAssertions || hasWeakAssertions || /assertThrows\s*\(/.test(content);
+    if (hasSpecificAssertions)
+        score += 25;
+    else if (hasFluentAssertions)
+        score += 15;
+    else if (!hasAnyAssertion)
+        score -= 10;
+    const hasInjectMocks = /@InjectMocks\b/.test(content);
+    const hasMocks = /@Mock\b|mockk|jest\.mock|mocker\.|spyOn/.test(content);
+    const hasVerify = /Mockito\.verify\s*\(|verify\s*\(|\.should\(\)\.have\./.test(content);
+    const mocksClassUnderTest = /@Mock[\s\S]{0,80}?([A-Z]\w*Service|[A-Z]\w*Controller)\s+[a-zA-Z_]\w*/.test(content) && !hasInjectMocks;
+    const usesRealExternalCalls = /new\s+RestTemplate|WebClient\.builder|axios\.|fetch\s*\(|httpClient\./.test(content);
+    if (hasInjectMocks && hasMocks)
+        score += 25;
+    else if (hasVerify)
+        score += 15;
+    else if (mocksClassUnderTest)
+        score -= 10;
+    else if (!hasMocks && usesRealExternalCalls)
+        score -= 15;
+    const descriptiveName = /(?:void|fun)\s+should[A-Z]\w+When[A-Z]\w+\s*\(/.test(content)
+        || /(?:void|fun)\s+should[A-Z]\w{10,}\s*\(/.test(content);
+    const hasDisplayName = /@DisplayName\(\s*["'`][^"'`]{10,}["'`]\s*\)/.test(content);
+    if (descriptiveName)
+        score += 20;
+    else if (hasDisplayName)
+        score += 10;
+    const coversEdgeCases = /\bnull\b|\bempty\b|\bboundary\b|\bmax\b|\bmin\b|\bzero\b|\bblank\b|\bnegative\b/i.test(content);
+    const coversErrorPath = /assertThrows|exception|invalid|notFound|failure|error/i.test(content);
+    if (coversEdgeCases)
+        score += 20;
+    else if (coversErrorPath)
+        score += 10;
+    if (!/@SpringBootTest\b/.test(content))
+        score += 10;
+    else if (/@MockBean\b/.test(content))
+        score += 5;
+    else
+        score -= 10;
+    return Math.max(0, Math.min(100, score));
+}
+function resolveEndpointsForMethod(graph, coveredMethod) {
+    const queue = findMethodNodeIds(graph, coveredMethod);
+    const visited = new Set();
+    const endpoints = new Map();
+    while (queue.length > 0) {
+        const currentId = queue.shift();
+        if (!currentId)
+            continue;
+        if (visited.has(currentId))
+            continue;
+        visited.add(currentId);
+        for (const edge of graph.getEdgesFrom(currentId)) {
+            if (edge.type === 'defines') {
+                const endpoint = graph.getNode(edge.targetNodeId);
+                if ((endpoint === null || endpoint === void 0 ? void 0 : endpoint.type) === 'endpoint') {
+                    endpoints.set(endpoint.id, endpoint);
+                }
+            }
+        }
+        for (const incomingEdge of graph.getEdgesTo(currentId)) {
+            if (incomingEdge.type === 'calls' && !visited.has(incomingEdge.sourceNodeId)) {
+                queue.push(incomingEdge.sourceNodeId);
+            }
+        }
+    }
+    return Array.from(endpoints.values());
+}
+function findMethodNodeIds(graph, coveredMethod) {
+    const allNodes = graph.getAllNodes();
+    return allNodes
+        .filter((node) => node.type === 'function' || node.type === 'service' || node.type === 'class')
+        .filter((node) => {
+        const label = node.label.toLowerCase();
+        const id = node.id.toLowerCase();
+        return (label === coveredMethod.methodName.toLowerCase()
+            || id.includes(coveredMethod.qualifiedMethod.toLowerCase())
+            || id.includes(`${coveredMethod.serviceId.toLowerCase()}:${coveredMethod.methodName.toLowerCase()}`));
+    })
+        .map((node) => node.id);
+}
+function dedupeBy(items, keySelector) {
+    const seen = new Set();
+    const deduped = [];
+    for (const item of items) {
+        const key = keySelector(item);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        deduped.push(item);
+    }
+    return deduped;
+}

package/dist/src/pipeline/stages/tia/testLayerClassifier.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"testLayerClassifier.d.ts","sourceRoot":"","sources":["../../../../../src/pipeline/stages/tia/testLayerClassifier.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AA8GlD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,MAAM,GACf,kBAAkB,CA0DpB"}
+{"version":3,"file":"testLayerClassifier.d.ts","sourceRoot":"","sources":["../../../../../src/pipeline/stages/tia/testLayerClassifier.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AA6HlD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,MAAM,GACf,kBAAkB,CA0DpB"}

package/dist/src/pipeline/stages/tia/testLayerClassifier.js

@@ -58,12 +58,16 @@ const CLASSIFICATION_RULES = [
     },
     {
         layer: 'performance',
-        directoryPatterns: [/\bperformance\b/i, /\bperf\b/i, /\bload\b/i, /\bstress\b/i, /\bbenchmark\b/i],
-        fileNamePatterns: [/\.perf\./i, /\.bench\./i, /\.load\./i, /\.k6\./i],
+        directoryPatterns: [/\bperformance\b/i, /\bperformance-tests\b/i, /\bperf\b/i, /\bload\b/i, /\bstress\b/i, /\bbenchmark\b/i],
+        fileNamePatterns: [/\.perf\./i, /\.bench\./i, /\.load\./i, /\.k6\./i, /Simulation\.(java|kt)$/i],
         contentPatterns: [
             /import\s.*k6/, // k6
             /from\s+['"]k6/,
             /io\.gatling/i, // Gatling
+            /extends\s+Simulation\b/, // Gatling Java/Kotlin Simulation
+            /ScenarioBuilder|setUp\s*\(/, // Gatling scenario setup
+            /http\s*\([^)]*\)\s*\.\s*(?:get|post|put|delete)\s*\(/, // Gatling HTTP requests
+            /rampUsers\s*\(|constantUsersPerSec\s*\(|atOnceUsers\s*\(/, // Gatling load profiles
             /locust|HttpUser|TaskSet/i, // Locust
             /import\s.*artillery/i, // Artillery
             /autocannon/i, // Autocannon
@@ -99,14 +103,18 @@ const CLASSIFICATION_RULES = [
     },
     {
         layer: 'integration',
-        directoryPatterns: [/\bintegration\b/i, /\bint[-_]?test\b/i],
-        fileNamePatterns: [/\.integration\./i, /\.int\./i, /IT\.java$/],
+        directoryPatterns: [/\bintegration\b/i, /\bintegration-tests\b/i, /\bcontract-tests\b/i, /\bint[-_]?test\b/i],
+        fileNamePatterns: [/\.integration\./i, /\.int\./i, /IT\.(java|kt)$/i, /IntegrationTest\.(java|kt)$/i],
         contentPatterns: [
             /@SpringBootTest/, // Spring Boot integration test
+            /@AutoConfigureMockMvc/, // Spring MockMvc integration
             /TestRestTemplate/, // Spring REST testing
+            /@RestClientTest/, // Spring REST client slice
             /@Testcontainers/i, // Testcontainers
+            /@Container\b/, // Testcontainers field
             /@DataJpaTest/i, // Spring Data JPA
             /@WebMvcTest/i, // Spring MVC test
+            /extends\s+AbstractIntegrationTest\b/, // Convention-based integration base class
             /testcontainers/i, // Docker containers
             /@pytest\.fixture.*scope\s*=\s*['"]session['"]/, // pytest session-scoped fixture (DB lifecycle)
             /factory\.(?:Factory|DjangoModelFactory|SQLAlchemyModelFactory)/, // Factory Boy (real-model tests)
@@ -131,7 +139,14 @@ const CLASSIFICATION_RULES = [
         directoryPatterns: [/\bunit\b/i],
         fileNamePatterns: [/\.unit\./i],
         contentPatterns: [
-        // Unit tests are the default; no specific content patterns needed
+            /@ExtendWith\(MockitoExtension/i,
+            /@RunWith\(MockitoJUnitRunner/i,
+            /@InjectMocks\b/,
+            /Mockito\.verify\s*\(/,
+            /assertThat\([\s\S]*?\)\.is/i,
+            /assertEquals|assertNotNull|assertTrue/,
+            /given\([\s\S]*?\)\.willReturn/i,
+            /\.should\(\)\.have\./,
         ],
         priority: 10,
     },

package/dist/src/pipeline/stages/tia/tiaStage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tiaStage.d.ts","sourceRoot":"","sources":["../../../../../src/pipeline/stages/tia/tiaStage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAE3E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAWzC,qBAAa,QAAS,YAAW,aAAa,CAAC,SAAS,CAAC;IACvD,QAAQ,CAAC,IAAI,EAAG,KAAK,CAAU;IAC/B,QAAQ,CAAC,QAAQ,SAAS;IAEpB,OAAO,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,SAAS,CAAC;CAmJ5D"}
+{"version":3,"file":"tiaStage.d.ts","sourceRoot":"","sources":["../../../../../src/pipeline/stages/tia/tiaStage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAE3E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAWzC,qBAAa,QAAS,YAAW,aAAa,CAAC,SAAS,CAAC;IACvD,QAAQ,CAAC,IAAI,EAAG,KAAK,CAAU;IAC/B,QAAQ,CAAC,QAAQ,SAAS;IAEpB,OAAO,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,SAAS,CAAC;CAqJ5D"}

package/dist/src/pipeline/stages/tia/tiaStage.js

@@ -81,6 +81,7 @@ class TiaStage {
             parameterizedTests: [],
             testEndpointMappings: [],
         };
+        const testFileContents = {};
         // 1. Classify test layers
         for (const testFile of testFiles) {
             let content;
@@ -92,6 +93,7 @@ class TiaStage {
                 continue;
             }
             filesScanned.push(testFile);
+            testFileContents[testFile] = content;
             const classification = (0, testLayerClassifier_1.classifyTestLayer)(testFile, content);
             output.classifications.push(classification);
             // 2. Detect mock boundaries
@@ -103,7 +105,7 @@ class TiaStage {
             output.parameterizedTests.push(...paramTests);
         }
         // 4. Map tests to endpoints
-        output.testEndpointMappings = (0, testEndpointMapper_1.mapTestsToEndpoints)(context.graph, testFiles);
+        output.testEndpointMappings = (0, testEndpointMapper_1.mapTestsToEndpoints)(context.graph, testFiles, testFileContents);
         // 5. Populate graph with TIA-discovered nodes
         // Add mock-boundary nodes
         for (const boundary of output.mockBoundaries) {

package/dist/src/pipeline/stages/tia/types.d.ts

@@ -36,9 +36,18 @@ export interface ExpandedParameterizedTest {
  */
 export interface TestEndpointMapping {
     testFilePath: string;
-    endpointId: string;
-    evidenceType: 'explicit-url' | 'resolved-constant' | 'import-graph' | 'naming-convention' | 'framework-metadata' | 'helper-traversal' | 'page-object';
+    endpointId?: string;
+    evidenceType: 'explicit-url' | 'resolved-constant' | 'import-graph' | 'naming-convention' | 'framework-metadata' | 'helper-traversal' | 'page-object' | 'service-call' | 'business-rule';
     confidence: 'high' | 'medium' | 'low';
+    serviceId?: string;
+    businessRule?: string;
+    coveredMethod?: string;
+    layer?: string;
+    mockLibrary?: string;
+    qualityScore?: number;
+    parameterizedExpansions?: number;
+    assertionCount?: number;
+    coversEndpoint?: string;
 }
 /**
  * Output of the TIA pipeline stage.

package/dist/src/pipeline/stages/tia/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/pipeline/stages/tia/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAA4B,MAAM,aAAa,CAAC;AAEjF;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,SAAS,CAAC;IACjB,UAAU,EAAE,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAC;IACtC,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;IACvB,QAAQ,EAAE,QAAQ,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACxC,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,GAAG,cAAc,CAAC;IACtC,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,cAAc,GAAG,mBAAmB,GAAG,cAAc,GAAG,mBAAmB,GAAG,oBAAoB,GAAG,kBAAkB,GAAG,aAAa,CAAC;IACtJ,UAAU,EAAE,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAC;CACvC;AAED;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,eAAe,EAAE,kBAAkB,EAAE,CAAC;IACtC,cAAc,EAAE,oBAAoB,EAAE,CAAC;IACvC,kBAAkB,EAAE,yBAAyB,EAAE,CAAC;IAChD,oBAAoB,EAAE,mBAAmB,EAAE,CAAC;CAC7C"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/pipeline/stages/tia/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAA4B,MAAM,aAAa,CAAC;AAEjF;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,SAAS,CAAC;IACjB,UAAU,EAAE,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAC;IACtC,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;IACvB,QAAQ,EAAE,QAAQ,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACxC,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,GAAG,cAAc,CAAC;IACtC,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,EACR,cAAc,GACd,mBAAmB,GACnB,cAAc,GACd,mBAAmB,GACnB,oBAAoB,GACpB,kBAAkB,GAClB,aAAa,GACb,cAAc,GACd,eAAe,CAAC;IACpB,UAAU,EAAE,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAC;IACtC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,uBAAuB,CAAC,EAAE,MAAM,CAAC;IACjC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,eAAe,EAAE,kBAAkB,EAAE,CAAC;IACtC,cAAc,EAAE,oBAAoB,EAAE,CAAC;IACvC,kBAAkB,EAAE,yBAAyB,EAAE,CAAC;IAChD,oBAAoB,EAAE,mBAAmB,EAAE,CAAC;CAC7C"}

package/dist/src/projectDefaults.d.ts

@@ -0,0 +1,6 @@
+export declare const DEFAULT_DISCOVERY_EXCLUDE_DIRS: readonly ["node_modules", ".git", "dist", "build", "target", ".cache", "coverage", ".nyc_output", "__pycache__", ".pytest_cache", ".tox", "vendor", ".bundle", ".gradle"];
+export declare const DEFAULT_GENERATED_SOURCE_DIRS: readonly ["build/generated-sources", "target/generated-sources", "src/generated", "build/generated", "target/generated"];
+export declare const DEFAULT_OPENAPI_INTERFACE_SUFFIXES: readonly ["Api", "ApiDelegate", "Controller", "Resource", "Endpoint"];
+export declare const DEFAULT_OPENAPI_EXCLUDE_SUFFIXES: readonly ["Mapper", "Repository", "Dao", "Client", "Feign"];
+export declare const DEFAULT_GENERATED_SOURCE_PATH_SEGMENTS: string[];
+//# sourceMappingURL=projectDefaults.d.ts.map

package/dist/src/projectDefaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"projectDefaults.d.ts","sourceRoot":"","sources":["../../src/projectDefaults.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,8BAA8B,2KAejC,CAAC;AAEX,eAAO,MAAM,6BAA6B,0HAMhC,CAAC;AAEX,eAAO,MAAM,kCAAkC,uEAMrC,CAAC;AAEX,eAAO,MAAM,gCAAgC,6DAMnC,CAAC;AAEX,eAAO,MAAM,sCAAsC,UAMlD,CAAC"}

package/dist/src/projectDefaults.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_GENERATED_SOURCE_PATH_SEGMENTS = exports.DEFAULT_OPENAPI_EXCLUDE_SUFFIXES = exports.DEFAULT_OPENAPI_INTERFACE_SUFFIXES = exports.DEFAULT_GENERATED_SOURCE_DIRS = exports.DEFAULT_DISCOVERY_EXCLUDE_DIRS = void 0;
+exports.DEFAULT_DISCOVERY_EXCLUDE_DIRS = [
+    'node_modules',
+    '.git',
+    'dist',
+    'build',
+    'target',
+    '.cache',
+    'coverage',
+    '.nyc_output',
+    '__pycache__',
+    '.pytest_cache',
+    '.tox',
+    'vendor',
+    '.bundle',
+    '.gradle',
+];
+exports.DEFAULT_GENERATED_SOURCE_DIRS = [
+    'build/generated-sources',
+    'target/generated-sources',
+    'src/generated',
+    'build/generated',
+    'target/generated',
+];
+exports.DEFAULT_OPENAPI_INTERFACE_SUFFIXES = [
+    'Api',
+    'ApiDelegate',
+    'Controller',
+    'Resource',
+    'Endpoint',
+];
+exports.DEFAULT_OPENAPI_EXCLUDE_SUFFIXES = [
+    'Mapper',
+    'Repository',
+    'Dao',
+    'Client',
+    'Feign',
+];
+exports.DEFAULT_GENERATED_SOURCE_PATH_SEGMENTS = Array.from(new Set(exports.DEFAULT_GENERATED_SOURCE_DIRS
+    .flatMap((dir) => dir.split('/'))
+    .filter((segment) => segment.includes('generated'))));