monocart-coverage-reports 2.7.0 → 2.7.2

package/README.md

@@ -6,15 +6,14 @@
 ![](https://img.shields.io/github/license/cenfun/monocart-coverage-reports)
 ![](https://img.shields.io/github/actions/workflow/status/cenfun/monocart-coverage-reports/static.yml)
 
-
-> A code coverage tool to generate native [V8](https://v8.dev/blog/javascript-code-coverage) reports or [Istanbul](https://istanbul.js.org/) reports. As early as 2017, V8 started offering native support for coverage data. However, we have essentially only been able to see coverage reports from Istanbul. Nowadays, we can directly generate V8 coverage reports with `monocart-coverage-reports`.
+> A code coverage tool to generate native [V8](https://v8.dev/blog/javascript-code-coverage) reports or [Istanbul](https://istanbul.js.org/) reports.
 
 * [Usage](#usage)
 * [Default Options](#default-options)
 * [Available Reports](#available-reports)
 * [Using `entryFilter` and `sourceFilter` to filter the results for V8 report](#using-entryfilter-and-sourcefilter-to-filter-the-results-for-v8-report)
 * [onEnd Hook](#onend-hook)
-* [`mcr` CLI](#mcr-cli)
+* [Command Line](#command-line)
 * [Compare Reports](#compare-reports)
 * [Compare Workflows](#compare-workflows)
 * [Collecting Istanbul Coverage Data](#collecting-istanbul-coverage-data)
@@ -275,7 +274,7 @@ const coverageOptions = {
 }
 ```
 
-## `mcr` CLI
+## Command Line
 > The CLI will run the program as a [child process](https://nodejs.org/docs/latest/api/child_process.html) with `NODE_V8_COVERAGE=dir` until it exits gracefully, and generate the coverage report with the coverage data from the `dir`.
 
 - Installing globally
@@ -324,8 +323,9 @@ Options:
     - `mcr.config.json` - json format
     - `.mcrrc.js`
     - `.mcrrc` - json format
-    - `mcr.config.ts` - it requires `NODE_OPTIONS="--loader ts-node/esm"`
+    - `mcr.config.ts` (requires preloading the typescript module)
 
+- Working with `tsx`, see [mcr-tsx](https://github.com/cenfun/mcr-tsx)
 - Working with `ts-node`, see [mcr-ts-node](https://github.com/cenfun/mcr-ts-node)
 
 ## Compare Reports
@@ -454,7 +454,7 @@ Possible solutions:
     > node [./test/test-node-koa.js](./test/test-node-koa.js)
 
 - [Child Process](https://nodejs.org/docs/latest/api/child_process.html) + NODE_V8_COVERAGE
-    - see [`mcr` CLI](#mcr-cli)
+    - see [Command Line](#command-line)
 
 ## Collecting V8 Coverage Data with `CDPClient` API
 - Work with node debugger `--inspect=9229`
@@ -814,6 +814,7 @@ const coverageOptions = {
 - [cypress-monocart-coverage](https://github.com/cenfun/cypress-monocart-coverage) - A Cypress plugin for coverage reports
 
 ### [CodeceptJS](https://github.com/codeceptjs/CodeceptJS)
+- CodeceptJS has integrated MCR from version [3.5.15](https://github.com/codeceptjs/CodeceptJS/releases/tag/3.5.15)
 - [codeceptjs-monocart-coverage](https://github.com/cenfun/codeceptjs-monocart-coverage) - A CodeceptJS plugin for coverage reports
 
 ### [WebdriverIO](https://github.com/webdriverio/webdriverio)

package/lib/cli.js

@@ -3,7 +3,6 @@
 const fs = require('fs');
 const path = require('path');
 const EC = require('eight-colors');
-const { fileURLToPath } = require('url');
 
 const {
     foregroundChild,
@@ -12,120 +11,104 @@ const {
 
 const MCR = require('./index.js');
 const Util = require('./utils/util.js');
-const { resolveSourceMap } = require('./converter/collect-source-maps.js');
 
 const version = require('../package.json').version;
 
-const resolveEntrySource = (entry, sourceMapCache = {}) => {
-    let source;
-    const filePath = fileURLToPath(entry.url);
-    const extname = path.extname(filePath);
-    if (fs.existsSync(filePath)) {
-        source = fs.readFileSync(filePath).toString('utf8');
+const getRegisterPath = (filename) => {
+    const rel = Util.relativePath(path.resolve(__dirname, 'register', filename));
+    if (rel.startsWith('.')) {
+        return rel;
     }
+    return `./${rel}`;
+};
 
-    // not for typescript, but it could be jsx even it is `.js`
-    if (source && !['.ts', '.tsx'].includes(extname)) {
-        entry.source = source;
-        return;
+const isFeatureSupported = (nv) => {
+    // module register added in Node.js: v20.6.0
+    const [major, minor] = nv.split('.').map((s) => parseInt(s));
+    if (major < 20) {
+        return false;
     }
-
-    const sourcemapData = sourceMapCache[entry.url];
-    const lineLengths = sourcemapData && sourcemapData.lineLengths;
-
-    // for fake source file (can not parse to AST)
-    if (lineLengths) {
-        let fakeSource = '';
-        sourcemapData.lineLengths.forEach((length) => {
-            fakeSource += `${''.padEnd(length, '*')}\n`;
-        });
-        entry.fake = true;
-        entry.source = fakeSource;
+    if (major > 20) {
+        return true;
     }
-
-    // Note: no runtime code in source map cache
-    // This is a problem for typescript
-
-};
-
-const resolveEntrySourceMap = (entry, sourceMapCache = {}) => {
-    // sourcemap data
-    const sourcemapData = sourceMapCache[entry.url];
-    if (sourcemapData) {
-        if (sourcemapData.data) {
-            entry.sourceMap = resolveSourceMap(sourcemapData.data, entry.url);
-        }
+    if (minor < 6) {
+        return false;
     }
+    return true;
 };
 
-const collectCoverageData = (coverageList, entryFilter, sourceMapCache = {}) => {
-
-    if (!Util.isList(coverageList)) {
+const initNodeOptions = async (cliOptions) => {
+    const nv = process.versions.node;
+    if (!isFeatureSupported(nv)) {
+        Util.logInfo(EC.yellow(`The current Node.js version "${nv}" does NOT support "module.register", it requires "20.6.0" or higher.`));
         return;
     }
 
-    // filter node internal files
-    coverageList = coverageList.filter((entry) => entry.url && entry.url.startsWith('file:'));
-    coverageList = coverageList.filter(entryFilter);
-
-    if (!Util.isList(coverageList)) {
-        return;
+    const nodeOptions = [];
+    if (process.env.NODE_OPTIONS) {
+        nodeOptions.push(process.env.NODE_OPTIONS);
     }
 
-    for (const entry of coverageList) {
-        resolveEntrySource(entry, sourceMapCache);
-        resolveEntrySourceMap(entry, sourceMapCache);
+    if (cliOptions.import) {
+        nodeOptions.push('--import');
+        nodeOptions.push(cliOptions.import);
+        await import(cliOptions.import);
+    } else if (cliOptions.require) {
+        nodeOptions.push('--require');
+        nodeOptions.push(cliOptions.require);
+        await import(cliOptions.require);
     }
 
-    return coverageList;
-};
+    // console.log(nodeOptions);
 
-const addCoverageData = async (coverageReport, nodeV8CoverageDir) => {
+    // export source after
+    const hasImport = nodeOptions.find((it) => typeof it === 'string' && it.includes('--import'));
+    if (hasImport) {
+        const importPath = getRegisterPath('register.mjs');
+        const hasImportPath = nodeOptions.find((it) => typeof it === 'string' && it.includes(importPath));
+        if (!hasImportPath) {
+            nodeOptions.push('--import');
+            nodeOptions.push(importPath);
+        }
+    } else {
+        const requirePath = getRegisterPath('register.js');
+        const hasRequirePath = nodeOptions.find((it) => typeof it === 'string' && it.includes(requirePath));
+        if (!hasRequirePath) {
+            nodeOptions.push('--require');
+            nodeOptions.push(requirePath);
+        }
+    }
 
-    let added = false;
+    // console.log(nodeOptions);
 
-    const files = fs.readdirSync(nodeV8CoverageDir);
-    if (!files.length) {
-        return added;
-    }
+    process.env.NODE_OPTIONS = nodeOptions.join(' ');
 
-    // filter before adding
-    const entryFilter = coverageReport.getEntryFilter();
-    for (const filename of files) {
-        const filePath = path.resolve(nodeV8CoverageDir, filename);
-        const content = fs.readFileSync(filePath).toString('utf-8');
-        if (content) {
-            const json = JSON.parse(content);
-            const coverageList = json.result;
-            const sourceMapCache = json['source-map-cache'];
-            const coverageData = collectCoverageData(coverageList, entryFilter, sourceMapCache);
-            if (coverageData) {
-                await coverageReport.add(coverageData);
-                added = true;
-            }
-        }
-    }
+};
 
-    return added;
+const initNodeV8CoverageDir = (coverageOptions) => {
+    // dir for node v8 coverage
+    const nodeV8CoverageDir = Util.relativePath(path.resolve(coverageOptions.outputDir, '.v8-coverage'));
+    process.env.NODE_V8_COVERAGE = nodeV8CoverageDir;
+    // clean v8 cache before running
+    Util.rmSync(nodeV8CoverageDir);
+    // Util.logInfo(`V8 coverage dir: ${EC.cyan(nodeV8CoverageDir)}`);
+
+    return nodeV8CoverageDir;
 };
 
 const executeCommand = async (command, cliOptions) => {
 
     Util.logInfo(`Execute: ${EC.cyan(command)}`);
 
+    await initNodeOptions(cliOptions);
+
     // console.log(options);
     const coverageReport = MCR(cliOptions);
     await coverageReport.loadConfig(cliOptions.config);
     coverageReport.cleanCache();
 
     const coverageOptions = coverageReport.options;
-
-    // dir for node v8 coverage
-    const nodeV8CoverageDir = Util.relativePath(path.resolve(coverageOptions.outputDir, '.v8-coverage'));
-    process.env.NODE_V8_COVERAGE = nodeV8CoverageDir;
-    // clean v8 cache before running
-    Util.rmSync(nodeV8CoverageDir);
-    // Util.logInfo(`V8 coverage dir: ${EC.cyan(nodeV8CoverageDir)}`);
+    const nodeV8CoverageDir = initNodeV8CoverageDir(coverageOptions);
 
     // =========================================
     // onStart hook
@@ -141,11 +124,6 @@ const executeCommand = async (command, cliOptions) => {
 
         // generate coverage even it is failed. code != 0
 
-        if (!fs.existsSync(nodeV8CoverageDir)) {
-            EC.logRed(`Not found V8 coverage dir: ${Util.relativePath(nodeV8CoverageDir)}`);
-            return 1;
-        }
-
         // =========================================
         // onReady hook before adding coverage data.
         // Sometimes, the child process has not yet finished writing the coverage data, and it needs to wait here.
@@ -155,7 +133,12 @@ const executeCommand = async (command, cliOptions) => {
         }
         // =========================================
 
-        await addCoverageData(coverageReport, nodeV8CoverageDir);
+        if (!fs.existsSync(nodeV8CoverageDir)) {
+            EC.logRed(`Invalid V8 coverage dir: ${Util.relativePath(nodeV8CoverageDir)}`);
+            return 1;
+        }
+
+        await coverageReport.addFromDir(nodeV8CoverageDir);
         await coverageReport.generate();
 
         // remove nodeV8CoverageDir
@@ -196,6 +179,9 @@ program
 
     .option('--lcov', 'generate lcov.info file')
 
+    .option('--import <module>', 'preload module at startup')
+    .option('--require <module>', 'preload module at startup')
+
     .action((_command, cliOptions) => {
         const command = program.args.join(' ');
         executeCommand(command, cliOptions);

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

@@ -54,22 +54,37 @@ const getSourceMapUrl = (content, url) => {
     }
 };
 
-const resolveSourcesContent = (sources, url) => {
-    const list = [];
-    for (const file of sources) {
+const resolveSourcesContent = (data, url) => {
+
+    const { sources, sourcesContent } = data;
+
+    let failed = false;
+    sources.forEach((file, i) => {
+        if (typeof sourcesContent[i] === 'string') {
+            return;
+        }
+
         const sourceUrl = Util.resolveUrl(file, url);
         if (sourceUrl) {
-            const sourcePath = sourceUrl.toString();
+            let sourcePath = sourceUrl.toString();
+            // could be no `file:`
             if (sourcePath.startsWith('file:')) {
-                const content = Util.readFileSync(path.resolve(fileURLToPath(sourcePath)));
-                list.push(content);
-                continue;
+                sourcePath = fileURLToPath(sourcePath);
+            }
+            const content = Util.readFileSync(path.resolve(sourcePath));
+            if (typeof content === 'string') {
+                sourcesContent[i] = content;
+                return;
             }
         }
+
         Util.logDebug(EC.red(`failed to load source content ${file}`));
-    }
-    if (list.length === sources.length) {
-        return list;
+        failed = true;
+    });
+
+
+    if (!failed) {
+        return data;
     }
 };
 
@@ -85,17 +100,19 @@ const resolveSourceMap = (data, url) => {
         return;
     }
 
-    // exists sources content
-    if (sourcesContent && sourcesContent.length === sources.length) {
-        return data;
+    // check sources content
+    if (sourcesContent) {
+        // all should be string, could be [null]
+        const contents = sourcesContent.filter((content) => typeof content === 'string');
+        if (contents.length === sources.length) {
+            return data;
+        }
+    } else {
+        data.sourcesContent = [];
     }
 
     // load sources content by sources
-    const contents = resolveSourcesContent(sources, url);
-    if (contents) {
-        data.sourcesContent = contents;
-        return data;
-    }
+    return resolveSourcesContent(data, url);
 
 };
 

package/lib/converter/converter.js

@@ -1069,12 +1069,12 @@ const generateCoverageForDist = (state) => {
 
 const unpackSourceMap = (state, options) => {
 
-    const { sourceMap } = state;
+    const { sourceMap, sourcePath } = state;
 
     // keep original urls
     const fileUrls = {};
     const sourcePathHandler = getSourcePathHandler(options);
-    initSourceMapSourcePath(sourceMap, fileUrls, sourcePathHandler);
+    initSourceMapSourcePath(sourceMap, fileUrls, sourcePath, sourcePathHandler);
     state.fileUrls = fileUrls;
 
     // ===============================================

package/lib/generate.js

@@ -2,7 +2,7 @@ const fs = require('fs');
 const path = require('path');
 const CG = require('console-grid');
 const EC = require('eight-colors');
-const { pathToFileURL } = require('url');
+const { pathToFileURL, fileURLToPath } = require('url');
 
 const Util = require('./utils/util.js');
 const {
@@ -12,6 +12,7 @@ const {
 const { mergeV8Coverage, saveV8Report } = require('./v8/v8.js');
 
 const { convertV8List } = require('./converter/converter.js');
+const { resolveSourceMap } = require('./converter/collect-source-maps.js');
 
 const { minimatch } = require('./packages/monocart-coverage-vendor.js');
 const { getGroupedRows } = require('./utils/snapshot.js');
@@ -720,7 +721,135 @@ const getInputData = async (inputList, all, cacheDir, addHandler) => {
     };
 };
 
+// ========================================================================================================
+
+const resolveEntrySource = (entry, sourceMapCache, sourceCache) => {
+
+    const url = entry.url;
+
+    // source from `source-id.json`
+    const sourceData = sourceCache[url];
+    if (sourceData) {
+        entry.source = sourceData.source;
+        return;
+    }
+
+    // source for typescript file from source map cache
+    // Note: no runtime code but lineLengths
+    const tsExtensionsPattern = /\.([cm]?ts|[tj]sx)($|\?)/;
+    if (tsExtensionsPattern.test(url)) {
+        const sourcemapData = sourceMapCache[url];
+        const lineLengths = sourcemapData && sourcemapData.lineLengths;
+
+        // for fake source file (can not parse to AST)
+        if (lineLengths) {
+            let fakeSource = '';
+            sourcemapData.lineLengths.forEach((length) => {
+                fakeSource += `${''.padEnd(length, '*')}\n`;
+            });
+            entry.fake = true;
+            entry.source = fakeSource;
+            return;
+        }
+
+    }
+
+    // Note: it could be jsx format even extname is `.js`
+    const filePath = fileURLToPath(url);
+    if (fs.existsSync(filePath)) {
+        entry.source = fs.readFileSync(filePath).toString('utf8');
+    }
+
+};
+
+const resolveEntrySourceMap = (entry, sourceMapCache) => {
+    // sourcemap data
+    const sourcemapData = sourceMapCache[entry.url];
+    if (sourcemapData) {
+        if (sourcemapData.data) {
+            entry.sourceMap = resolveSourceMap(sourcemapData.data, entry.url);
+        }
+    }
+};
+
+const readCoverageData = (filePath, entryFilter, sourceCache) => {
+
+    const content = fs.readFileSync(filePath).toString('utf-8');
+    if (!content) {
+        return;
+    }
+
+    const json = JSON.parse(content);
+    let coverageData = json.result;
+    if (!Util.isList(coverageData)) {
+        return;
+    }
+
+    // filter node internal files, should no anonymous for nodejs
+    coverageData = coverageData.filter((entry) => entry.url && entry.url.startsWith('file:'));
+    coverageData = coverageData.filter(entryFilter);
+
+    if (!Util.isList(coverageData)) {
+        // Util.logDebug('No coverage data after filter');
+        return;
+    }
+
+    const sourceMapCache = json['source-map-cache'] || {};
+    for (const entry of coverageData) {
+        resolveEntrySource(entry, sourceMapCache, sourceCache);
+        resolveEntrySourceMap(entry, sourceMapCache);
+    }
+
+    return coverageData;
+};
+
+const readFromDir = async (dir, entryFilter, addHandler) => {
+
+    if (!dir || !fs.existsSync(dir)) {
+        Util.logError(`Invalid V8 coverage dir: ${dir}`);
+        return;
+    }
+
+    const files = fs.readdirSync(dir);
+    if (!files.length) {
+        Util.logInfo(`No coverage files in the dir: ${dir}`);
+        return;
+    }
+
+    const coverageFiles = [];
+    const sourceCache = {};
+    files.forEach((filename) => {
+        const isCoverage = filename.startsWith('coverage-');
+        if (isCoverage) {
+            coverageFiles.push(filename);
+            return;
+        }
+        const isSource = filename.startsWith('source-');
+        if (isSource) {
+            const filePath = path.resolve(dir, filename);
+            const content = fs.readFileSync(filePath).toString('utf-8');
+            if (content) {
+                const json = JSON.parse(content);
+                if (json.url) {
+                    sourceCache[json.url] = json;
+                }
+            }
+        }
+    });
+
+    // filter before adding
+    for (const filename of coverageFiles) {
+        const filePath = path.resolve(dir, filename);
+        const coverageData = readCoverageData(filePath, entryFilter, sourceCache);
+        if (coverageData) {
+            await addHandler(coverageData);
+        }
+    }
+
+};
+
 module.exports = {
     getInputData,
+    readFromDir,
     generateCoverageReports
 };

package/lib/index.d.ts

@@ -255,7 +255,7 @@ declare namespace MCR {
          * 
          * {object} Replace key with value.
          * */
-        sourcePath?: ((filePath: string) => string) | {
+        sourcePath?: ((filePath: string, info: any) => string) | {
             [key: string]: string;
         };
 
@@ -347,6 +347,12 @@ declare namespace MCR {
          * @param coverageData {array} V8 format, {object} Istanbul format */
         add: (coverageData: any[] | any) => Promise<AddedResults>;
 
+        /**
+         * add V8 coverage from a dir
+         * @param dir node v8 coverage dir
+         */
+        addFromDir: (dir: string) => Promise<void>;
+
         /** generate report */
         generate: () => Promise<CoverageResults>;
 

package/lib/index.js

@@ -7,7 +7,9 @@ const defaultOptions = require('./default/options.js');
 const Util = require('./utils/util.js');
 
 const { initV8ListAndSourcemap, getEntryFilter } = require('./v8/v8.js');
-const { getInputData, generateCoverageReports } = require('./generate.js');
+const {
+    getInputData, readFromDir, generateCoverageReports
+} = require('./generate.js');
 const { getSnapshot, diffSnapshot } = require('./utils/snapshot.js');
 const CDPClient = require('./client/cdp-client.js');
 
@@ -113,6 +115,14 @@ class CoverageReport {
         return results;
     }
 
+    // add coverage from dir
+    addFromDir(dir) {
+        const entryFilter = this.getEntryFilter();
+        return readFromDir(dir, entryFilter, (coverageData) => {
+            return this.add(coverageData);
+        });
+    }
+
     // generate report
     async generate() {