Installer avec Codex ou Claude Copiez ce prompt, collez-le dans Codex, Claude ou un autre assistant, puis laissez-le vérifier la page du skill et l'installer pour vous.
Une commande directe contourne le prompt de vérification. Examinez la source avant de l'exécuter.
Test coverage analysis identifies which parts of the codebase are exercised by the test suite and, more importantly, which parts are not. Raw coverage percentages are misleading without context: 80% statement coverage might mean the most critical error-handling paths are completely untested while trivial getters are thoroughly covered. This skill guides AI coding agents through comprehensive coverage gap analysis that goes beyond percentages to identify high-risk untested code, enforce coverage on new changes, and generate actionable test recommendations.
Core Principles
Coverage Is a Diagnostic Tool, Not a Goal: High coverage does not guarantee test quality. A test that executes every line without meaningful assertions provides coverage with zero defect detection capability. Use coverage to find what is missing, not as proof of quality.
Branch Coverage Over Statement Coverage: Statement coverage counts whether a line executed; branch coverage counts whether both true and false paths of every conditional executed. A function with an early return can have 100% statement coverage but 50% branch coverage if only one path is tested.
Risk-Weighted Coverage: Not all code carries equal risk. Payment processing, authentication, and data validation deserve 100% coverage. Configuration constants and simple data transfer objects do not. Prioritize coverage gaps by business risk.
Change-Based Coverage Is Non-Negotiable: Tracking coverage of new and modified code ensures that every change ships with tests. Legacy code coverage gaps are inherited, but new gaps are preventable.
Dead Code Is Not a Coverage Gap: Code that is never reached in production is not an untested path needing tests; it is dead code needing removal. Distinguish between untested live code and genuinely unreachable code before writing tests.
Coverage Trends Matter More Than Snapshots: A codebase at 70% coverage and improving is healthier than one at 85% and declining. Track coverage over time to detect erosion before it becomes a problem.
Exclude What Does Not Belong: Generated code, vendor libraries, type definitions, and configuration files inflate or deflate coverage numbers without providing signal. Exclude them to keep coverage metrics meaningful.
Understanding the differences between coverage types is essential for accurate gap analysis.
// src/services/payment.service.tsexportclassPaymentService {
asyncprocessPayment(amount: number, method: string): Promise<PaymentResult> {
// Statement: this line is line 1if (amount <= 0) {
// Branch A (true): amount is invalidthrownewPaymentError('Invalid amount');
}
// Branch A (false): amount is valid - falls through// Statement: this line is line 2if (method === 'credit_card') {
// Branch B (true): credit card pathreturnthis.processCreditCard(amount);
} elseif (method === 'paypal') {
// Branch C (true): PayPal pathreturnthis.processPayPal(amount);
} else {
// Branch D (default): unsupported methodthrownewPaymentError(`Unsupported payment method: ${method}`);
}
}
}
// TEST: Only tests the credit card happy pathdescribe('PaymentService', () => {
it('processes credit card payment', async () => {
const service = newPaymentService();
const result = await service.processPayment(100, 'credit_card');
expect(result.status).toBe('success');
});
});
// Coverage analysis:// Statement coverage: ~60% (lines 1-2 executed, but PayPal and error paths not)// Branch coverage: ~33% (only Branch A-false and Branch B-true)// Function coverage: ~33% (processPayment called, but not processPayPal)// GAPS: negative amount, PayPal path, unsupported method path
Comprehensive Gap Analysis Script
// scripts/coverage-gap-analysis.tsimport * as fs from'fs';
import * as path from'path';
interfaceCoverageEntry {
path: string;
statementMap: Record<string, { start: Location; end: Location }>;
s: Record<string, number>; // Statement hit countsbranchMap: Record<string, { type: string; loc: Location; locations: Location[] }>;
b: Record<string, number[]>; // Branch hit counts per branchfnMap: Record<string, { name: string; loc: Location; decl: Location }>;
f: Record<string, number>; // Function hit counts
}
interfaceLocation {
line: number;
column: number;
}
interfaceCoverageGap {
file: string;
type: 'statement' | 'branch' | 'function';
location: { startLine: number; endLine: number };
description: string;
riskLevel: 'critical' | 'high' | 'medium' | 'low';
suggestion: string;
}
functionanalyzeCoverageGaps(coverageJsonPath: string): CoverageGap[] {
constcoverageData: Record<string, CoverageEntry> = JSON.parse(
fs.readFileSync(coverageJsonPath, 'utf-8')
);
constgaps: CoverageGap[] = [];
for (const [filePath, entry] ofObject.entries(coverageData)) {
const relativePath = path.relative(process.cwd(), filePath);
// Find uncovered statementsfor (const [stmtId, hitCount] ofObject.entries(entry.s)) {
if (hitCount === 0) {
const loc = entry.statementMap[stmtId];
gaps.push({
file: relativePath,
type: 'statement',
location: { startLine: loc.start.line, endLine: loc.end.line },
description: `Uncovered statement at line ${loc.start.line}`,
riskLevel: assessRisk(relativePath, loc.start.line),
suggestion: `Add a test that exercises the code path at line ${loc.start.line}`,
});
}
}
// Find uncovered branchesfor (const [branchId, hitCounts] ofObject.entries(entry.b)) {
const branchInfo = entry.branchMap[branchId];
hitCounts.forEach((count, index) => {
if (count === 0) {
const loc = branchInfo.locations[index] || branchInfo.loc;
const branchType = index === 0 ? 'true' : 'false';
gaps.push({
file: relativePath,
type: 'branch',
location: { startLine: loc.line, endLine: loc.line },
description: `Uncovered ${branchType} branch of ${branchInfo.type} at line ${branchInfo.loc.line}`,
riskLevel: assessRisk(relativePath, loc.line),
suggestion: `Add a test for the ${branchType} path of the ${branchInfo.type} conditional at line ${branchInfo.loc.line}`,
});
}
});
}
// Find uncovered functionsfor (const [fnId, hitCount] ofObject.entries(entry.f)) {
if (hitCount === 0) {
const fnInfo = entry.fnMap[fnId];
gaps.push({
file: relativePath,
type: 'function',
location: { startLine: fnInfo.loc.start.line, endLine: fnInfo.loc.end.line },
description: `Uncovered function "${fnInfo.name}" at line ${fnInfo.loc.start.line}`,
riskLevel: assessRisk(relativePath, fnInfo.loc.start.line),
suggestion: `Add tests for the "${fnInfo.name}" function covering its main paths`,
});
}
}
}
return gaps.sort((a, b) => {
const riskOrder = { critical: 0, high: 1, medium: 2, low: 3 };
return riskOrder[a.riskLevel] - riskOrder[b.riskLevel];
});
}
functionassessRisk(filePath: string, line: number): 'critical' | 'high' | 'medium' | 'low' {
// Critical: payment, auth, securityif (/payment|billing|charge|refund/i.test(filePath)) return'critical';
if (/auth|login|session|token|password/i.test(filePath)) return'critical';
if (/security|encrypt|decrypt|hash/i.test(filePath)) return'critical';
// High: data validation, API controllersif (/valid|sanitiz|controller|handler/i.test(filePath)) return'high';
if (/service/i.test(filePath)) return'high';
// Medium: utilities, helpersif (/util|helper|format/i.test(filePath)) return'medium';
// Low: configuration, constants, typesif (/config|constant|type|interface/i.test(filePath)) return'low';
return'medium';
}
// Run analysisconst gaps = analyzeCoverageGaps('coverage/coverage-final.json');
console.log(`\nCoverage Gap Analysis Report`);
console.log(`${'='.repeat(60)}`);
console.log(`Total gaps found: ${gaps.length}`);
console.log(` Critical: ${gaps.filter((g) => g.riskLevel === 'critical').length}`);
console.log(` High: ${gaps.filter((g) => g.riskLevel === 'high').length}`);
console.log(` Medium: ${gaps.filter((g) => g.riskLevel === 'medium').length}`);
console.log(` Low: ${gaps.filter((g) => g.riskLevel === 'low').length}`);
console.log(`\nTop Priority Gaps:`);
gaps.slice(0, 20).forEach((gap, i) => {
console.log(` ${i + 1}. [${gap.riskLevel.toUpperCase()}] ${gap.file}:${gap.location.startLine}`);
console.log(` ${gap.description}`);
console.log(` Suggestion: ${gap.suggestion}`);
});
fs.writeFileSync('coverage/gap-analysis.json', JSON.stringify(gaps, null, 2));
Change-Based Coverage
Change-based coverage tracks whether newly added or modified lines are covered by tests. This is the most actionable form of coverage enforcement because it prevents new gaps without requiring retroactive testing of legacy code.
// scripts/change-coverage.tsimport { execSync } from'child_process';
import * as fs from'fs';
interfaceChangedLine {
file: string;
line: number;
type: 'added' | 'modified';
}
interfaceChangeCoverageResult {
totalChangedLines: number;
coveredLines: number;
uncoveredLines: ChangedLine[];
coveragePercentage: number;
}
functiongetChangedLines(baseBranch: string = 'main'): ChangedLine[] {
const diffOutput = execSync(`git diff ${baseBranch}...HEAD --unified=0 --diff-filter=AM`, {
encoding: 'utf-8',
});
constchangedLines: ChangedLine[] = [];
let currentFile = '';
for (const line of diffOutput.split('\n')) {
// Match file headerconst fileMatch = line.match(/^\+\+\+ b\/(.+)$/);
if (fileMatch) {
currentFile = fileMatch[1];
continue;
}
// Match hunk header: @@ -oldStart,oldCount +newStart,newCount @@const hunkMatch = line.match(/^@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@/);
if (hunkMatch) {
const startLine = parseInt(hunkMatch[1], 10);
const lineCount = parseInt(hunkMatch[2] || '1', 10);
// Only track source files, not testsif (
currentFile.match(/\.(ts|tsx|js|jsx|py|java)$/) &&
!currentFile.match(/\.(test|spec|__test__|_test)\./i) &&
!currentFile.includes('__mocks__')
) {
for (let i = 0; i < lineCount; i++) {
changedLines.push({
file: currentFile,
line: startLine + i,
type: 'added',
});
}
}
}
}
return changedLines;
}
functioncheckChangeCoverage(baseBranch: string = 'main'): ChangeCoverageResult {
const changedLines = getChangedLines(baseBranch);
if (changedLines.length === 0) {
console.log('No source file changes detected.');
return { totalChangedLines: 0, coveredLines: 0, uncoveredLines: [], coveragePercentage: 100 };
}
// Load coverage dataconst coverageData = JSON.parse(
fs.readFileSync('coverage/coverage-final.json', 'utf-8')
);
constuncoveredLines: ChangedLine[] = [];
let coveredCount = 0;
for (const change of changedLines) {
const absolutePath = `${process.cwd()}/${change.file}`;
const fileCoverage = coverageData[absolutePath];
if (!fileCoverage) {
// File has no coverage data at all
uncoveredLines.push(change);
continue;
}
// Check if this specific line is coveredlet lineCovered = false;
for (const [stmtId, stmtLoc] ofObject.entries(fileCoverage.statementMap)) {
const loc = stmtLoc asany;
if (change.line >= loc.start.line && change.line <= loc.end.line) {
if (fileCoverage.s[stmtId] > 0) {
lineCovered = true;
break;
}
}
}
if (lineCovered) {
coveredCount++;
} else {
uncoveredLines.push(change);
}
}
constresult: ChangeCoverageResult = {
totalChangedLines: changedLines.length,
coveredLines: coveredCount,
uncoveredLines,
coveragePercentage:
changedLines.length > 0 ? (coveredCount / changedLines.length) * 100 : 100,
};
return result;
}
// Run change-based coverage checkconst result = checkChangeCoverage(process.argv[2] || 'main');
console.log('\nChange-Based Coverage Report');
console.log('='.repeat(50));
console.log(`Changed lines: ${result.totalChangedLines}`);
console.log(`Covered: ${result.coveredLines}`);
console.log(`Uncovered: ${result.uncoveredLines.length}`);
console.log(`Coverage: ${result.coveragePercentage.toFixed(1)}%`);
if (result.uncoveredLines.length > 0) {
console.log('\nUncovered changed lines:');
const byFile = newMap<string, number[]>();
for (const line of result.uncoveredLines) {
if (!byFile.has(line.file)) byFile.set(line.file, []);
byFile.get(line.file)!.push(line.line);
}
for (const [file, lines] of byFile) {
console.log(` ${file}: lines ${lines.join(', ')}`);
}
}
// Enforce minimum change coverageconstMIN_CHANGE_COVERAGE = 90;
if (result.coveragePercentage < MIN_CHANGE_COVERAGE) {
console.error(
`\nFAILED: Change coverage ${result.coveragePercentage.toFixed(1)}% is below minimum ${MIN_CHANGE_COVERAGE}%`
);
process.exit(1);
} else {
console.log(`\nPASSED: Change coverage meets minimum threshold of ${MIN_CHANGE_COVERAGE}%`);
}
// scripts/suggest-tests.tsimport * as fs from'fs';
interfaceTestSuggestion {
file: string;
functionName: string;
line: number;
uncoveredBranches: string[];
suggestedTestCases: string[];
priority: number;
}
functiongenerateTestSuggestions(): TestSuggestion[] {
const coverageData = JSON.parse(
fs.readFileSync('coverage/coverage-final.json', 'utf-8')
);
constsuggestions: TestSuggestion[] = [];
for (const [filePath, entry] ofObject.entries(coverageData)) {
const fileEntry = entry asany;
const relativePath = filePath.replace(process.cwd() + '/', '');
const sourceCode = fs.readFileSync(filePath, 'utf-8').split('\n');
// Analyze uncovered branchesfor (const [branchId, hitCounts] ofObject.entries(fileEntry.b)) {
const counts = hitCounts asnumber[];
const branchInfo = fileEntry.branchMap[branchId];
const uncoveredIndices = counts
.map((count, idx) => (count === 0 ? idx : -1))
.filter((idx) => idx >= 0);
if (uncoveredIndices.length === 0) continue;
// Read source code around the branch to understand contextconst branchLine = branchInfo.loc.start.line - 1;
const contextLines = sourceCode.slice(
Math.max(0, branchLine - 2),
Math.min(sourceCode.length, branchLine + 3)
);
const context = contextLines.join('\n');
constsuggestedCases: string[] = [];
// Infer test cases from branch type and contextif (branchInfo.type === 'if') {
if (context.includes('null') || context.includes('undefined')) {
suggestedCases.push('Test with null/undefined input');
}
if (context.includes('.length') || context.includes('Array.isArray')) {
suggestedCases.push('Test with empty array');
suggestedCases.push('Test with populated array');
}
if (context.includes('> 0') || context.includes('< 0') || context.includes('=== 0')) {
suggestedCases.push('Test with zero value');
suggestedCases.push('Test with negative value');
suggestedCases.push('Test with positive value');
}
if (context.includes('throw') || context.includes('Error')) {
suggestedCases.push('Test error throwing condition');
}
}
if (suggestedCases.length === 0) {
uncoveredIndices.forEach((idx) => {
suggestedCases.push(`Test the ${idx === 0 ? 'true' : 'false'} branch at line ${branchInfo.loc.start.line}`);
});
}
suggestions.push({
file: relativePath,
functionName: findContainingFunction(fileEntry.fnMap, branchInfo.loc.start.line),
line: branchInfo.loc.start.line,
uncoveredBranches: uncoveredIndices.map((idx) =>`Branch ${idx}`),
suggestedTestCases: suggestedCases,
priority: assessTestPriority(relativePath),
});
}
}
return suggestions.sort((a, b) => b.priority - a.priority);
}
functionfindContainingFunction(fnMap: Record<string, any>, line: number): string {
for (const fn ofObject.values(fnMap)) {
if (line >= fn.loc.start.line && line <= fn.loc.end.line) {
return fn.name || 'anonymous';
}
}
return'unknown';
}
functionassessTestPriority(filePath: string): number {
if (/payment|auth|security/i.test(filePath)) return10;
if (/service|controller/i.test(filePath)) return7;
if (/validator|sanitiz/i.test(filePath)) return8;
if (/util|helper/i.test(filePath)) return5;
return3;
}
const suggestions = generateTestSuggestions();
console.log('\nTest Generation Suggestions');
console.log('='.repeat(60));
suggestions.slice(0, 15).forEach((s, i) => {
console.log(`\n${i + 1}. ${s.file} - ${s.functionName}() [line ${s.line}]`);
console.log(` Uncovered: ${s.uncoveredBranches.join(', ')}`);
s.suggestedTestCases.forEach((tc) =>console.log(` -> ${tc}`));
});
Configuration
Excluding Generated and Vendor Code
// .nycrc.json (Istanbul configuration for Node.js projects){"all":true,"check-coverage":true,"branches":80,"functions":85,"lines":85,"statements":85,"include":["src/**/*.ts"],"exclude":["src/**/*.d.ts","src/**/*.test.ts","src/**/*.spec.ts","src/generated/**","src/types/**","src/**/__mocks__/**","src/**/test-utils/**","src/**/*.stories.tsx","src/migrations/**","src/seeds/**","node_modules/**"],"reporter":["text","lcov","json-summary","html"],"report-dir":"coverage"}
Package.json Scripts
{"scripts":{"test":"vitest run","test:coverage":"vitest run --coverage","coverage:gaps":"ts-node scripts/coverage-gap-analysis.ts","coverage:changes":"ts-node scripts/change-coverage.ts","coverage:modules":"ts-node scripts/module-coverage.ts","coverage:trend":"ts-node scripts/coverage-trend.ts","coverage:suggest":"ts-node scripts/suggest-tests.ts","coverage:dead-code":"ts-node scripts/dead-code-detector.ts","coverage:report":"npm run test:coverage && npm run coverage:gaps && npm run coverage:modules"}}
Best Practices
Enforce change-based coverage in CI. Require that new and modified lines have at least 90% coverage. This prevents coverage erosion without demanding retroactive coverage of legacy code.
Set per-module thresholds for critical code. Payment, authentication, and data validation modules should have higher coverage requirements (95%+) than utility or configuration modules.
Use branch coverage as the primary metric. Statement coverage is too coarse. A function with four if-statements can show 75% statement coverage while only testing one of sixteen possible paths.
Review coverage reports in pull requests. Automatically post coverage summaries and change coverage as PR comments so reviewers can see gaps before approving.
Track coverage trends over time. Record coverage snapshots on every merge to main. Alert when coverage drops more than 1% between measurements.
Exclude files that should not be tested. Type definitions, barrel exports, generated code, and migration files should be excluded from coverage collection to prevent skewed metrics.
Identify dead code before writing tests for it. Run dead code detection before coverage gap analysis. Do not waste effort writing tests for code that should be deleted.
Use the all flag to include files with zero coverage. By default, most coverage tools only report on files that are imported during testing. The all flag ensures files with no test imports appear with 0% coverage.
Combine coverage from multiple test types. Merge coverage reports from unit tests, integration tests, and E2E tests to get a complete picture. A line covered by an E2E test does not need a redundant unit test.
Focus on uncovered error paths. Error handling code (catch blocks, error responses, validation failures) is frequently untested but is where bugs most commonly hide. Prioritize coverage of error paths.
Set realistic initial thresholds and ratchet up. If current coverage is 60%, do not set the threshold to 85% immediately. Start at 60%, prevent regression, and increase the threshold as coverage improves.
Make coverage reports accessible to the whole team. Host HTML coverage reports where all team members can browse them. Coverage gaps are a team responsibility, not just the author's.
Anti-Patterns to Avoid
Chasing 100% coverage as a vanity metric. Achieving 100% coverage often requires testing trivial code (getters, constants, type guards) while providing diminishing returns. Focus on risk-weighted coverage instead.
Writing assertion-free tests to boost coverage. Tests that call functions without asserting outcomes increase coverage numbers without catching bugs. Every test must assert meaningful behavior.
Using coverage pragmas to hide gaps. The /* istanbul ignore next */ pragma has legitimate uses for truly unreachable code, but using it to silence warnings on testable code is gaming the metric.
Measuring only statement coverage. Statement coverage misses untested branches, especially in code with early returns, ternary operators, and short-circuit evaluation. Always measure branch coverage.
Treating coverage as a substitute for test design. High coverage with poor assertions catches fewer bugs than moderate coverage with thoughtful assertions. Coverage guides where to test; test design determines what to test.
Ignoring coverage of error handling code. Error paths are frequently the least tested and most bug-prone. If a try-catch block's catch branch shows 0% coverage, that error handling has never been verified.
Applying uniform thresholds to all code. Configuration files and type definitions should not have the same threshold as business logic. Use per-directory or per-file thresholds to reflect actual risk.
Debugging Tips
Use the HTML coverage report for visual gap identification. The interactive HTML report highlights covered lines in green and uncovered lines in red. This is the fastest way to identify specific gaps in a file.
Check that tests actually import the source files. If a file shows 0% coverage, verify that at least one test imports it. Coverage tools can only track files that are loaded during test execution unless the all flag is set.
Verify the coverage provider matches the runtime. V8 coverage works best for Node.js applications. Istanbul works better for browser-targeted code transpiled with Babel. Mismatched providers produce inaccurate reports.
Look for uncovered else branches in conditionals. The most common coverage gap is the implicit else branch. An if (condition) { ... } without an else has two branches, but only the true branch is usually tested.
Check threshold configuration precedence. Per-file thresholds override global thresholds. If a file consistently fails coverage despite seeming well-tested, check whether a per-file threshold is set higher than global.
Inspect the coverage-final.json for detailed data. The JSON coverage report contains exact hit counts for every statement, branch, and function. Use this data for programmatic analysis when the HTML report is insufficient.
Run coverage in watch mode during development. Use vitest --coverage --watch or jest --coverage --watchAll to see coverage changes in real time as you write tests.
Merge coverage from parallel test runs. If tests run in parallel shards, each shard produces partial coverage. Use istanbul-merge or nyc merge to combine reports before analyzing gaps.
Verify source maps are correct. When testing transpiled code, incorrect source maps cause coverage to be attributed to wrong lines. Ensure the build tool generates accurate source maps for coverage reporting.
