monocart-coverage-reports
Advanced tools
A code coverage tool to generate native V8 reports or Istanbul reports.
A code coverage tool to generate native V8 reports or Istanbul reports.
entryFilter and sourceFilter to filter the results for V8 reportCDPClient APIsourcePath for the Source Filesconst MCR = require('monocart-coverage-reports');
const coverageOptions = {
name: 'My Coverage Report - 2024-02-28',
outputDir: './coverage-reports',
reports: ["v8", "console-details"]
}
const coverageReport = MCR(coverageOptions);
coverageReport.cleanCache();
await coverageReport.add(coverageData1);
await coverageReport.add(coverageData2);
await coverageReport.generate();
// Or
// const { CoverageReport } = require('monocart-coverage-reports');
// const coverageReport = new CoverageReport(coverageOptions);
reports Available ReportsentryFilter and sourceFilter Using entryFilter and sourceFilter to filter the results for V8 reportsourcePath Resolve sourcePath for the Source Filesall Adding Empty Coverage for Untested FilesinputDir Merge Coverage Reportslogging Debug for Coverage and SourcemaponEnd onEnd HookDeclaration lib/index.d.ts
V8 build-in reports (V8 data only):
v8
v8-json
Istanbul build-in reports (both V8 and istanbul data):
clovercoberturahtml
html-spa
jsonjson-summarylcovlcovonly
noneteamcitytexttext-lcovtext-summaryOther build-in reports (both V8 and istanbul data):
codecov
console-summary shows coverage summary in the console
console-details Show file coverage and uncovered lines in the console. Like text, but for V8. For Github actions, we can enforce color with env: FORCE_COLOR: true.
raw only keep all original data, which can be used for other reports input with inputDir
Custom Reporter
{
reports: [
[path.resolve('./test/custom-istanbul-reporter.js'), {
type: 'istanbul',
file: 'custom-istanbul-coverage.text'
}],
[path.resolve('./test/custom-v8-reporter.js'), {
type: 'v8',
outputFile: 'custom-v8-coverage.json'
}],
[path.resolve('./test/custom-v8-reporter.mjs'), {
type: 'both'
}]
]
}
example: ./test/custom-istanbul-reporter.js, see istanbul built-in reporters' implementation for reference.
example: ./test/custom-v8-reporter.js
const MCR = require('monocart-coverage-reports');
const coverageOptions = {
outputDir: './coverage-reports',
reports: [
// build-in reports
['console-summary'],
['v8'],
['html', {
subdir: 'istanbul'
}],
['json', {
file: 'my-json-file.json'
}],
'lcovonly',
// custom reports
// Specify reporter name with the NPM package
["custom-reporter-1"],
["custom-reporter-2", {
type: "istanbul",
key: "value"
}],
// Specify reporter name with local path
['/absolute/path/to/custom-reporter.js']
]
}
const coverageReport = MCR(coverageOptions);
coverageReport.cleanCache();
entryFilter and sourceFilter to filter the results for V8 reportWhen V8 coverage data collected, it actually contains the data of all entry files, for example:
dist/main.js
dist/vendor.js
dist/something-else.js
We can use entryFilter to filter the entry files. For example, we should remove vendor.js and something-else.js if they are not in our coverage scope.
dist/main.js
When inline or linked sourcemap exists to the entry file, the source files will be extracted from the sourcemap for the entry file, and the entry file will be removed if logging is not debug.
> src/index.js
> src/components/app.js
> node_modules/dependency/dist/dependency.js
We can use sourceFilter to filter the source files. For example, we should remove dependency.js if it is not in our coverage scope.
> src/index.js
> src/components/app.js
For example:
const coverageOptions = {
entryFilter: (entry) => entry.url.indexOf("main.js") !== -1,
sourceFilter: (sourcePath) => sourcePath.search(/src\//) !== -1
};
Or using minimatch pattern:
const coverageOptions = {
entryFilter: "**/main.js",
sourceFilter: "**/src/**"
};
// supports multiple patterns:
const coverageOptions = {
entryFilter: {
'**/vendor.js': false,
'**/main.js': true
},
sourceFilter: {
'**/src/**': true
}
};
For example, checking thresholds:
const EC = require('eight-colors');
const coverageOptions = {
name: 'My Coverage Report',
outputDir: './coverage-reports',
onEnd: (coverageResults) => {
const thresholds = {
bytes: 80,
lines: 60
};
console.log('check thresholds ...', thresholds);
const errors = [];
const { summary } = coverageResults;
Object.keys(thresholds).forEach((k) => {
const pct = summary[k].pct;
if (pct < thresholds[k]) {
errors.push(`Coverage threshold for ${k} (${pct} %) not met: ${thresholds[k]} %`);
}
});
if (errors.length) {
const errMsg = errors.join('\n');
console.log(EC.red(errMsg));
// throw new Error(errMsg);
// process.exit(1);
}
}
}
The CLI will run the program as a child process with
NODE_V8_COVERAGE=diruntil it exits gracefully, and generate the coverage report with the coverage data from thedir.
npm i monocart-coverage-reports -g
mcr node ./test/specs/node.test.js -r v8,console-summary --lcov
npm i monocart-coverage-reports
npx mcr node ./test/specs/node.test.js -r v8,console-summary --lcov
Usage: mcr [options] <command>
CLI to generate coverage reports
Arguments:
command command to execute
Options:
-V, --version output the version number
-c, --config <path> custom config file path
--logging <logging> off, error, info, debug
-n, --name <name> report name for title
-r, --reports <name[,name]> coverage reports to use
-o, --outputDir <dir> output dir for reports
-i, --inputDir <dir> input dir for merging raw files
--entryFilter <pattern> entry url filter
--sourceFilter <pattern> source path filter
--outputFile <path> output file for v8 report
--inline inline html for v8 report
--assetsPath <path> assets path if not inline
--lcov generate lcov.info file
-h, --help display help for command
Loading config file by priority:
-c or --configmcr.config.jsmcr.config.cjsmcr.config.mjsmcr.config.json - json format.mcrrc.js.mcrrc - json formatmcr.config.ts (requires preloading the typescript module)Working with tsx, see mcr-tsx
Working with ts-node, see mcr-ts-node
| Istanbul | V8 | V8 to Istanbul | |
|---|---|---|---|
| Coverage data | Istanbul (Object) | V8 (Array) | V8 (Array) |
| Output | Istanbul reports | V8 reports | Istanbul reports |
| - Bytes | ❌ | ✅ | ❌ |
| - Statements | ✅ | ✅ | ✅ |
| - Branches | ✅ | ✅ | ✅ |
| - Functions | ✅ | ✅ | ✅ |
| - Lines | ✅ | ✅ | ✅ |
| - Execution counts | ✅ | ✅ | ✅ |
| CSS coverage | ❌ | ✅ | ✅ |
| Minified code | ❌ | ✅ | ❌ |
Istanbul Workflows
V8 Workflows
Before collecting Istanbul coverage data, It requires your source code is instrumented with Istanbul
window.__coverage__, example: test-istanbul.jsglobal.__coverage__sourcemap and do not compress/minify:
devtool: source-map and mode: development, example webpack.config-v8.jssourcemap: truesourcemap: true and minify: falsesourcemap: true and minify: falseCollecting coverage data with Chromium Coverage API:
Sometimes, the sourcemap file cannot be successfully loaded with the
sourceMappingURL, you can try to manually read the sourcemap file before the coverage data is added to the report.
const jsCoverage = await page.coverage.stopJSCoverage();
jsCoverage.forEach((entry) => {
// read sourcemap for the my-dist.js manually
if (entry.url.endsWith('my-dist.js')) {
entry.sourceMap = JSON.parse(fs.readFileSync('dist/my-dist.js.map').toString('utf-8'));
}
});
await MCR(coverageOptions).add(jsCoverage);
Puppeteer does not provide raw v8 coverage data by default. A simple conversion is required, see example: ./test/test-puppeteer.js
await Promise.all([
page.coverage.startJSCoverage({
resetOnNavigation: false,
// provide raw v8 coverage data
includeRawScriptCoverage: true
}),
page.coverage.startCSSCoverage({
resetOnNavigation: false
})
]);
await page.goto(url);
const [jsCoverage, cssCoverage] = await Promise.all([
page.coverage.stopJSCoverage(),
page.coverage.stopCSSCoverage()
]);
// to raw V8 script coverage
const coverageData = [... jsCoverage.map((it) => {
return {
source: it.text,
... it.rawScriptCoverage
};
}), ... cssCoverage];
Possible solutions:
NODE_V8_COVERAGE=dir
NODE_V8_COVERAGE=dir before the program running, the coverage data will be saved to the dir after the program exits gracefully.dir and generate coverage report.cross-env NODE_V8_COVERAGE=
.temp/v8-coverage-envnode ./test/test-node-env.js && node ./test/generate-report.js
V8 API + NODE_V8_COVERAGE
v8.takeCoverage(), it does not require waiting until the program exits gracefully.cross-env NODE_V8_COVERAGE=
.temp/v8-coverage-apinode ./test/test-node-api.js
Inspector API
CDP API
node --inspect=9229 ./test/test-node-cdp.js
Node Debugging + CDP + NODE_V8_COVERAGE + V8 API
v8.takeCoverage() interface to manually collect coverage data. Remote invocation of the v8.takeCoverage() interface can be accomplished through the Runtime.evaluate of the CDP.Child Process + NODE_V8_COVERAGE
CDPClient API--inspect=9229const MCR = require('monocart-coverage-reports');
const client = await MCR.CDPClient({
port: 9229
});
await client.startJSCoverage();
// run your test here
const coverageData = await client.stopJSCoverage();
const { chromium } = require('playwright');
const MCR = require('monocart-coverage-reports');
const browser = await chromium.launch();
const page = await browser.newPage();
const session = await page.context().newCDPSession(page);
const client = await MCR.CDPClient({
session
});
// both js and css coverage
await client.startCoverage();
// run your test page here
await page.goto("your page url");
const coverageData = await client.stopCoverage();
const puppeteer = require('puppeteer');
const MCR = require('monocart-coverage-reports');
const browser = await puppeteer.launch({});
const page = await browser.newPage();
const session = await page.target().createCDPSession();
const client = await MCR.CDPClient({
session
});
// both js and css coverage
await client.startCoverage();
// run your test page here
await page.goto("your page url");
const coverageData = await client.stopCoverage();
The data will be added to
[outputDir]/.cache, After the generation of the report, this data will be removed unless debugging has been enabled or a raw report has been used, see Debug for Coverage and Sourcemap
const MCR = require('monocart-coverage-reports');
const coverageOptions = require('path-to/same-options.js');
const coverageReport = MCR(coverageOptions);
// clean previous cache before the start of testing
// unless the running environment is new and no cache
coverageReport.cleanCache();
const MCR = require('monocart-coverage-reports');
const coverageOptions = require('path-to/same-options.js');
const coverageReport = MCR(coverageOptions);
// do not clean cache in the stage
await coverageReport.add(coverageData1);
const MCR = require('monocart-coverage-reports');
const coverageOptions = require('path-to/same-options.js');
const coverageReport = MCR(coverageOptions);
// do not clean cache in the stage
await coverageReport.add(coverageData2);
// generate coverage reports after the completion of testing
const MCR = require('monocart-coverage-reports');
const coverageOptions = require('path-to/same-options.js');
const coverageReport = MCR(coverageOptions);
// do not clean cache before generating reports
await coverageReport.generate();
The following usage scenarios may require merging coverage reports:
If the reports cannot be merged automatically, then here is how to manually merge the reports.
First, using the raw report to export the original coverage data to the specified directory.
const coverageOptions = {
name: 'My Unit Test Coverage Report',
outputDir: "./coverage-reports/unit",
reports: [
['raw', {
// relative path will be "./coverage-reports/unit/raw"
outputDir: "raw"
}],
['v8'],
['console-summary']
]
};
Then, after all the tests are completed, generate a merged report with option inputDir:
// esm syntax
import fs from "fs";
import { CoverageReport } from 'monocart-coverage-reports';
const coverageOptions = {
name: 'My Merged Coverage Report',
inputDir: [
'./coverage-reports/unit/raw',
'./coverage-reports/e2e/raw'
],
outputDir: './coverage-reports/merged',
reports: [
['v8'],
['console-summary']
],
onEnd: () => {
// remove the raw files if it useless
fs.rmSync('./coverage-reports/unit/raw', {
recursive: true,
force: true
})
}
};
await new CoverageReport(coverageOptions).generate();
sourcePath for the Source FilesIf the source file comes from the sourcemap, then its path is a virtual path. Using the sourcePath option to resolve a custom path.
For example, we have tested multiple dist files, which contain some common files. We hope to merge the coverage of the same files, so we need to unify the sourcePath in order to be able to merge the coverage data.
const coverageOptions = {
sourcePath: (filePath) => {
// Remove the virtual prefix
const list = ['my-dist-file1/', 'my-dist-file2/'];
for (const str of list) {
if (filePath.startsWith(str)) {
return filePath.slice(str.length);
}
}
return filePath;
}
};
It also supports simple key/value replacement:
const coverageOptions = {
sourcePath: {
'my-dist-file1/': '',
'my-dist-file2/': ''
}
};
By default the untested files will not be included in the coverage report, we can add empty coverage data for all files with option all, the untested files will show 0% coverage.
const coverageOptions = {
all: {
dir: ['./src'],
filter: (filePath) => {
return true;
}
}
};
The filter also supports minimatch pattern:
const coverageOptions = {
all: {
dir: ['./src'],
filter: '**/*.js'
}
};
// or multiple patterns
const coverageOptions = {
all: {
dir: ['./src'],
filter: {
// exclude files
'**/ignored-*.js': false,
'**/*.html': false,
'**/*.ts': false,
// empty css coverage
'**/*.scss': "css",
'**/*': true
}
}
};
To ignore codes, use the special comment which starts with v8 ignore :
/* v8 ignore start */
function uncovered() {
}
/* v8 ignore stop */
/* v8 ignore next */
const os = platform === 'wind32' ? 'Windows' : 'Other';
const os = platform === 'wind32' ? 'Windows' /* v8 ignore next */ : 'Other';
// v8 ignore next 3
if (platform === 'linux') {
console.log('hello linux');
}
// Coverage data for a source range.
export interface CoverageRange {
// JavaScript script source offset for the range start.
startOffset: integer;
// JavaScript script source offset for the range end.
endOffset: integer;
// Collected execution count of the source range.
count: integer;
}
// Coverage data for a JavaScript function.
/**
* @functionName can be an empty string.
* @ranges is always non-empty. The first range is called the "root range".
* @isBlockCoverage indicates if the function has block coverage information.
If this is false, it usually means that the functions was never called.
It seems to be equivalent to ranges.length === 1 && ranges[0].count === 0.
*/
export interface FunctionCoverage {
// JavaScript function name.
functionName: string;
// Source ranges inside the function with coverage data.
ranges: CoverageRange[];
// Whether coverage data for this function has block granularity.
isBlockCoverage: boolean;
}
// Coverage data for a JavaScript script.
export interface ScriptCoverage {
// JavaScript script id.
scriptId: Runtime.ScriptId;
// JavaScript script name or url.
url: string;
// Functions contained in the script that has coverage data.
functions: FunctionCoverage[];
}
export type V8CoverageData = ScriptCoverage[];
see devtools-protocol ScriptCoverage and v8-coverage
It is a popular library which is used to convert V8 coverage format to istanbul's coverage format. Most test frameworks are using it, such as Jest, Vitest, but it has two major problems:
const a = tf ? 'true' : 'false';
^ ^ ^
m1 p m2
m1andm2are two consecutive mappings,pis the position we looking for. However, we can only get the position of them1orm2if we don't fix it top. Especially the generated code is different from the original code, such as the code was minified, compressed or converted, it is difficult to find the exact position.
We implemented new converter:
AssignmentPattern.| AST | V8 |
|---|---|
| AssignmentPattern | 🛇 Not Support |
| ConditionalExpression | ✔ |
| IfStatement | ✔ |
| LogicalExpression | ✔ |
| SwitchStatement | ✔ |
Sometimes, the coverage is not what we expect. The next step is to figure out why, and we can easily find out the answer step by step through debugging.
logging: 'debug'const coverageOptions = {
logging: 'debug',
reports: [
['v8'],
['console-summary']
]
};
When logging is debug, the raw report data will be preserved in [outputDir]/.cache or [outputDir]/raw if raw report is used. And the dist file will be preserved in the V8 list, and by opening the browser's devtool, it makes data verification visualization effortless.
Unparsable sourceIt happens during the parsing of the source code into AST, if the source code is not in the standard ECMAScript. For example ts, jsx and so on. There is a option to fix it, which is to manually compile the source code for these files.
import * as fs from "fs";
import * as path from "path";
import { fileURLToPath } from "url";
import * as TsNode from 'ts-node';
const coverageOptions = {
onEntry: async (entry) => {
const filePath = fileURLToPath(entry.url)
const originalSource = fs.readFileSync(filePath).toString("utf-8");
const fileName = path.basename(filePath);
const tn = TsNode.create({});
const source = tn.compile(originalSource, fileName);
entry.fake = false;
entry.source = source;
}
}
codecov built-in report (specification)const coverageOptions = {
outputDir: "./coverage-reports",
reports: [
['codecov']
]
};
- name: Codecov
uses: codecov/codecov-action@v3
with:
files: ./coverage-reports/codecov.json
lcov report:const coverageOptions = {
outputDir: "./coverage-reports",
lcov: true
};
- name: Coveralls
uses: coverallsapp/github-action@v2
with:
files: ./coverage-reports/lcov.info
lcov report. Github actions example:- name: Analyze with SonarCloud
uses: sonarsource/sonarcloud-github-action@master
env:
SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
with:
projectBaseDir: ./
args: >
-Dsonar.organization=cenfun
-Dsonar.projectKey=monocart-coverage-reports
-Dsonar.projectName=monocart-coverage-reports
-Dsonar.javascript.lcov.reportPaths=docs/mcr/lcov.info
-Dsonar.sources=lib
-Dsonar.tests=test
-Dsonar.exclusions=dist/*,packages/*
FAQs
A code coverage tool to generate native V8 reports or Istanbul reports.
The npm package monocart-coverage-reports receives a total of 189,659 weekly downloads. As such, monocart-coverage-reports popularity was classified as popular.
We found that monocart-coverage-reports demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 1 open source maintainer collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
Research
A malicious npm package disguised as a WhatsApp client is exploiting authentication flows with a remote kill switch to exfiltrate data and destroy files.
Security News
PyPI now supports digital attestations, enhancing security and trust by allowing package maintainers to verify the authenticity of Python packages.
Security News
GitHub removed 27 malicious pull requests attempting to inject harmful code across multiple open source repositories, in another round of low-effort attacks.