monocart-coverage-reports 2.5.7 → 2.5.9

package/README.md

@@ -37,6 +37,8 @@
     - [Playwright](#playwright)
     - [Jest](#jest)
     - [Vitest](#vitest)
+    - [CodeceptJS](#codeceptjs)
+    - [WebdriverIO](#webdriverio)
     - [Codecov](#codecov)
     - [Coveralls](#coveralls)
     - [Sonar Cloud](#sonar-cloud)
@@ -46,15 +48,22 @@
 ## Usage
 ```js
 const MCR = require('monocart-coverage-reports');
-const options = {
+const coverageOptions = {
+    name: 'My Coverage Report - 2024-02-28',
     outputDir: './coverage-reports',
-    reports: "v8"
+    reports: ["v8", "console-details"]
 }
-const coverageReport = MCR(options);
+const coverageReport = MCR(coverageOptions);
+coverageReport.cleanCache();
+
 await coverageReport.add(coverageData1);
 await coverageReport.add(coverageData2);
-const coverageResults = await coverageReport.generate();
-console.log(coverageResults.summary);
+
+await coverageReport.generate();
+
+// Or 
+// const { CoverageReport } = require('monocart-coverage-reports');
+// const coverageReport = new CoverageReport(coverageOptions);
 ```
 - [example v8](https://github.com/cenfun/monocart-coverage-reports/blob/main/test/test-v8.js)
 - [example istanbul](https://github.com/cenfun/monocart-coverage-reports/blob/main/test/test-istanbul.js)
@@ -132,7 +141,7 @@ console.log(coverageResults.summary);
 ### Multiple Reports:
 ```js
 const MCR = require('monocart-coverage-reports');
-const options = {
+const coverageOptions = {
     outputDir: './coverage-reports',
     reports: [
         // build-in reports
@@ -151,14 +160,15 @@ const options = {
         ["custom-reporter-1"],
         ["custom-reporter-2", {
             type: "istanbul",
-            option: "value"
+            key: "value"
         }],
         // Specify reporter name with local path
         ['/absolute/path/to/custom-reporter.js']
 
     ]
 }
-const coverageReport = MCR(options);
+const coverageReport = MCR(coverageOptions);
+coverageReport.cleanCache();
 ```
 
 ## Using `entryFilter` and `sourceFilter` to filter the results for V8 report
@@ -190,12 +200,22 @@ const coverageOptions = {
     sourceFilter: (sourcePath) => sourcePath.search(/src\//) !== -1
 };
 ```
-Or `minimatch` pattern:
+Or using `minimatch` pattern:
 ```js
 const coverageOptions = {
     entryFilter: "**/main.js",
     sourceFilter: "**/src/**"
 };
+// supports multiple patterns:
+const coverageOptions = {
+    entryFilter: {
+        '**/vendor.js': false,
+        '**/main.js': true
+    },
+    sourceFilter: {
+        '**/src/**': true
+    }
+};
 ```
 
 ## onEnd Hook
@@ -343,21 +363,31 @@ await MCR(coverageOptions).add(jsCoverage);
 ## Collecting Raw V8 Coverage Data with Puppeteer
 > Puppeteer does not provide raw v8 coverage data by default. A simple conversion is required, see example: [./test/test-puppeteer.js](./test/test-puppeteer.js)
 ```js
-await page.coverage.startJSCoverage({
-    // provide raw v8 coverage data
-    includeRawScriptCoverage: true
-});
+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 = await page.coverage.stopJSCoverage();
-const rawV8CoverageData = jsCoverage.map((it) => {
-    // Convert to raw v8 coverage format
+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];
 ```
 
 ## Node.js V8 Coverage Report for Server Side
@@ -397,34 +427,40 @@ Possible solutions:
 > 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');
-MCR(options).cleanCache();
+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();
 ```
 
 - Sub process 1, testing stage 1
 ```js
 const MCR = require('monocart-coverage-reports');
-const options = require('path-to/same-options.js');
-await MCR(options).add(coverageData1);
+const coverageOptions = require('path-to/same-options.js');
+const coverageReport = MCR(coverageOptions);
+// do not clean cache in the stage
+await coverageReport.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);
+const coverageOptions = require('path-to/same-options.js');
+const coverageReport = MCR(coverageOptions);
+// do not clean cache in the stage
+await coverageReport.add(coverageData2);
 ```
 
 - Main process, after the completion of testing
 ```js
 // 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);
-const coverageResults = await coverageReport.generate();
-console.log(coverageResults.summary);
+const coverageOptions = require('path-to/same-options.js');
+const coverageReport = MCR(coverageOptions);
+// do not clean cache before generating reports
+await coverageReport.generate();
 ```
 
 ## Merge Coverage Reports
@@ -451,6 +487,7 @@ const coverageOptions = {
 ```
 Then, after all the tests are completed, generate a merged report with option `inputDir`:
 ```js
+// esm syntax
 import fs from "fs";
 import { CoverageReport } from 'monocart-coverage-reports';
 const coverageOptions = {
@@ -503,42 +540,41 @@ const coverageOptions = {
 ```
 
 ## Adding Empty Coverage for Untested Files
-By default the untested files will not be included in the coverage report, we can first add empty coverage data for all files, so the files with coverage data will be merged, and untested files will retain 0% coverage.
+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.
 ```js
-const fs = require('fs');
-const path = require('path');
-const { pathToFileURL } = require('url');
-const MCR = require('monocart-coverage-reports');
-
-const dir = "./src";
-const coverageData = [];
-const fileList = fs.readdirSync(dir);
-for (const filename of fileList) {
-    const filePath = path.resolve(dir, filename);
-    const source = fs.readFileSync(filePath).toString('utf-8');
-    const sourcePath = path.relative(process.cwd(), filePath);
-    const url = pathToFileURL(sourcePath).toString();
-    const extname = path.extname(filename);
-    if (['.css'].includes(extname)) {
-        coverageData.push({
-            empty: true,
-            type: 'css',
-            url,
-            text: source
-        });
-    } else {
-        coverageData.push({
-            empty: true,
-            type: 'js',
-            url,
-            source
-        });
+const coverageOptions = {
+    all: {
+        dir: ['./src'],
+        filter: (filePath) => {
+            return true;
+        }
     }
-}
-const options = require('path-to/same-options.js');
-await MCR(options).add(coverageData);
+};
+```
+The filter also supports `minimatch` pattern:
+```js
+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
+        }
+    }
+};
 ```
-see example: [./test/cli-options.js](./test/cli-options.js)
 
 ## Ignoring Uncovered Codes
 To ignore codes, use the special comment which starts with `v8 ignore `:
@@ -675,6 +711,12 @@ When `logging` is `debug`, the raw report data will be preserved in `[outputDir]
 ### [Vitest](https://github.com/vitest-dev/vitest)
 - [vitest-monocart-coverage](https://github.com/cenfun/vitest-monocart-coverage) - A Vitest custom provider module for coverage reports
 
+### [CodeceptJS](https://github.com/codeceptjs/CodeceptJS)
+- [codeceptjs-monocart-coverage](https://github.com/cenfun/codeceptjs-monocart-coverage) - A CodeceptJS plugin for coverage reports
+
+### [WebdriverIO](https://github.com/webdriverio/webdriverio)
+- [wdio-monocart-service](https://github.com/cenfun/wdio-monocart-service) - A WebdriverIO service 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.js

@@ -167,19 +167,34 @@ const getJsAstInfo = (item, coverageList) => {
         allowHashBang: true
     };
 
+    let err;
     let ast;
     try {
         ast = acorn.parse(source, options);
     } catch (e) {
+        err = e;
+    }
+
+    if (err) {
 
-        // empty = untested file, could be .ts, .vue and so on, that can not be parsed normally
-        if (!empty) {
-            Util.logInfo(`failed to parse source file: ${item.sourcePath} ${e.message}`);
+        // empty = untested file
+        // could be .ts, .vue and so on, that can not be parsed normally
+        if (empty) {
+            return {
+                functions: [],
+                branches: [],
+                statements: []
+            };
         }
+
+        // runtime code should be parsed successful
+        Util.logInfo(`failed to parse source file: ${item.sourcePath} ${err.message}`);
+
         // https://github.com/acornjs/acorn/tree/master/acorn-loose
         // It is recommended to always try a parse with the regular acorn parser first,
         // and only fall back to this parser when that one finds syntax errors.
         ast = acornLoose.parse(source, options);
+
     }
 
     const coverageInfo = getCoverageInfo(coverageList);

package/lib/converter/converter.js

@@ -697,6 +697,9 @@ const handleOriginalBytesCoverage = (state, originalStateMap) => {
         // });
     }
 
+
+    const checkList = [];
+
     // check original bytes if fully in a wrapper range
     originalStateMap.forEach((originalState) => {
         const bytes = originalState.bytes;
@@ -727,6 +730,30 @@ const handleOriginalBytesCoverage = (state, originalStateMap) => {
         // console.log('===========================================================', originalState.sourcePath);
         // console.log(originalState.source.length, endMapping);
 
+        checkList.push({
+            originalState,
+            startOffset,
+            endOffset
+        });
+
+    });
+
+    if (!checkList.length) {
+        return;
+    }
+
+    // there is no state.bytes if not in debug
+    // should using coverageList to generate bytes first
+    handleBytesCoverage(state);
+
+    checkList.forEach((it) => {
+
+        const {
+            originalState, startOffset, endOffset
+        } = it;
+
+        // console.log('=============', 'no bytes', originalState.sourcePath);
+
         // only check uncovered range
         // because a uncovered range could be in a covered wrapper
         // { start: 0, end: 12137, count: 1 }, could be { start: > 0, end: < 12137, count: 0 }
@@ -735,7 +762,8 @@ const handleOriginalBytesCoverage = (state, originalStateMap) => {
                 continue;
             }
             if (startOffset >= range.start && endOffset <= range.end) {
-                bytes.push({
+                // console.log('------------', 'added');
+                originalState.bytes.push({
                     start: 0,
                     end: originalState.source.length,
                     count: 0
@@ -746,6 +774,7 @@ const handleOriginalBytesCoverage = (state, originalStateMap) => {
 
     });
 
+
 };
 
 // ========================================================================================================
@@ -841,17 +870,34 @@ const getOriginalDecodedMappings = (originalDecodedMap, sourceIndex, locator) =>
 // ========================================================================================================
 
 const getSourceFilter = (options) => {
-    const sourceFilter = options.sourceFilter;
-    if (typeof sourceFilter === 'function') {
-        return sourceFilter;
+    const input = options.sourceFilter;
+
+    // for function handler
+    if (typeof input === 'function') {
+        return input;
     }
 
-    if (sourceFilter && typeof sourceFilter === 'string') {
+    // for single minimatch pattern
+    if (input && typeof input === 'string') {
         return (sourcePath) => {
-            return minimatch(sourcePath, sourceFilter);
+            return minimatch(sourcePath, input);
+        };
+    }
+
+    // for patterns
+    if (input && typeof input === 'object') {
+        const patterns = Object.keys(input);
+        return (sourcePath) => {
+            for (const pattern of patterns) {
+                if (minimatch(sourcePath, pattern)) {
+                    return input[pattern];
+                }
+            }
+            // false if not matched
         };
     }
 
+    // default
     return () => true;
 };
 

package/lib/default/options.js

@@ -46,6 +46,13 @@ module.exports = {
     // sourceFilter: (sourcePath) => sourcePath.search(/src\/.+/) !== -1,
     sourceFilter: null,
 
+    // options for adding empty coverage for all files
+    // all: {
+    //     dir: ['src'],
+    //     filter: (sourcePath) => true
+    // },
+    all: null,
+
     // (V8 only) {boolean} Enable/Disable ignoring uncovered codes with the special comments: v8 ignore next/next N/start/stop
     v8Ignore: true,
 
@@ -65,9 +72,12 @@ module.exports = {
     // {object} { bytes:[50,80], statements:[50,80], branches:[50,80], functions:[50,80], lines:[50,80] }
     watermarks: [50, 80],
 
-    // {boolean} clean previous files in output dir before generating report. Defaults to true.
+    // {boolean} Indicates whether to clean previous files in output dir before generating report. Defaults to true.
     clean: true,
 
+    // {boolean} Indicates whether to clean previous cache in output dir before generating report. Defaults to false.
+    cleanCache: false,
+
     // {function} onEnd hook
     // onEnd: async (reportData) => {}
     onEnd: null

package/lib/generate.js

@@ -11,6 +11,9 @@ const { mergeV8Coverage, saveV8Report } = require('./v8/v8.js');
 
 const { convertV8List } = require('./converter/converter.js');
 
+const { minimatch } = require('./packages/monocart-coverage-vendor.js');
+const { pathToFileURL } = require('url');
+
 // ========================================================================================================
 
 // maybe v8 or to istanbul reports
@@ -288,8 +291,175 @@ const generateCoverageReports = async (dataList, sourceCache, options) => {
 
 // ========================================================================================================
 
+const resolveAllDirList = (input) => {
+    const dirs = Util.toList(input, ',');
+    if (!dirs.length) {
+        return;
+    }
+    const dirList = dirs.filter((it) => fs.existsSync(it));
+    if (!dirList.length) {
+        return;
+    }
+    return dirList;
+};
+
+const resolveAllFilter = (input) => {
+    // for function handler
+    if (typeof input === 'function') {
+        return input;
+    }
+
+    // for single minimatch pattern
+    if (input && typeof input === 'string') {
+        return (filePath) => {
+            return minimatch(filePath, input);
+        };
+    }
+
+    // for patterns
+    if (input && typeof input === 'object') {
+        const patterns = Object.keys(input);
+        return (filePath) => {
+            for (const pattern of patterns) {
+                if (minimatch(filePath, pattern)) {
+                    return input[pattern];
+                }
+            }
+            // false if not matched
+        };
+    }
+
+    // default
+    return () => true;
+};
+
+const resolveAllDataType = (type, dataList) => {
+    if (!type && dataList.length) {
+        const firstData = dataList[0];
+        type = firstData.type;
+    }
+    const types = {
+        v8: 'v8',
+        istanbul: 'istanbul'
+    };
+    return types[type] || types.v8;
+};
 
-const getInputData = async (inputList) => {
+const resolveAllOptions = (input, dataList) => {
+    if (!input) {
+        return;
+    }
+
+    let type;
+    let dir;
+    let filter;
+    if (typeof input === 'string' || Array.isArray(input)) {
+        dir = input;
+        filter = () => true;
+    } else {
+        type = input.type;
+        dir = input.dir;
+        filter = input.filter;
+    }
+
+    const dirList = resolveAllDirList(dir);
+    if (!dirList) {
+        return;
+    }
+
+    const dataType = resolveAllDataType(type, dataList);
+    const fileFilter = resolveAllFilter(filter);
+
+    return {
+        dirList,
+        dataType,
+        fileFilter
+    };
+};
+
+const resolveFileType = (fileType, filePath) => {
+    if (fileType === 'js' || fileType === 'css') {
+        return fileType;
+    }
+    const extname = path.extname(filePath);
+    if (['.css', '.scss', '.sass', '.less'].includes(extname)) {
+        return 'css';
+    }
+    return 'js';
+};
+
+const getV8EmptyData = (fileList) => {
+    const v8DataList = [];
+    fileList.forEach((item) => {
+        const { filePath, fileType } = item;
+        const type = resolveFileType(fileType, filePath);
+        const url = pathToFileURL(filePath).toString();
+        const source = Util.readFileSync(filePath);
+        const entryFile = {
+            empty: true,
+            type,
+            url,
+            // for empty, css supports both source and text
+            source
+        };
+        v8DataList.push(entryFile);
+    });
+    return v8DataList;
+};
+
+const getIstanbulEmptyData = (fileList) => {
+    const istanbulData = {};
+    fileList.forEach((item) => {
+        const { filePath } = item;
+        istanbulData[filePath] = {
+            path: filePath,
+            statementMap: {},
+            fnMap: {},
+            branchMap: {},
+            s: {},
+            f: {},
+            b: {}
+        };
+    });
+    return istanbulData;
+};
+
+const getEmptyData = (all, dataList) => {
+    const allOptions = resolveAllOptions(all, dataList);
+    // console.log('allOptions', all, allOptions);
+    if (!allOptions) {
+        return;
+    }
+    const {
+        dirList, dataType, fileFilter
+    } = allOptions;
+    const fileList = [];
+    dirList.forEach((dir) => {
+        Util.forEachFile(dir, [], (fileName, fileDir) => {
+            const filePath = path.resolve(fileDir, fileName);
+            const fileType = fileFilter(filePath);
+            if (fileType) {
+                fileList.push({
+                    filePath,
+                    fileType
+                });
+            }
+        });
+    });
+    // console.log('fileList', fileList);
+    if (!fileList.length) {
+        return;
+    }
+    if (dataType === 'v8') {
+        return getV8EmptyData(fileList);
+    }
+    return getIstanbulEmptyData(fileList);
+};
+
+// ========================================================================================================
+
+
+const getInputData = async (inputList, all, cacheDir, addHandler) => {
     const dataList = [];
     const sourceCache = new Map();
 
@@ -321,6 +491,35 @@ const getInputData = async (inputList) => {
             }
         }
     }
+
+    // add empty coverage for all files
+    // dataList for data type, before `add` we don't which one is tested, because using hash id
+    const emptyData = getEmptyData(all, dataList);
+    if (emptyData) {
+        const coverageResults = await addHandler(emptyData);
+        // after `add`
+        if (coverageResults) {
+            dataList.push(coverageResults);
+            if (coverageResults.type === 'v8') {
+                // sourceCache
+                coverageResults.data.forEach((entry) => {
+                    const { id } = entry;
+                    if (sourceCache.has(id)) {
+                        // console.log('+', entry.sourcePath);
+                        return;
+                    }
+                    // console.log('-', entry.sourcePath);
+                    const sourcePath = Util.resolveCacheSourcePath(cacheDir, id);
+                    const content = Util.readFileSync(sourcePath);
+                    if (content) {
+                        const json = JSON.parse(content);
+                        sourceCache.set(json.id, json);
+                    }
+                });
+            }
+        }
+    }
+
     return {
         dataList,
         sourceCache