api-tests-coverage 1.0.23 → 1.0.24

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

@@ -38,56 +38,37 @@ function expandJavaKotlinParameterized(filePath, content) {
     const lines = content.split('\n');
     for (let i = 0; i < lines.length; i++) {
         const line = lines[i].trim();
-        // @ParameterizedTest must precede the data source annotation
         if (!line.includes('@ParameterizedTest'))
             continue;
-        // Look ahead for data source annotations
         let testName = 'unknown';
         let variantCount = 'unresolvable';
         let pattern = '@ParameterizedTest';
-        for (let j = i + 1; j < Math.min(i + 10, lines.length); j++) {
+        for (let j = i + 1; j < Math.min(i + 12, lines.length); j++) {
             const nextLine = lines[j].trim();
-            // Extract test method name
-            const methodMatch = /(?:void|fun)\s+(\w+)\s*\(/.exec(nextLine);
-            if (methodMatch) {
-                testName = methodMatch[1];
-                break;
-            }
-            // @ValueSource(strings = {"a", "b", "c"})
             const valueSourceMatch = /@ValueSource\(\s*\w+\s*=\s*\{([^}]+)\}/.exec(nextLine);
             if (valueSourceMatch) {
-                variantCount = valueSourceMatch[1].split(',').length;
+                variantCount = countTopLevelArguments(valueSourceMatch[1]);
                 pattern = '@ValueSource';
-                continue;
             }
-            // @CsvSource({"a,1", "b,2", "c,3"})
             const csvSourceMatch = /@CsvSource\(\s*(?:value\s*=\s*)?\{([^}]+)\}/.exec(nextLine);
             if (csvSourceMatch) {
                 variantCount = csvSourceMatch[1].split(/",\s*"/).length;
                 pattern = '@CsvSource';
-                continue;
             }
-            // @MethodSource("methodName")
             const methodSourceMatch = /@MethodSource\(\s*"(\w+)"/.exec(nextLine);
             if (methodSourceMatch) {
                 pattern = `@MethodSource(${methodSourceMatch[1]})`;
-                // Try to find the method and count Stream.of() arguments
-                const sourceMethodRegex = new RegExp(`(?:static\\s+)?(?:Stream|List|Collection|Set).*?\\s+${methodSourceMatch[1]}\\s*\\([^)]*\\)\\s*\\{([\\s\\S]*?)\\}`, 'm');
-                const sourceMethodMatch = sourceMethodRegex.exec(content);
-                if (sourceMethodMatch) {
-                    const body = sourceMethodMatch[1];
-                    const argsMatch = body.match(/(?:Arguments\.of|of)\s*\(/g);
-                    if (argsMatch) {
-                        variantCount = argsMatch.length;
-                    }
-                }
-                continue;
+                variantCount = countMethodSourceVariants(content, methodSourceMatch[1]);
             }
-            // @EnumSource(MyEnum.class)
-            if (nextLine.includes('@EnumSource')) {
+            const enumSourceMatch = /@EnumSource\(\s*(\w+)(?:\.class|::class)/.exec(nextLine);
+            if (enumSourceMatch) {
                 pattern = '@EnumSource';
-                variantCount = 'unresolvable'; // Would need to find enum declaration
-                continue;
+                variantCount = countEnumValues(content, enumSourceMatch[1]);
+            }
+            const methodMatch = /(?:void|fun)\s+(\w+)\s*\(/.exec(nextLine);
+            if (methodMatch) {
+                testName = methodMatch[1];
+                break;
             }
         }
         results.push({
@@ -107,29 +88,33 @@ function expandJestParameterized(filePath, content) {
     const lines = content.split('\n');
     for (let i = 0; i < lines.length; i++) {
         const line = lines[i];
-        // test.each([...])('name', ...)
-        // it.each([...])('name', ...)
-        // describe.each([...])('name', ...)
-        const eachMatch = /(?:test|it|describe)\.each\s*\(\s*\[/.exec(line);
+        const lineOffset = content.indexOf(line);
+        const inlineEachMatch = /(?:test|it|describe)\.each\s*\(\s*\[/.exec(line);
+        const variableEachMatch = /(?:test|it|describe)\.each\s*\(\s*([A-Za-z_]\w*)\s*\)/.exec(line);
+        const eachMatch = inlineEachMatch !== null && inlineEachMatch !== void 0 ? inlineEachMatch : variableEachMatch;
         if (eachMatch) {
-            // Try to extract the array and count items
-            const arrayContent = extractBalancedBrackets(content, content.indexOf(eachMatch[0], i > 0 ? content.indexOf(lines[i]) : 0));
-            const variantCount = arrayContent ? countArrayElements(arrayContent) : 'unresolvable';
-            // Extract test name from the next argument
-            const nameMatch = /\)\s*\(\s*['"`]([^'"`]+)['"`]/.exec(content.substring(content.indexOf(eachMatch[0])));
+            let variantCount = 'unresolvable';
+            if (inlineEachMatch) {
+                const bracketIndex = content.indexOf('[', lineOffset);
+                const arrayContent = extractBalanced(content, bracketIndex, '[', ']');
+                variantCount = arrayContent ? countArrayElements(arrayContent) : 'unresolvable';
+            }
+            else if (variableEachMatch) {
+                variantCount = resolveNamedArrayCount(content, variableEachMatch[1]);
+            }
+            const nameMatch = /\)\s*\(\s*['"`]([^'"`]+)['"`]/.exec(content.substring(lineOffset));
             const testName = (_a = nameMatch === null || nameMatch === void 0 ? void 0 : nameMatch[1]) !== null && _a !== void 0 ? _a : 'parameterized test';
+            const callsite = eachMatch[0].split('.')[0];
             results.push({
                 testFilePath: filePath,
                 testName,
                 variantCount,
-                pattern: 'test.each',
+                pattern: inlineEachMatch ? `${callsite}.each` : `${callsite}.each(variable)`,
                 line: i + 1,
             });
         }
-        // test.each`template`('name', ...)  — tagged template form
         const templateMatch = /(?:test|it|describe)\.each\s*`/.exec(line);
         if (templateMatch && !eachMatch) {
-            // Count rows in tagged template (lines between backticks, minus header)
             let rowCount = 0;
             for (let j = i + 1; j < lines.length; j++) {
                 if (lines[j].includes('`'))
@@ -137,12 +122,11 @@ function expandJestParameterized(filePath, content) {
                 if (lines[j].trim())
                     rowCount++;
             }
-            const variantCount = rowCount > 0 ? rowCount : 'unresolvable';
             results.push({
                 testFilePath: filePath,
                 testName: 'parameterized test',
-                variantCount,
-                pattern: 'test.each (template)',
+                variantCount: rowCount > 0 ? rowCount : 'unresolvable',
+                pattern: `${templateMatch[0].split('.')[0]}.each (template)`,
                 line: i + 1,
             });
         }
@@ -155,48 +139,61 @@ function expandPytestParameterized(filePath, content) {
     const lines = content.split('\n');
     for (let i = 0; i < lines.length; i++) {
         const line = lines[i].trim();
-        // @pytest.mark.parametrize("name", [...])
         const paramMatch = /@pytest\.mark\.parametrize\s*\(/.exec(line);
         if (paramMatch) {
-            // Try to extract array content and count elements
             let variantCount = 'unresolvable';
-            // Look for the bracket content
             const fullContent = lines.slice(i, Math.min(i + 20, lines.length)).join('\n');
-            const bracketContent = extractBalancedBrackets(fullContent, fullContent.indexOf('['));
+            const bracketContent = extractBalanced(fullContent, fullContent.indexOf('['), '[', ']');
             if (bracketContent) {
                 variantCount = countPytestParams(bracketContent);
             }
-            // Extract test name from following def line
-            let testName = 'unknown';
-            for (let j = i + 1; j < Math.min(i + 10, lines.length); j++) {
-                const defMatch = /def\s+(\w+)\s*\(/.exec(lines[j]);
-                if (defMatch) {
-                    testName = defMatch[1];
-                    break;
-                }
-            }
             results.push({
                 testFilePath: filePath,
-                testName,
+                testName: findPythonDefinitionName(lines, i),
                 variantCount,
                 pattern: '@pytest.mark.parametrize',
                 line: i + 1,
             });
         }
+        const fixtureMatch = /@pytest\.fixture\s*\(\s*params\s*=\s*\[/.exec(line);
+        if (fixtureMatch) {
+            let variantCount = 'unresolvable';
+            const fullContent = lines.slice(i, Math.min(i + 20, lines.length)).join('\n');
+            const bracketContent = extractBalanced(fullContent, fullContent.indexOf('['), '[', ']');
+            if (bracketContent) {
+                variantCount = countPytestParams(bracketContent);
+            }
+            results.push({
+                testFilePath: filePath,
+                testName: findPythonDefinitionName(lines, i),
+                variantCount,
+                pattern: '@pytest.fixture(params)',
+                line: i + 1,
+            });
+        }
     }
     return results;
 }
 // ─── Helpers ─────────────────────────────────────────────────────────────────
-function extractBalancedBrackets(content, startIndex) {
-    if (startIndex < 0 || startIndex >= content.length || content[startIndex] !== '[') {
+function findPythonDefinitionName(lines, startIndex) {
+    for (let j = startIndex + 1; j < Math.min(startIndex + 10, lines.length); j++) {
+        const defMatch = /def\s+(\w+)\s*\(/.exec(lines[j]);
+        if (defMatch) {
+            return defMatch[1];
+        }
+    }
+    return 'unknown';
+}
+function extractBalanced(content, startIndex, openChar, closeChar) {
+    if (startIndex < 0 || startIndex >= content.length || content[startIndex] !== openChar) {
         return undefined;
     }
     let depth = 0;
     let i = startIndex;
     while (i < content.length) {
-        if (content[i] === '[')
+        if (content[i] === openChar)
             depth++;
-        else if (content[i] === ']') {
+        else if (content[i] === closeChar) {
             depth--;
             if (depth === 0) {
                 return content.substring(startIndex + 1, i);
@@ -207,32 +204,108 @@ function extractBalancedBrackets(content, startIndex) {
     return undefined;
 }
 function countArrayElements(arrayContent) {
-    // Count top-level elements (not nested)
+    const trimmed = arrayContent.trim();
+    if (trimmed.length === 0)
+        return 0;
     let depth = 0;
-    let count = 1;
+    let count = 0;
+    let segmentHasContent = false;
     for (const char of arrayContent) {
-        if (char === '[' || char === '(' || char === '{')
+        if (char === '[' || char === '(' || char === '{') {
             depth++;
-        else if (char === ']' || char === ')' || char === '}')
+            segmentHasContent = true;
+        }
+        else if (char === ']' || char === ')' || char === '}') {
             depth--;
-        else if (char === ',' && depth === 0)
-            count++;
+        }
+        else if (char === ',' && depth === 0) {
+            if (segmentHasContent) {
+                count++;
+                segmentHasContent = false;
+            }
+            continue;
+        }
+        else if (!/\s/.test(char)) {
+            segmentHasContent = true;
+        }
     }
-    // If only whitespace, return 0
-    if (arrayContent.trim().length === 0)
+    return segmentHasContent ? count + 1 : count;
+}
+function countTopLevelArguments(content) {
+    const trimmed = content.trim();
+    if (!trimmed)
         return 0;
-    return count;
+    return countArrayElements(trimmed);
 }
 function countPytestParams(bracketContent) {
-    // Each top-level tuple/value is a test case
     const trimmed = bracketContent.trim();
     if (!trimmed)
         return 0;
-    // Count top-level commas for simple values
-    // For tuples, count each (...) group
-    const tupleMatches = trimmed.match(/\([^)]*\)/g);
-    if (tupleMatches)
-        return tupleMatches.length;
-    // Otherwise count comma-separated values
+    const tupleCount = countTopLevelTuples(trimmed);
+    if (tupleCount > 0)
+        return tupleCount;
     return countArrayElements(trimmed);
 }
+function countMethodSourceVariants(content, methodName) {
+    var _a;
+    const sourceMethodRegex = new RegExp(`(?:static\\s+)?(?:[\\w<>,?]+\\s+)+${methodName}\\s*\\([^)]*\\)\\s*\\{([\\s\\S]*?)\\}`, 'm');
+    const sourceMethodMatch = sourceMethodRegex.exec(content);
+    if (!sourceMethodMatch)
+        return 'unresolvable';
+    const body = sourceMethodMatch[1];
+    const argsMatch = body.match(/Arguments\.of\s*\(/g);
+    if (argsMatch) {
+        return argsMatch.length;
+    }
+    const collectionMatch = (_a = body.match(/(?:Stream|List|Sequence|Collection|Set)\.of\s*\(([\s\S]*?)\)/m)) !== null && _a !== void 0 ? _a : body.match(/(?:listOf|arrayOf|sequenceOf|setOf)\s*\(([\s\S]*?)\)/m);
+    if (collectionMatch) {
+        return countTopLevelArguments(collectionMatch[1]);
+    }
+    return 'unresolvable';
+}
+function countEnumValues(content, enumName) {
+    const enumRegex = new RegExp(`enum(?:\\s+class)?\\s+${enumName}\\s*(?::[^\\{]+)?\\{([\\s\\S]*?)\\}`, 'm');
+    const enumMatch = enumRegex.exec(content);
+    if (!enumMatch)
+        return 'unresolvable';
+    const body = enumMatch[1]
+        .replace(/\/\*[\s\S]*?\*\//g, '')
+        .replace(/\/\/.*$/gm, '');
+    const values = body
+        .split(',')
+        .map((value) => value.trim())
+        .filter((value) => value.length > 0)
+        .map((value) => value.replace(/\([^)]*\).*/, '').trim())
+        .filter((value) => /^[A-Z][A-Za-z0-9_]*$/.test(value));
+    return values.length > 0 ? values.length : 'unresolvable';
+}
+function resolveNamedArrayCount(content, variableName) {
+    const declarationRegex = new RegExp(`(?:const|let|var)\\s+${variableName}\\s*=\\s*\\[`, 'm');
+    const declarationMatch = declarationRegex.exec(content);
+    if (!declarationMatch)
+        return 'unresolvable';
+    const bracketIndex = declarationMatch.index + declarationMatch[0].length - 1;
+    const arrayContent = extractBalanced(content, bracketIndex, '[', ']');
+    return arrayContent ? countArrayElements(arrayContent) : 'unresolvable';
+}
+function countTopLevelTuples(content) {
+    let depth = 0;
+    let count = 0;
+    let tupleStarted = false;
+    for (const char of content) {
+        if (char === '(') {
+            depth++;
+            if (depth === 1) {
+                tupleStarted = true;
+            }
+        }
+        else if (char === ')') {
+            if (depth === 1 && tupleStarted) {
+                count++;
+                tupleStarted = false;
+            }
+            depth = Math.max(0, depth - 1);
+        }
+    }
+    return count;
+}

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

@@ -9,6 +9,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
  */
 import type { TestEndpointMapping } from './types';
 import type { CoverageKnowledgeGraph } from '../../graph';
@@ -17,6 +19,8 @@ import type { CoverageKnowledgeGraph } from '../../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.
  */
-export declare function mapTestsToEndpoints(graph: CoverageKnowledgeGraph, testFiles: string[]): TestEndpointMapping[];
+export declare function mapTestsToEndpoints(graph: CoverageKnowledgeGraph, testFiles: string[], fileContents?: Record<string, string>): TestEndpointMapping[];
 //# sourceMappingURL=testEndpointMapper.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"testEndpointMapper.d.ts","sourceRoot":"","sources":["../../../../../src/pipeline/stages/tia/testEndpointMapper.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAEnD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAG1D;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,sBAAsB,EAC7B,SAAS,EAAE,MAAM,EAAE,GAClB,mBAAmB,EAAE,CAqFvB"}
+{"version":3,"file":"testEndpointMapper.d.ts","sourceRoot":"","sources":["../../../../../src/pipeline/stages/tia/testEndpointMapper.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAEnD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AA4B1D;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,sBAAsB,EAC7B,SAAS,EAAE,MAAM,EAAE,EACnB,YAAY,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAM,GACxC,mBAAmB,EAAE,CAyJvB"}