Advanced code coverage analysis with instrumentation and multiple report formats. Provides detailed insights into test coverage with line, statement, and branch coverage metrics.
Instruments source code for coverage analysis before test execution.
/**
* Instruments source code for coverage analysis
* @param options - Coverage configuration options
* @returns Promise that resolves when instrumentation is complete
*/
coverage.instrument(options: CoverageOptions): Promise<void>;Usage Examples:
const Lab = require('@hapi/lab');
// Basic instrumentation
await Lab.coverage.instrument({
coveragePath: './src',
coverageExclude: ['node_modules', 'test']
});
// Advanced instrumentation with predicates
await Lab.coverage.instrument({
coveragePath: './lib',
coverageExclude: ['*.test.js'],
'coverage-predicates': {
'deep-equal': true,
'throws': true
}
});Analyzes coverage data collected during test execution and generates detailed reports.
/**
* Analyzes coverage data and generates comprehensive coverage reports
* @param options - Coverage analysis configuration
* @returns Promise resolving to detailed coverage report
*/
coverage.analyze(options: CoverageOptions): Promise<CoverageReport>;Usage Examples:
// Basic coverage analysis
const coverageReport = await Lab.coverage.analyze({
threshold: 80,
coveragePath: './src'
});
// Coverage with HTML report
const report = await Lab.coverage.analyze({
reporter: 'html',
output: 'coverage.html',
threshold: 90,
'coverage-all': true
});Comprehensive configuration options for coverage analysis behavior.
interface CoverageOptions {
/** Enable code coverage analysis */
coverage?: boolean;
/** Root path for coverage analysis */
coveragePath?: string;
/** File patterns to exclude from coverage */
coverageExclude?: string[];
/** Include all matched files in coverage report */
'coverage-all'?: boolean;
/** Prevent recursive file inclusion in coverage */
'coverage-flat'?: boolean;
/** File pattern for coverage analysis */
coveragePattern?: RegExp;
/** Custom coverage predicates configuration */
'coverage-predicates'?: { [key: string]: boolean };
/** Coverage threshold percentage (0-100) */
threshold?: number;
/** Reporter format for coverage output */
reporter?: string;
/** Output file for coverage report */
output?: string;
}Detailed coverage analysis results with line, statement, and branch metrics.
interface CoverageReport {
/** Overall coverage percentage */
percent: number;
/** Per-file coverage details */
files: { [filename: string]: FileCoverage };
/** Summary statistics */
summary: CoverageSummary;
/** Coverage threshold status */
threshold: {
/** Whether threshold was met */
met: boolean;
/** Required threshold percentage */
required: number;
/** Actual coverage percentage */
actual: number;
};
}
interface FileCoverage {
/** File path relative to coverage root */
filename: string;
/** Overall file coverage percentage */
percent: number;
/** Line coverage details */
lines: {
/** Total lines in file */
total: number;
/** Lines covered by tests */
covered: number;
/** Coverage percentage for lines */
percent: number;
/** Line-by-line hit counts */
hits: { [lineNumber: number]: number };
};
/** Statement coverage details */
statements: {
/** Total statements in file */
total: number;
/** Statements covered by tests */
covered: number;
/** Coverage percentage for statements */
percent: number;
/** Statement hit details */
hits: { [statementId: string]: StatementHit };
};
/** Branch coverage details */
branches?: {
/** Total branches in file */
total: number;
/** Branches covered by tests */
covered: number;
/** Coverage percentage for branches */
percent: number;
/** Branch hit details */
hits: { [branchId: string]: BranchHit };
};
/** Source code lines */
source: string[];
}
interface StatementHit {
/** Line number of statement */
line: number;
/** Number of times statement was executed */
count: number;
/** Whether statement uses boolean predicates */
bool?: boolean | 'nullish';
/** Predicate hit tracking */
hit?: { [key: string]: boolean };
}
interface BranchHit {
/** Line number of branch */
line: number;
/** Branch execution counts for each path */
paths: number[];
/** Whether all branch paths were taken */
covered: boolean;
}
interface CoverageSummary {
/** Total lines across all files */
lines: {
total: number;
covered: number;
percent: number;
};
/** Total statements across all files */
statements: {
total: number;
covered: number;
percent: number;
};
/** Total branches across all files */
branches?: {
total: number;
covered: number;
percent: number;
};
}Advanced coverage tracking for complex boolean expressions and error conditions.
interface CoveragePredicates {
/** Track deep equality comparisons */
'deep-equal'?: boolean;
/** Track exception throwing paths */
'throws'?: boolean;
/** Track nullish coalescing operations */
'nullish'?: boolean;
/** Custom predicate definitions */
[predicateName: string]: boolean;
}Usage Examples:
// Enable comprehensive predicate tracking
const options = {
'coverage-predicates': {
'deep-equal': true,
'throws': true,
'nullish': true
}
};
await Lab.coverage.instrument(options);Interactive HTML reports with detailed line-by-line coverage visualization.
Features:
Usage:
await Lab.report(script, {
coverage: true,
reporter: 'html',
output: 'coverage.html'
});Industry-standard LCOV format for integration with external tools and CI/CD systems.
Usage:
await Lab.report(script, {
coverage: true,
reporter: 'lcov',
output: 'coverage.lcov'
});XML-based Clover format for build systems and IDEs.
Usage:
await Lab.report(script, {
coverage: true,
reporter: 'clover',
output: 'coverage.xml'
});Complete example for continuous integration with coverage thresholds:
const Lab = require('@hapi/lab');
const runCoverageTests = async () => {
const script = Lab.script();
// Your tests here
const result = await Lab.report(script, {
coverage: true,
threshold: 90,
reporter: ['console', 'lcov'],
output: ['', 'coverage.lcov'],
'coverage-exclude': ['node_modules', 'test', '*.test.js']
});
if (result.coverage.threshold.met) {
console.log('Coverage threshold met!');
process.exit(0);
} else {
console.error(`Coverage ${result.coverage.percent}% below threshold ${result.coverage.threshold.required}%`);
process.exit(1);
}
};
runCoverageTests();Example for local development with HTML reports:
// Run with HTML coverage report for development
await Lab.report(script, {
coverage: true,
'coverage-all': true,
reporter: 'html',
output: 'coverage/index.html',
coveragePath: './src',
coverageExclude: ['test/**', 'node_modules/**']
});
console.log('Coverage report generated: coverage/index.html');