monocart-coverage-reports 2.3.2 → 2.3.4

package/README.md

@@ -29,8 +29,8 @@
 * [How to convert V8 to Istanbul](#how-to-convert-v8-to-istanbul)
     - [Using `v8-to-istanbul`](#using-v8-to-istanbul)
     - [How Monocart Works](#how-monocart-works)
+* [Debug for Coverage and Sourcemap](#debug-for-coverage-and-sourcemap)
 * [Integration](#integration) - Playwright, Jest, Vitest, Codecov, Coveralls, Sonar Cloud
-* [Istanbul Introduction](#istanbul-introduction)
 * [Thanks](#thanks)
 
 ## Usage
@@ -302,7 +302,7 @@ mcr "node ./test/test-node-env.js" -c test/cli-options.js
     - see [Node.js V8 Coverage Report for Server Side](#nodejs-v8-coverage-report-for-server-side)
 
 ## Manually Resolve the Sourcemap
-> If the `js` file is loaded with `addScriptTag` [API](https://playwright.dev/docs/api/class-page#page-add-script-tag), then its sourcemap file may not work. You can try to manually read the sourcemap file before the coverage data is added to the report.
+> 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.
 ```js
 const jsCoverage = await page.coverage.stopJSCoverage();
 jsCoverage.forEach((entry) => {
@@ -370,26 +370,32 @@ Possible solutions:
     - see [`mcr` CLI](#mcr-cli)
 
 ## Multiprocessing Support
-The data will be added to `[outputDir]/.cache`, and the cache will be removed after reports generated.
-- sub process 1
+> 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](#debug-for-coverage-and-sourcemap)
+- Main process, before the start of testing
 ```js
+// clean previous cache before the start of testing (option)
 const MCR = require('monocart-coverage-reports');
 const options = require('path-to/same-options.js');
-const coverageReport = MCR(options);
-await coverageReport.add(coverageData1);
+MCR(options).cleanCache();
 ```
 
-- sub process 2
+- Sub process 1, testing stage 1
 ```js
 const MCR = require('monocart-coverage-reports');
 const options = require('path-to/same-options.js');
-const coverageReport = MCR(options);
-await coverageReport.add(coverageData2);
+await MCR(options).add(coverageData1);
+```
+
+- Sub process 2, testing stage 2
+```js
+const MCR = require('monocart-coverage-reports');
+const options = require('path-to/same-options.js');
+await MCR(options).add(coverageData2);
 ```
 
-- main process
+- Main process, after the completion of testing
 ```js
-// after all sub processes finished
+// generate coverage reports after the completion of testing
 const MCR = require('monocart-coverage-reports');
 const options = require('path-to/same-options.js');
 const coverageReport = MCR(options);
@@ -478,7 +484,7 @@ const os = platform === 'wind32' ? 'Windows' /* v8 ignore next */ : 'Other';
 
 // v8 ignore next 3
 if (platform === 'linux') {
-    console.info('hello linux');
+    console.log('hello linux');
 }
 ```
 
@@ -577,6 +583,25 @@ We implemented new converter instead of v8-to-istanbul:
 | LogicalExpression     | ✔ Not Perfect | 
 | SwitchStatement       | ✔ Not Perfect | 
 
+## Debug for Coverage and Sourcemap
+> 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.
+- Start debugging for v8 report with option `logging: 'debug'`
+```js
+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.
+![](./test/debug-coverage.png)
+
+- Check sourcemap with [Source Map Visualization](https://evanw.github.io/source-map-visualization/)
+
+![](./test/debug-sourcemap.png)
+
 ## Integration
 - [monocart-reporter](https://github.com/cenfun/monocart-reporter) - A [Playwright](https://github.com/microsoft/playwright) custom reporter, supports generating [Code Coverage Report](https://github.com/cenfun/monocart-reporter?#code-coverage-report)
 - [jest-monocart-coverage](https://github.com/cenfun/jest-monocart-coverage) - A [Jest](https://github.com/jestjs/jest/) custom reporter for coverage reports
@@ -601,6 +626,12 @@ We implemented new converter instead of v8-to-istanbul:
     ```
 - [Coveralls](https://coveralls.io/)
     - [![Coverage Status](https://coveralls.io/repos/github/cenfun/monocart-coverage-reports/badge.svg?branch=main)](https://coveralls.io/github/cenfun/monocart-coverage-reports?branch=main)
+    ```js
+    const coverageOptions = {
+        outputDir: "./coverage-reports",
+        lcov: true
+    };
+    ```
     - Github Actions example:
     ```yml
     - name: Coveralls
@@ -627,13 +658,10 @@ We implemented new converter instead of v8-to-istanbul:
             -Dsonar.tests=test
             -Dsonar.exclusions=dist/*,packages/*
     ```
-
-
-## Istanbul Introduction
-- [Istanbul coverage report](https://istanbul.js.org/) - Instrumenting source codes and generating coverage reports
-- [babel-plugin-istanbul](https://github.com/istanbuljs/babel-plugin-istanbul)
-- [istanbul-reports](https://github.com/istanbuljs/istanbuljs/tree/master/packages/istanbul-reports/lib)
-- [Code Coverage Introduction](https://docs.cypress.io/guides/tooling/code-coverage)
+- Integration with any testing framework
+    - First, you need to collect coverage data when any stage of the test is completed. Then, add the coverage data to the coverage report.
+    - Upon the completion of all tests, generate the coverage report. 
+    - see [Multiprocessing Support](#multiprocessing-support)
 
 ## Thanks
 - Special thanks to [@edumserrano](https://github.com/edumserrano)

package/lib/converter/ast.js

@@ -4,7 +4,6 @@ const {
 const Util = require('../utils/util.js');
 
 const { createBranches, collectBranches } = require('./branches.js');
-const findInRanges = require('./find-in-ranges.js');
 
 const getFunctionRange = (start, end, state) => {
 
@@ -28,7 +27,7 @@ const getFunctionRange = (start, end, state) => {
     }
 
     // find in functionRanges
-    return findInRanges(start, end, functionRanges);
+    return Util.findInRanges(start, end, functionRanges, 'startOffset', 'endOffset');
 };
 
 const collectAstInfo = (ast, state) => {
@@ -214,7 +213,7 @@ const addRule = (item, coverageList, coveredRanges, count = 0) => {
     const endOffset = end.offset;
 
     if (!count) {
-        const coveredRange = findInRanges(startOffset, endOffset, coveredRanges);
+        const coveredRange = Util.findInRanges(startOffset, endOffset, coveredRanges, 'startOffset', 'endOffset');
         if (coveredRange) {
             count = 1;
         }

package/lib/converter/branches.js

@@ -1,5 +1,4 @@
 const Util = require('../utils/util.js');
-const findInRanges = require('./find-in-ranges.js');
 
 const findBranchBlock = (start, end, functionInfo) => {
     const { range } = functionInfo;
@@ -14,7 +13,7 @@ const findBranchBlock = (start, end, functionInfo) => {
 
             // support for tf2 || a || 1;
             // "a" is in "|| a"
-            const blockItem = findInRanges(start, end, blockRanges);
+            const blockItem = Util.findInRanges(start, end, blockRanges, 'startOffset', 'endOffset');
             if (blockItem) {
                 return blockItem;
             }
@@ -108,7 +107,7 @@ const addNodeCount = (node, parents, functionInfo) => {
             return;
         }
 
-        const blockItem = findInRanges(start, end, blockRanges);
+        const blockItem = Util.findInRanges(start, end, blockRanges, 'startOffset', 'endOffset');
         if (blockItem) {
             node._state = {
                 count: blockItem.count
@@ -270,8 +269,27 @@ const createBranches = (functionInfo, branchMap, body, params, functionParents =
 
 // =======================================================================================
 
+const updateBlockLocations = (locations) => {
+    const noBlockList = [];
+    let blockCount = 0;
+    locations.forEach((item) => {
+        if (item.block) {
+            item.count = item.block.count;
+            blockCount += item.count;
+            return;
+        }
+        noBlockList.push(item);
+    });
+
+    return {
+        noBlockList,
+        blockCount
+    };
+};
+
 // const a = tf1 ? 'true' : 'false';
-const ConditionalExpression = (group, parentCount, noBlockList, blockCount) => {
+const ConditionalExpression = (locations, parentCount) => {
+    const { noBlockList, blockCount } = updateBlockLocations(locations);
     if (!noBlockList.length) {
         return;
     }
@@ -282,7 +300,8 @@ const ConditionalExpression = (group, parentCount, noBlockList, blockCount) => {
     });
 };
 
-const IfStatement = (group, parentCount, noBlockList, blockCount) => {
+const IfStatement = (locations, parentCount) => {
+    const { noBlockList, blockCount } = updateBlockLocations(locations);
     if (!noBlockList.length) {
         return;
     }
@@ -296,7 +315,8 @@ const IfStatement = (group, parentCount, noBlockList, blockCount) => {
 };
 
 // const b = tf2 || tf1 || a;
-const LogicalExpression = (group, parentCount, noBlockList, blockCount) => {
+const LogicalExpression = (locations, parentCount) => {
+    const { noBlockList, blockCount } = updateBlockLocations(locations);
     if (!noBlockList.length) {
         return;
     }
@@ -304,15 +324,10 @@ const LogicalExpression = (group, parentCount, noBlockList, blockCount) => {
     noBlockList.forEach((item) => {
         item.count = count;
     });
-
-    // const start = group.start;
-    // if (start > 7874 && start < 7922) {
-    //     console.log(group.type, parentCount, 'locations', group.locations);
-    // }
-
 };
 
-const SwitchStatement = (group, parentCount, noBlockList, blockCount) => {
+const SwitchStatement = (locations, parentCount) => {
+    const { noBlockList, blockCount } = updateBlockLocations(locations);
     if (!noBlockList.length) {
         return;
     }
@@ -322,6 +337,12 @@ const SwitchStatement = (group, parentCount, noBlockList, blockCount) => {
     });
 };
 
+const AssignmentPattern = (locations, parentCount) => {
+    locations.forEach((item) => {
+        item.count = parentCount;
+    });
+};
+
 // =======================================================================================
 
 const getBranchParentCount = (reverseParents, functionCount) => {
@@ -363,27 +384,17 @@ const updateBranchCount = (group) => {
     // calculate branches count
     // > 1
 
-    const noBlockList = [];
-    let blockCount = 0;
-    locations.forEach((item) => {
-        if (item.block) {
-            item.count = item.block.count;
-            blockCount += item.count;
-            return;
-        }
-        noBlockList.push(item);
-    });
-
     const handlers = {
         ConditionalExpression,
         IfStatement,
         LogicalExpression,
-        SwitchStatement
+        SwitchStatement,
+        AssignmentPattern
     };
 
     const handler = handlers[type];
     if (handler) {
-        handler(group, parentCount, noBlockList, blockCount);
+        handler(locations, parentCount);
     }
 
 };

package/lib/converter/converter.js

@@ -20,7 +20,6 @@ const { decode } = require('../packages/monocart-coverage-vendor.js');
 const InfoLine = require('./info-line.js');
 const InfoBranch = require('./info-branch.js');
 const InfoFunction = require('./info-function.js');
-const findInRanges = require('./find-in-ranges.js');
 
 // ========================================================================================================
 
@@ -29,7 +28,7 @@ const handleIgnoredRanges = (list, ignoredRanges) => {
         if (item.count > 0) {
             return;
         }
-        const range = findInRanges(item.start, item.end, ignoredRanges);
+        const range = Util.findInRanges(item.start, item.end, ignoredRanges, 'start', 'end');
         if (range) {
             // console.log(item, range);
             item.ignored = true;
@@ -39,13 +38,17 @@ const handleIgnoredRanges = (list, ignoredRanges) => {
 
 // ========================================================================================================
 
-const updateLinesCount = (bytes, locator, lineMap) => {
+const applyBytesToLines = (bytes, locator, lineMap) => {
     bytes.forEach((range) => {
-
         const {
             start, end, count, ignored
         } = range;
 
+        // no need handle ignored and uncovered byte
+        if (count === 0 && ignored) {
+            return;
+        }
+
         const sLoc = locator.offsetToLocation(start);
         const eLoc = locator.offsetToLocation(end);
 
@@ -53,83 +56,110 @@ const updateLinesCount = (bytes, locator, lineMap) => {
         const lines = Util.getRangeLines(sLoc, eLoc);
 
         lines.forEach((it) => {
-            const line = lineMap.get(it.line);
-            if (!line) {
+            const lineItem = lineMap.get(it.line);
+            if (!lineItem) {
+                // not found line, could be comment or blank line
+                return;
+            }
+            if (lineItem.ignored) {
                 return;
             }
 
-            // from outside into inside, uncovered is certain
-            // default is covered
-            if (it.entire) {
-                line.covered = count > 0;
-                line.count = count;
-
-                if (ignored) {
-                    if (!line.covered) {
-                        line.ignored = true;
-                    }
-                }
+            it.count = count;
 
+            // default is covered, so only focus on
+            // 1, last covered count
+            // 2, uncovered entire and pieces
+            if (count > 0) {
+                lineItem.coveredCount = count;
             } else {
-
-                if (!ignored) {
-                    if (count > 0) {
-                        line.count = count;
-                    } else {
-                    // not covered if any count = 0
-                        line.covered = false;
-                    }
+                if (it.entire) {
+                    lineItem.uncoveredEntire = it;
+                } else {
+                    lineItem.uncoveredPieces.push(it);
                 }
-
             }
-
-            // if (!line.history) {
-            //     line.history = [];
-            // }
-            // line.history.push(`${it.entire}-${count}`);
-
         });
 
     });
-
-    // if (state.sourcePath.endsWith('component.js')) {
-    //     console.log('===========================================', state.sourcePath);
-    // }
-
 };
 
-const handleLinesCoverage = (bytes, locator) => {
-
-    const lines = [];
-    // line 1 based
-    const lineMap = new Map();
+const handleLinesCoverage = (bytes, locator, ignoredRanges) => {
 
     // init lines
     let blankCount = 0;
     let commentCount = 0;
-
-    locator.lines.forEach((it) => {
+    // line 1 based
+    const lineMap = new Map();
+    locator.lines.forEach((lineItem) => {
         // exclude blank and comment
-        if (it.blank) {
+        if (lineItem.blank) {
             blankCount += 1;
             return;
         }
-        if (it.comment) {
+        if (lineItem.comment) {
             commentCount += 1;
             return;
         }
+        const ignored = Util.findInRanges(lineItem.start, lineItem.end, ignoredRanges);
+        if (ignored) {
+            return;
+        }
         // line 1-base
-        const line = it.line + 1;
-        // default count to 1, both js and css
-        const lineInfo = new InfoLine(line, it.length, 1);
-        lineMap.set(line, lineInfo);
-        lines.push(lineInfo);
+        const line = lineItem.line + 1;
+        lineItem.coveredCount = 1;
+        lineItem.uncoveredEntire = null;
+        lineItem.uncoveredPieces = [];
+        lineMap.set(line, lineItem);
     });
 
-    updateLinesCount(bytes, locator, lineMap);
+    applyBytesToLines(bytes, locator, lineMap);
+
+    const lines = [];
+    // data lines for codecov
+    // https://docs.codecov.com/docs/codecov-custom-coverage-format
+    const dataLines = {};
+
+    // no ignore items
+    lineMap.forEach((lineItem, line) => {
+
+        const {
+            uncoveredEntire, uncoveredPieces, coveredCount
+        } = lineItem;
+
+        // default count to 1, both js and css
+        let count = 1;
+        // full covered true/false for entire line
+        let covered = true;
+
+        if (uncoveredEntire) {
+            count = 0;
+            covered = false;
+        } else {
+
+            count = coveredCount;
+            const uncoveredLen = uncoveredPieces.length;
+            if (uncoveredLen > 0) {
+                covered = false;
+
+                // uncovered
+                count = `1/${uncoveredLen + 1}`;
+
+            }
+
+        }
+
+        // data lines
+        dataLines[line] = count;
+
+        // exclude indent?
+        const infoLine = new InfoLine(line, lineItem.length, count, covered);
+        lines.push(infoLine);
+    });
 
     return {
         lines,
+        dataLines,
         blankCount,
         commentCount
     };
@@ -185,11 +215,8 @@ const calculateV8Lines = (lines, blankCount, commentCount) => {
         comment: commentCount
     };
 
+    // the lines not includes ignored
     lines.forEach((ln) => {
-        if (ln.ignored) {
-            // console.log(ln);
-            return;
-        }
         v8Lines.total += 1;
         // full line covered
         if (ln.covered) {
@@ -235,6 +262,8 @@ const collectFileCoverage = (v8Data, state, options) => {
     const ignoredRanges = getIgnoredRanges(locator, options);
     if (ignoredRanges) {
 
+        data.ignores = ignoredRanges;
+
         // data bytes is start/end/count object
         handleIgnoredRanges(data.bytes, ignoredRanges);
 
@@ -275,8 +304,10 @@ const collectFileCoverage = (v8Data, state, options) => {
     // lines
     // after bytes with ignored, before calculateV8Lines
     const {
-        lines, blankCount, commentCount
-    } = handleLinesCoverage(data.bytes, locator);
+        lines, dataLines, blankCount, commentCount
+    } = handleLinesCoverage(data.bytes, locator, ignoredRanges);
+
+    data.lines = dataLines;
 
     // ==========================================
     // v8 data and summary
@@ -301,21 +332,10 @@ const collectFileCoverage = (v8Data, state, options) => {
         b: {}
     };
 
-    // for codecov https://docs.codecov.com/docs/codecov-custom-coverage-format
-    data.lines = {};
-
-    lines.filter((it) => !it.ignored).forEach((line, index) => {
+    // the lines not includes ignored
+    lines.forEach((line, index) => {
         istanbulData.statementMap[`${index}`] = line.generate();
         istanbulData.s[`${index}`] = line.count;
-
-        let count = 0;
-        if (line.covered) {
-            count = line.count;
-        } else if (!line.covered && line.count > 0) {
-            count = '1/2';
-        }
-        // 1-base
-        data.lines[`${line.line}`] = count;
     });
 
     functions.filter((it) => !it.ignored).forEach((fn, index) => {

package/lib/converter/ignore.js

@@ -2,7 +2,7 @@ const Util = require('../utils/util.js');
 
 const getNextN = (content, currentLine, item, locator) => {
 
-    // v8 ignore next N
+    // v-8 ignore next N
     if (content) {
         const n = parseInt(content);
         if (n && n > 0) {
@@ -20,13 +20,32 @@ const getNextN = (content, currentLine, item, locator) => {
         }
     }
 
-    // v8 ignore next
+    // v-8 ignore next
     return 1;
 };
 
+const extendStart = (start, source) => {
+    // extend left, include
+    while (start > 0 && Util.isBlank(source[start - 1])) {
+        start -= 1;
+    }
+    return start;
+};
+
+const extendEnd = (end, source, maxLength) => {
+    // extend right, exclude
+    while (end < maxLength && Util.isBlank(source[end])) {
+        end += 1;
+    }
+    return end;
+};
+
 const addNextIgnore = (list, content, item, locator) => {
 
-    const { lineParser } = locator;
+    const { lineParser, source } = locator;
+    const maxLength = source.length;
+
+    const start = extendStart(item.start, source);
 
     // findLine 0-base
     const currentLine = lineParser.findLine(item.end);
@@ -37,24 +56,38 @@ const addNextIgnore = (list, content, item, locator) => {
     // getLine 1-base
     const line = currentLine.line + 1;
     const endLine = locator.getLine(line + n);
-    const endOffset = endLine ? endLine.end : locator.source.length;
+    const end = extendEnd(endLine ? endLine.end : maxLength, source, maxLength);
 
     const nextItem = {
         type: 'next',
         n,
-        startOffset: item.end,
-        endOffset
+        start,
+        end
     };
 
     list.push(nextItem);
 };
 
+// both v8 or c8
+const hasIgnoreKey = (content) => {
+    const v8Key = 'v8 ignore';
+    if (content.startsWith(v8Key)) {
+        return v8Key.length;
+    }
+    const c8Key = 'c8 ignore';
+    if (content.startsWith(c8Key)) {
+        return c8Key.length;
+    }
+    // istanbul ignore has different rules, can not support it
+};
+
 const getIgnoredRanges = (locator, options) => {
     if (!options.v8Ignore) {
         return;
     }
 
-    const { lineParser } = locator;
+    const { lineParser, source } = locator;
+    const maxLength = source.length;
 
     const comments = lineParser.comments;
     if (!Util.isList(comments)) {
@@ -71,35 +104,35 @@ const getIgnoredRanges = (locator, options) => {
         let content = block ? text.slice(2, -2) : text.slice(2);
         content = content.trim();
 
-        const v8IgnoreKey = 'v8 ignore';
-        if (!content.startsWith(v8IgnoreKey)) {
+        const ignoreKey = hasIgnoreKey(content);
+        if (!ignoreKey) {
             return;
         }
 
-        content = content.slice(v8IgnoreKey.length).trim();
+        content = content.slice(ignoreKey).trim();
 
         if (ignoreStart) {
-            // v8 ignore stop
+            // v-8 ignore stop
             if (content === 'stop') {
-                ignoreStart.endOffset = start;
+                ignoreStart.end = extendEnd(end, source, maxLength);
                 ignoreStart = null;
             }
             return;
         }
 
-        // v8 ignore start
+        // v-8 ignore start
         if (content === 'start') {
             // add first for sort by start
             ignoreStart = {
-                type: 'start',
-                startOffset: end,
-                endOffset: end
+                type: 'start-stop',
+                start: extendStart(start, source),
+                end: start
             };
             list.push(ignoreStart);
             return;
         }
 
-        // v8 ignore next N
+        // v-8 ignore next N
         const nextKey = 'next';
         if (content.startsWith(nextKey)) {
             content = content.slice(nextKey.length).trim();
@@ -110,7 +143,7 @@ const getIgnoredRanges = (locator, options) => {
 
     // ignore not stop
     if (ignoreStart) {
-        ignoreStart.endOffset = locator.source.length;
+        ignoreStart.end = locator.source.length;
         ignoreStart = null;
     }