monocart-coverage-reports 2.7.3 → 2.7.5

package/README.md

@@ -42,6 +42,7 @@
     - [CodeceptJS](#codeceptjs)
     - [WebdriverIO](#webdriverio)
     - [Storybook Test Runner](#storybook-test-runner)
+    - [TestCafe](#testcafe)
     - [Codecov](#codecov)
     - [Coveralls](#coveralls)
     - [Sonar Cloud](#sonar-cloud)
@@ -829,6 +830,9 @@ const coverageOptions = {
 ### [Storybook Test Runner](https://github.com/storybookjs/test-runner)
 - [storybook-monocart-coverage](https://github.com/cenfun/storybook-monocart-coverage) - Storybook V8 Coverage Example
 
+### [TestCafe](https://github.com/DevExpress/testcafe)
+- [testcafe-reporter-coverage](https://github.com/cenfun/testcafe-reporter-coverage) - A TestCafe custom reporter for coverage reports
+
 ### [Codecov](https://codecov.com/)
 [![codecov](https://codecov.io/gh/cenfun/monocart-coverage-reports/graph/badge.svg?token=H0LW7UKYU3)](https://codecov.io/gh/cenfun/monocart-coverage-reports)
 - Supports native `codecov` built-in report ([specification](https://docs.codecov.com/docs/codecov-custom-coverage-format))

package/lib/converter/ast-visitor.js

@@ -8,6 +8,12 @@ const BranchTypes = {
     AssignmentPattern: 'AssignmentPattern'
 };
 
+const setGeneratedOnly = (block, generatedOnly) => {
+    if (block && generatedOnly) {
+        block.generatedOnly = true;
+    }
+};
+
 const getParentFunctionState = (reverseParents) => {
     const parentFunction = reverseParents.find((it) => it._state && it._state.isFunction);
     if (!parentFunction) {
@@ -266,6 +272,7 @@ const updateBranchCount = (group) => {
     const groupBlock = getFunctionBlock(group.start, group.end, functionState);
     if (groupBlock) {
         parentCount = groupBlock.count;
+        setGeneratedOnly(groupBlock, group.generatedOnly);
     }
 
     // calculate branches count
@@ -277,6 +284,7 @@ const updateBranchCount = (group) => {
             return;
         }
         item.block = getFunctionBlock(start, end, functionState);
+        setGeneratedOnly(item.block, group.generatedOnly);
     });
 
 
@@ -314,12 +322,16 @@ const generateBranches = (branchMap) => {
             }
         });
 
-        branches.push({
+        const branch = {
             type: group.type,
             start: group.start,
             end: group.end,
             locations: group.locations
-        });
+        };
+
+        setGeneratedOnly(branch, group.generatedOnly);
+
+        branches.push(branch);
     });
 
     // sort branches
@@ -395,6 +407,34 @@ const generateStatements = (statementNodes) => {
     return statements;
 };
 
+// =======================================================================================
+// handle special generated codes for original coverage
+
+const webpackWrapHandler = (node) => {
+    // ignore webpack wrap for original function
+    // id: { type: 'Identifier', name: '__webpack_modules__' },
+    const name = node.id && node.id.name;
+    if (name === '__webpack_modules__' && node.init && node.init.properties) {
+        // mark all as wrap function
+        node.init.properties.forEach((it) => {
+            it.value._webpackWrapKey = it.key && it.key.value;
+        });
+        // console.log('==========================', node.type);
+        // console.log(name, parents.length);
+    }
+};
+
+const viteImportDefaultHandler = (node, group) => {
+    // ignore vite conditional expression for __esModule default
+    const testObj = node.test.object;
+    const testName = testObj && testObj.name;
+    if (testName && testName.startsWith('__vite__cjsImport')) {
+        setGeneratedOnly(group, true);
+    }
+
+};
+
+
 // =======================================================================================
 
 const collectNodes = (ast) => {
@@ -409,18 +449,7 @@ const collectNodes = (ast) => {
 
         VariableDeclarator(node, parents) {
 
-            // =============================================================
-            // id: { type: 'Identifier', name: '__webpack_modules__' },
-            const name = node.id && node.id.name;
-            if (name === '__webpack_modules__' && node.init && node.init.properties) {
-                // mark all as wrap function
-                node.init.properties.forEach((it) => {
-                    it.value._wrapKey = it.key && it.key.value;
-                });
-                // console.log('==========================', node.type);
-                // console.log(name, parents.length);
-            }
-            // =============================================================
+            webpackWrapHandler(node);
 
         },
 
@@ -473,10 +502,14 @@ const collectNodes = (ast) => {
         // Ternary
         // var b = a ? 'consequent' : 'alternate';
         ConditionalExpression: (node, parents) => {
+
             const { consequent, alternate } = node;
             const group = createBranchGroup(BranchTypes.ConditionalExpression, node, parents, branchMap);
             addBranch(group, consequent, locationMap);
             addBranch(group, alternate, locationMap);
+
+            viteImportDefaultHandler(node, group);
+
         },
 
         // if an if statement; can also be else if.
@@ -619,7 +652,7 @@ const collectAstInfo = (ast, coverageInfo) => {
         const bodyStart = node.body.start;
         const bodyEnd = node.body.end;
         const functionName = id && id.name;
-        const isWrap = Boolean(node._wrapKey);
+        const _webpackWrapKey = node._webpackWrapKey;
 
         const functionItem = {
             start,
@@ -629,9 +662,9 @@ const collectAstInfo = (ast, coverageInfo) => {
             functionName,
             count: rootState.count
         };
-        if (isWrap) {
-            functionItem.wrap = true;
-        }
+
+        setGeneratedOnly(functionItem, _webpackWrapKey);
+
         functions.push(functionItem);
 
         const functionState = {
@@ -641,9 +674,9 @@ const collectAstInfo = (ast, coverageInfo) => {
 
         const functionRange = findFunctionRange(item, coverageInfo);
         if (functionRange) {
-            if (isWrap) {
-                functionRange.wrap = true;
-            }
+
+            setGeneratedOnly(functionRange, _webpackWrapKey);
+
             functionState.range = functionRange;
             functionState.count = functionRange.count;
             functionItem.count = functionRange.count;

package/lib/converter/collect-source-maps.js

@@ -28,7 +28,14 @@ const loadSourceMap = async (url = '') => {
         return;
     }
 
-    return res.data;
+    const content = res.data;
+
+    // could be string not json, if Content-Type is application/octet-stream
+    if (typeof content === 'string') {
+        return JSON.parse(content);
+    }
+
+    return content;
 };
 
 const getSourceMapUrl = (content, url) => {

package/lib/converter/converter.js

@@ -510,6 +510,11 @@ const handleOriginalBytesCoverage = (state) => {
 
 const handleGeneratedBytesCoverage = (state) => {
 
+    // it could be a dist file, do not handle twice
+    if (state.addedGeneratedBytes) {
+        return;
+    }
+
     const { js, coverageList } = state;
 
     if (js) {
@@ -524,6 +529,8 @@ const handleGeneratedBytesCoverage = (state) => {
         });
     }
 
+    state.addedGeneratedBytes = true;
+
 };
 
 // ========================================================================================================
@@ -551,15 +558,16 @@ const handleOriginalFunctionsCoverage = (state, originalStateMap) => {
 
     // function count
     state.astInfo.functions.forEach((it) => {
-        const {
-            start, end, bodyStart, bodyEnd, wrap
-        } = it;
 
         // remove webpack wrap functions for functions count, not for ranges here
-        if (wrap) {
+        if (it.generatedOnly) {
             return;
         }
 
+        const {
+            start, end, bodyStart, bodyEnd
+        } = it;
+
         const result = findOriginalRange(start, end, state, originalStateMap);
         if (result.error) {
             logMappingErrors('function', result);
@@ -598,6 +606,10 @@ const handleOriginalBranchesCoverage = (state, originalStateMap) => {
     // function count
     state.astInfo.branches.forEach((group) => {
 
+        if (group.generatedOnly) {
+            return;
+        }
+
         const { type, locations } = group;
 
         // start
@@ -668,6 +680,11 @@ const handleOriginalStatementsCoverage = (state, originalStateMap) => {
 
     // statement count
     state.astInfo.statements.forEach((it) => {
+
+        if (it.generatedOnly) {
+            return;
+        }
+
         const { start, end } = it;
 
         const result = findOriginalRange(start, end, state, originalStateMap);
@@ -799,11 +816,10 @@ const handleAllOriginalBytesCoverage = (state, originalStateMap) => {
 
     // v8 coverage
     coverageList.forEach((block) => {
-        block.ranges.forEach((range, index) => {
+        block.ranges.forEach((range) => {
 
             // remove wrap functions for original files
-            if (range.wrap) {
-                // console.log(range);
+            if (range.generatedOnly) {
                 return;
             }
 
@@ -1405,7 +1421,7 @@ const convertV8List = (v8list, options) => {
         // console.log([item.id]);
 
         const {
-            type, source, sourcePath
+            type, source, fake, sourcePath
         } = item;
 
         // for source file, type could be ts or vue as extname, but js = true
@@ -1454,6 +1470,7 @@ const convertV8List = (v8list, options) => {
             js,
             type,
             source,
+            fake,
             sourcePath,
             sourceMap,
             locator,

package/lib/converter/find-original-range.js

@@ -1,3 +1,4 @@
+const { diff } = require('../packages/monocart-coverage-vendor');
 const Util = require('../utils/util.js');
 const EC = Util.EC;
 
@@ -38,6 +39,144 @@ const findMapping = (list, offset) => {
 
 // ========================================================================================================
 
+const alignText = (gt, ot) => {
+
+    const toList = (s) => {
+        return s.split('').map((v, i) => {
+            return {
+                index: i,
+                value: v
+            };
+        });
+    };
+
+    const mergeList = (gList, oList) => {
+        const oLen = oList.length;
+        if (!oLen) {
+            return;
+        }
+        const gLen = gList.length;
+        if (gLen === oLen) {
+            gList.forEach((item, i) => {
+                item.original = oList[i];
+            });
+        }
+    };
+
+    const gl = toList(gt);
+    const ol = toList(ot);
+
+    // console.log(gl);
+    // console.log(ol);
+
+    const commonItems = [];
+    diff(gl.length, ol.length, (gi, oi) => {
+        return gl[gi].value === ol[oi].value;
+    }, (len, gi, oi) => {
+        commonItems.push([gi, oi, len]);
+    });
+
+    // console.log(commonItems);
+    // console.log('================================================================');
+    // merge list
+    // previous index
+    let gpi = 0;
+    let opi = 0;
+    commonItems.forEach(([gi, oi, len]) => {
+
+        if (gpi !== gi) {
+            const gList = gl.slice(gpi, gi);
+            const oList = ol.slice(opi, oi);
+            mergeList(gList, oList);
+        }
+
+        for (let i = 0; i < len; i++) {
+
+            const gii = gi + i;
+            const oii = oi + i;
+            const gItem = gl[gii];
+            gItem.original = ol[oii];
+
+            // matching a word end
+            if (i === len - 1 && len > 1) {
+                gItem.wordEnd = true;
+            }
+
+        }
+        gpi = gi + len;
+        opi = oi + len;
+    });
+
+    // console.log(JSON.stringify(data.gt));
+    // console.log(JSON.stringify(data.ot));
+    if (gpi < gl.length && opi < ol.length) {
+        const gList = gl.slice(gpi);
+        const oList = ol.slice(opi);
+        mergeList(gList, oList);
+    }
+
+    // console.log(gl);
+    return gl;
+};
+
+const getWordEndPosition = (list, gp, direction) => {
+    // for end only
+    if (direction !== 'end') {
+        return;
+    }
+
+    const prev = list[gp - 1];
+    if (prev && prev.original && prev.wordEnd) {
+        const op = prev.original.index + 1;
+        // console.log(gp, JSON.stringify(gt));
+        // console.log(op, JSON.stringify(ot));
+        return {
+            pos: op
+        };
+    }
+};
+
+const getAlignPosition = (gt, gp, ot, direction) => {
+
+    // there is no need to align for long text
+    const maxLength = 500;
+    if (gt.length > maxLength || ot.length > maxLength) {
+        // console.log(gt.length, ot.length, gp);
+        return;
+    }
+
+    // generatedText: '"false";\n',
+    // originalText: "'false';\r\n    ",
+    // generatedPos: 7
+
+    // left matched
+
+    // originalText: '1;',
+    // generatedText: '1;else',
+    // generatedLeft: '1;'
+
+    // generatedText: '    var id = options.base ? item[0] + options.base : item[0];\r\n',
+    // originalText: '    var id = options.base ? item[0] + options.base : item[0];\n',
+
+    // right matched
+    // only for original first line text
+
+    // exclusive
+    const list = alignText(gt, ot);
+    const item = list[gp];
+    if (item && item.original) {
+        return {
+            pos: item.original.index
+        };
+    }
+
+    // inclusive, for end only
+    return getWordEndPosition(list, gp, direction);
+
+};
+
+// ========================================================================================================
+
 const getBlockStartPosition = (originalLineText) => {
     // originalText: 'argument) {',
     // generatedLeft: 'o',
@@ -117,87 +256,62 @@ const getBlockEndPosition = (originalLineText) => {
 
 };
 
+// ========================================================================================================
+
 const getComparedPosition = (info, direction) => {
 
-    let gt = info.generatedText;
+    const gt = info.generatedText;
     const gp = info.generatedPos;
-    let ot = info.originalText;
-
-    // before trim
-    const oLen = ot.length;
-
-    gt = gt.trimEnd();
-    ot = ot.trimEnd();
-
-    // no original content after trim
-    if (!ot) {
-        return {
-            pos: direction === 'start' ? oLen : 0
-        };
-    }
+    const ot = info.originalText;
+    const olt = info.originalLineText;
 
-    // no generated content after trim
-    if (!gt) {
+    // seems direction is start only
+    if (gp === 0) {
         return;
     }
 
-    // same content
-    if (gt === ot) {
+    // whole generated text
+    if (gp >= gt.length) {
+        // console.log(JSON.stringify(gt), gt.length, gp);
+        // console.log(JSON.stringify(ot));
         return {
-            pos: gp
+            pos: olt.length
         };
     }
 
     // =============================
+    // trim right
+    const gtt = gt.trimEnd();
+    const ott = ot.trimEnd();
 
-    // generatedText: '"false";\n',
-    // originalText: "'false';\r\n    ",
-    // generatedPos: 7
-
-    // length not change, replace " to '
-    gt = gt.replace(/"/g, "'");
-    ot = ot.replace(/"/g, "'");
-
-
-    // same content too
-    if (gt === ot) {
+    // no original content after trim
+    if (!ott) {
         return {
-            pos: gp
+            pos: direction === 'start' ? ot.length : 0
         };
     }
 
-    // ============================
-    // left matched
-
-    // originalText: '1;',
-    // generatedText: '1;else',
-    // generatedLeft: '1;'
-
-    // generatedText: '    var id = options.base ? item[0] + options.base : item[0];\r\n',
-    // originalText: '    var id = options.base ? item[0] + options.base : item[0];\n',
+    // no generated content after trim
+    if (!gtt) {
+        return;
+    }
 
-    const left = gt.slice(0, gp);
-    if (ot.startsWith(left)) {
+    // same content
+    if (gtt === ott) {
         return {
             pos: gp
         };
     }
 
-    // ============================
-    // right matched
-    // only for original first line text
+    // =============================
 
-    const olt = info.originalLineText;
-    const right = gt.slice(gp);
-    if (olt.endsWith(right)) {
-        return {
-            pos: olt.length - right.length
-        };
-    }
+    return getAlignPosition(gt, gp, ot, direction);
 
 };
 
-const initOriginalLineText = (info) => {
+
+const getSimilarPosition = (info, direction) => {
+
     const originalText = info.originalText;
     // never cross line, using first line of original text
     // trim end remove \r\n and \n
@@ -205,44 +319,27 @@ const initOriginalLineText = (info) => {
     if (originalLines.length === 1) {
         // already single line
         info.originalLineText = originalText.trimEnd();
-        info.originalSingle = true;
-        return;
+    } else {
+        // multiple liens
+        info.originalLineText = originalLines[0].trimEnd();
     }
-    // multiple liens
-    info.originalLineText = originalLines[0].trimEnd();
-};
 
-const getSimilarPosition = (info, direction) => {
-
-    initOriginalLineText(info);
+    // no need comparison for fake source
+    if (info.fake) {
+        return;
+    }
 
     const textPos = getComparedPosition(info, direction);
     if (textPos) {
         return textPos;
     }
 
-    if (info.originalSingle) {
-        return;
-    }
-
-    // multiple lines
-    const { generatedPos, originalLineText } = info;
-    // generatedPos not in first line
-    if (generatedPos > originalLineText.length) {
-        return;
-    }
-
-    const linePos = getComparedPosition(info, direction);
-    if (linePos) {
-        return linePos;
-    }
-
     // console.log('====================================================================');
-    // console.log(`${EC.magenta(direction)} similar position can NOT be fixed`);
+    // console.log(`${EC.magenta(direction)} similar position can NOT be fixed`, info.originalState.sourcePath);
     // console.log({
-    //     sourcePath: info.originalState.sourcePath,
-    //     generatedText,
-    //     generatedPos,
+    //     direction,
+    //     generatedText: info.generatedText,
+    //     generatedPos: info.generatedPos,
     //     originalText
     // });
 
@@ -402,11 +499,13 @@ const getFixedOriginalStart = (start, mappings, state, cache) => {
         };
     }
 
-    const direction = 'start';
+
     const { originalText, originalOffset } = getOriginalText(m1, m2, cache);
     const { generatedText, generatedPos } = getGeneratedText(m1, m2, state, start);
+    const direction = 'start';
 
     const info = {
+        fake: state.fake,
         generatedText,
         generatedPos,
         originalText,
@@ -453,11 +552,13 @@ const getFixedOriginalEnd = (end, mappings, state, cache) => {
         };
     }
 
-    const direction = 'end';
+
     const { originalText, originalOffset } = getOriginalText(m1, m2, cache);
     const { generatedText, generatedPos } = getGeneratedText(m1, m2, state, end);
+    const direction = 'end';
 
     const info = {
+        fake: state.fake,
         offset: end,
         generatedText,
         generatedPos,