monocart-reporter 1.6.32 → 1.6.34

package/README.md

@@ -451,18 +451,6 @@ test.describe('suite title', () => {
  */
 const { test, expect } = require('@playwright/test');
 ```
-```js
-// for project (Can't use comments but use project level `metadata`)
-// playwright.config.js
-module.exports = {
-    projects: [{
-        name: 'Desktop Chromium',
-        metadata: {
-            owner: 'PO'
-        }
-    }]
-};  
-```
 
 ### Remove Secrets and Sensitive Data
 > The report may hosted outside of the organization’s internal boundaries, security becomes a big issue. Any secrets or sensitive data, such as usernames, passwords, tokens and API keys, should be handled with extreme care. The following example is removing the password and token from the report data with the string replacement in `visitor` function.
@@ -639,6 +627,7 @@ Attach a code coverage report with API `attachCoverageReport(data, testInfo, opt
     - Istanbul only:
     - `watermarks` (Object) Istanbul watermarks, see [here](https://github.com/istanbuljs/istanbuljs/tree/master/packages/istanbul-lib-report)
     - `lcov` (Boolean) Whether to create `lcov.info`
+    - `sourcePath` (Function) source path handler, return a new source path
     - V8 only:
     - `toIstanbul` (Boolean) Whether to convert to Istanbul report
     - `watermarks` (Array) Defaults to `[50, 80]` 
@@ -654,30 +643,27 @@ Attach a code coverage report with API `attachCoverageReport(data, testInfo, opt
 ```js
 import { test, expect } from '@playwright/test';
 import { attachCoverageReport } from 'monocart-reporter';
-test.describe.configure({
-    mode: 'serial'
-});
-let page;
-test.describe('take Istanbul coverage', () => {
-    test('first, open page', async ({ browser }) => {
-        page = await browser.newPage();
-        await page.goto(pageUrl);
-    });
 
-    test('next, run test cases', async () => {
-        await new Promise((resolve) => {
-            setTimeout(resolve, 500);
-        });
+test('Take Istanbul coverage report', async ({ page }) => {
+
+    await page.goto('http://localhost:8090/coverage/istanbul.html');
+
+    // delay for mock code execution
+    await new Promise((resolve) => {
+        setTimeout(resolve, 500);
     });
 
-    test('finally, take coverage', async () => {
-        // take Istanbul coverage
-        const coverageData = await page.evaluate(() => window.__coverage__);
-        expect(coverageData, 'expect found Istanbul data: __coverage__').toBeTruthy();
-        // coverage report
-        const report = await attachCoverageReport(coverageData, test.info());
-        console.log(report.summary);
+    // take Istanbul coverage
+    const coverageData = await page.evaluate(() => window.__coverage__);
+    await page.close();
+    expect(coverageData, 'expect found Istanbul data: __coverage__').toBeTruthy();
+
+    // coverage report
+    const report = await attachCoverageReport(coverageData, test.info(), {
+        lcov: true
     });
+    console.log(report.summary);
+
 });
 ```
 
@@ -687,43 +673,38 @@ test.describe('take Istanbul coverage', () => {
 ```js
 import { test, expect } from '@playwright/test';
 import { attachCoverageReport } from 'monocart-reporter';
-test.describe.configure({
-    mode: 'serial'
-});
-let page;
-test.describe('take V8 coverage', () => {
-    test('first, open page', async ({ browser }) => {
-        page = await browser.newPage();
-        await Promise.all([
-            page.coverage.startJSCoverage(),
-            page.coverage.startCSSCoverage()
-        ]);
-        await page.goto(pageUrl);
-    });
 
-    test('next, run test cases', async () => {
-        await new Promise((resolve) => {
-            setTimeout(resolve, 500);
-        });
+test('Take V8 and Istanbul coverage report', async ({ page }) => {
+
+    await Promise.all([
+        page.coverage.startJSCoverage({
+            resetOnNavigation: false
+        }),
+        page.coverage.startCSSCoverage({
+            resetOnNavigation: false
+        })
+    ]);
+
+    await page.goto('http://localhost:8090/coverage/v8.html');
+
+    // delay for mock code execution
+    await new Promise((resolve) => {
+        setTimeout(resolve, 500);
     });
 
-    test('finally, take coverage', async () => {
-        const [jsCoverage, cssCoverage] = await Promise.all([
-            page.coverage.stopJSCoverage(),
-            page.coverage.stopCSSCoverage()
-        ]);
-        const coverageList = [... jsCoverage, ... cssCoverage];
-        // filter file list
-        // coverageList = coverageList.filter((item) => {
-        //     if (item.url.endsWith('.js') || item.url.endsWith('.css')) {
-        //         return true;
-        //     }
-        // });
-        expect(coverageList.length).toBeGreaterThan(0);
-        // coverage report
-        const report = await attachCoverageReport(coverageList, test.info());
-        console.log(report.summary);
+    const [jsCoverage, cssCoverage] = await Promise.all([
+        page.coverage.stopJSCoverage(),
+        page.coverage.stopCSSCoverage()
+    ]);
+    await page.close();
+
+    const coverageList = [... jsCoverage, ... cssCoverage];
+
+    const v8 = await attachCoverageReport(coverageList, test.info(), {
+        excludeDistFile: false
     });
+    console.log(v8.summary);
+
 });
 ```
 

package/lib/common.js

@@ -39,7 +39,8 @@ const stepHandler = (item, summary) => {
 const tagHandler = (item, tags, tagOptions) => {
     const matches = item.title.matchAll(Util.tagPattern);
     for (const match of matches) {
-        const tag = match[1];
+        // all, before, key, after
+        const tag = match[2];
         let tagItem = tags[tag];
         if (!tagItem) {
             tagItem = {};

package/lib/default/columns.js

@@ -9,7 +9,7 @@ module.exports = [{
     id: 'title',
     name: 'Title',
     searchable: true,
-    width: 300,
+    width: 350,
     maxWidth: 1230
 }, {
     id: 'type',

package/lib/generate-data.js

@@ -4,8 +4,8 @@ const Util = require('./utils/util.js');
 const { getTickInfo } = require('./utils/system.js');
 const Visitor = require('./visitor.js');
 const { calculateSummary } = require('./common.js');
-const { generateCoverageReport } = require('./plugins/coverage/coverage.js');
-const { generateNetworkReport } = require('./plugins/network/network.js');
+const { generateGlobalCoverageReport } = require('./plugins/coverage/coverage.js');
+const { generateGlobalNetworkReport } = require('./plugins/network/network.js');
 
 const getReportName = (options, config, metadata) => {
     const reportName = options.name || config.name || metadata.name;
@@ -20,11 +20,11 @@ const artifactsHandler = async (visitor, options) => {
     // global artifacts
     const { coverage, network } = visitor.artifactDataMap;
     if (coverage) {
-        const report = await generateCoverageReport(coverage, options);
+        const report = await generateGlobalCoverageReport(coverage, options);
         artifacts.push(report);
     }
     if (network) {
-        const report = await generateNetworkReport(coverage, options);
+        const report = await generateGlobalNetworkReport(coverage, options);
         artifacts.push(report);
     }
     return artifacts;
@@ -81,16 +81,6 @@ const generateData = async (results) => {
     // global metadata
     const metadata = config.metadata || {};
 
-    // merge project row metadata
-    config.projects.forEach((p, i) => {
-        // merge project metadata to project row
-        const pm = p.metadata;
-        const row = data.rows[i];
-        if (pm && row) {
-            Object.assign(row, pm);
-        }
-    });
-
     const reportName = getReportName(options, config, metadata);
     options.name = reportName;
 

package/lib/platform/share.js

@@ -1,7 +1,7 @@
 const Util = {
 
     // definition
-    tagPattern: /@([^@\s]+)/g,
+    tagPattern: /(\s*)@([^@\s]+)(\s*)/g,
     lineBreakPattern: /\r\n|[\r\n\u2028\u2029]/gu,
 
     attachments: {

package/lib/plugins/coverage/coverage-utils.js

@@ -1,6 +1,4 @@
 const Util = require('../../utils/util.js');
-const Concurrency = require('../../platform/concurrency.js');
-const { convertSourceMap, axios } = require('../../runtime/monocart-coverage.js');
 
 const sortRanges = (ranges) => {
     ranges.sort((a, b) => {
@@ -67,6 +65,8 @@ const getSourcePath = (url, index = '', type = '') => {
     return filterPath(relPath);
 };
 
+// ========================================================================================================
+
 const mergeSourceRoot = (sourceRoot, sourceName) => {
     if (sourceName.startsWith(sourceRoot)) {
         return sourceName;
@@ -74,89 +74,51 @@ const mergeSourceRoot = (sourceRoot, sourceName) => {
     return sourceRoot + sourceName;
 };
 
-// ================================================================================================
-
-const request = async (options) => {
-    if (typeof options === 'string') {
-        options = {
-            url: options
-        };
-    }
-    let err;
-    const res = await axios(options).catch((e) => {
-        err = e;
+const initSourceMapRootAndUrl = (sourceMap, fileUrls, fileSources) => {
+    // reset sourceRoot
+    const sourceRoot = sourceMap.sourceRoot || '';
+    sourceMap.sourceRoot = '';
+
+    sourceMap.sources = sourceMap.sources.map((sourceName, i) => {
+        const sourceUrl = mergeSourceRoot(sourceRoot, sourceName);
+        const sourcePath = getSourcePath(sourceUrl, i + 1);
+        fileUrls[sourcePath] = sourceUrl;
+        fileSources[sourcePath] = sourceMap.sourcesContent[i];
+        return sourcePath;
     });
-    return [err, res];
-};
-
-const getSourceMapUrl = (content, url) => {
 
-    const m = content.match(convertSourceMap.mapFileCommentRegex);
-    if (!m) {
-        return;
-    }
+};
 
-    const comment = m.pop();
-    const r = convertSourceMap.mapFileCommentRegex.exec(comment);
-    // for some odd reason //# .. captures in 1 and /* .. */ in 2
-    const filename = r[1] || r[2];
+// ================================================================================================
 
-    let mapUrl;
+const convertFunctionsToRanges = (functions) => {
 
-    try {
-        mapUrl = new URL(filename, url);
-    } catch (e) {
-        // console.log(e)
-    }
-    if (mapUrl) {
-        return mapUrl.toString();
+    if (!Util.isList(functions)) {
+        return [];
     }
-};
 
-const resolveSourceMap = (data) => {
-    if (data) {
-        const { sources, sourcesContent } = data;
-        if (!sources || !sourcesContent) {
-            return;
+    const ranges = [];
+    for (const fun of functions) {
+        if (fun.ranges) {
+            for (const range of fun.ranges) {
+                // rename startOffset/endOffset to start/end, keep count
+                ranges.push({
+                    start: range.startOffset,
+                    end: range.endOffset,
+                    count: range.count
+                });
+            }
         }
-        return data;
     }
-};
 
-const collectSourceMaps = async (v8list) => {
-    const concurrency = new Concurrency();
-    for (const item of v8list) {
-        // useless for css
-        if (item.type === 'css') {
-            continue;
-        }
+    sortRanges(ranges);
 
-        const source = item.source;
-        const converter = convertSourceMap.fromSource(source);
-        if (converter) {
-            item.sourceMap = resolveSourceMap(converter.sourcemap);
-            continue;
-        }
-        const sourceMapUrl = getSourceMapUrl(source, item.url);
-        if (sourceMapUrl) {
-            item.sourceMapUrl = sourceMapUrl;
-            concurrency.addItem(item);
-        }
-    }
-    await concurrency.start(async (item) => {
-        const [err, res] = await request({
-            url: item.sourceMapUrl
-        });
-        if (!err && res) {
-            item.sourceMap = resolveSourceMap(res.data);
-        }
-    });
+    return ranges;
 };
 
-
 module.exports = {
     sortRanges,
     getSourcePath,
-    mergeSourceRoot,
-    collectSourceMaps
+    initSourceMapRootAndUrl,
+    convertFunctionsToRanges
 };

package/lib/plugins/coverage/coverage.js

@@ -3,13 +3,9 @@ const path = require('path');
 const EC = require('eight-colors');
 
 const Util = require('../../utils/util.js');
-
-const {
-    convertV8ToIstanbul, mergeIstanbulList, saveIstanbulReport
-} = require('./istanbul/istanbul.js');
-
+const { convertV8ToIstanbul, saveIstanbulReport } = require('./istanbul/istanbul.js');
 const {
-    initV8List, mergeV8List, saveV8Report
+    initV8ListAndSourcemap, unpackV8List, mergeV8Coverage, saveV8Report
 } = require('./v8/v8.js');
 
 // ========================================================================================================
@@ -48,6 +44,9 @@ const defaultIstanbulOptions = {
     unpackSourceMap: true,
     sourceFilter: null,
 
+    // source path handler
+    sourcePath: null,
+
     // (usually not used) source finder for Istanbul HTML report
     sourceFinder: null,
 
@@ -101,6 +100,10 @@ const generateV8Coverage = async (v8list, testInfo, options) => {
         ... options
     };
 
+    // init v8list and unpack sourcemap
+    const inlineSourceMap = true;
+    v8list = await initV8ListAndSourcemap(v8list, options, inlineSourceMap);
+
     // ================================================================
 
     if (options.toIstanbul) {
@@ -120,7 +123,8 @@ const generateV8Coverage = async (v8list, testInfo, options) => {
 
     // ================================================================
 
-    v8list = await initV8List(v8list, options);
+    // functions to ranges, and unpack source maps
+    await unpackV8List(v8list, options);
 
     const report = await saveV8Report(v8list, options);
 
@@ -145,12 +149,17 @@ const attachCoverageReport = (coverageInput, testInfo, options = {}) => {
         ... options
     };
 
-    const htmlDir = path.resolve(options.outputDir, options.outputName);
-    if (!fs.existsSync(htmlDir)) {
-        fs.mkdirSync(htmlDir, {
-            recursive: true
-        });
+    let htmlDir = path.resolve(options.outputDir, options.outputName);
+    let i = 1;
+    while (fs.existsSync(htmlDir)) {
+        const outputName = `${options.outputName}-${i}`;
+        htmlDir = path.resolve(options.outputDir, outputName);
+        i += 1;
     }
+
+    fs.mkdirSync(htmlDir, {
+        recursive: true
+    });
     options.htmlDir = htmlDir;
 
     if (Array.isArray(coverageInput)) {
@@ -162,26 +171,11 @@ const attachCoverageReport = (coverageInput, testInfo, options = {}) => {
 
 // ========================================================================================================
 
-const generateArtifactData = (v8list, options) => {
-    options = {
-        ... defaultV8Options,
-        ... options
-    };
-    if (options.toIstanbul) {
-        options = {
-            ... defaultIstanbulOptions,
-            ... options
-        };
-        return convertV8ToIstanbul(v8list, options);
-    }
-    return initV8List(v8list, options);
-};
-
 //  add coverage report to global, v8list only
-const addCoverageReport = async (coverageInput, testInfo) => {
+const addCoverageReport = async (v8list, testInfo) => {
 
-    if (!coverageInput) {
-        EC.logRed('[MCR] invalid coverage input');
+    if (!Util.isList(v8list)) {
+        EC.logRed(`[MCR] invalid v8 list for test: ${testInfo.title}`);
         return;
     }
 
@@ -193,25 +187,34 @@ const addCoverageReport = async (coverageInput, testInfo) => {
     const outputDir = path.dirname(outputFile);
 
     const options = {
+        ... defaultV8Options,
         // use reporter dir as output dir, NOT test output dir
         outputDir,
         outputName: 'coverage',
         ... coverageOptions
     };
 
+    const reportDir = path.resolve(options.outputDir, options.outputName);
+
+    // artifactsDir for temp artifact files
+    const artifactsDir = path.resolve(reportDir, '.artifacts');
+    options.artifactsDir = artifactsDir;
+
     const id = Util.shortTestId(testInfo.testId);
-    const filename = `artifact-${id}.json`;
-    const jsonDir = path.resolve(options.outputDir, options.outputName);
-    const jsonPath = path.resolve(jsonDir, filename);
+    const filename = `coverage-${id}.json`;
+    const jsonPath = path.resolve(artifactsDir, filename);
 
-    const data = await generateArtifactData(coverageInput, options);
+    // init v8list and unpack sourcemap
+    const inlineSourceMap = false;
+    v8list = await initV8ListAndSourcemap(v8list, options, inlineSourceMap);
 
-    // console.log('addCoverageReport keys', Object.keys(data.coverageData));
+    // console.log('addCoverageReport', coverageInput.map((it) => it.url));
 
     const report = {
-        id,
-        outputFile: Util.relativePath(jsonPath),
-        data
+        // title for debug
+        title: testInfo.title,
+        // merge with data
+        data: v8list
     };
 
     const artifactContent = JSON.stringify({
@@ -233,34 +236,43 @@ const addCoverageReport = async (coverageInput, testInfo) => {
 
 // ========================================================================================================
 
-const generateGlobalCoverageReport = async (dataList, options) => {
+const getGlobalCoverageData = async (dataList, options) => {
 
     options = {
         ... defaultV8Options,
         ... options
     };
 
+    // merge v8list first
+    const v8list = await mergeV8Coverage(dataList, options);
+    // console.log('after merge', v8list.map((it) => it.url));
+
     if (options.toIstanbul) {
+
         options = {
             ... defaultIstanbulOptions,
             ... options
         };
-        const istanbulList = dataList.map((it) => it.data);
-        const { coverageData, fileSources } = mergeIstanbulList(istanbulList);
-        return saveIstanbulReport(coverageData, fileSources, options);
+
+        const { coverageData, fileSources } = await convertV8ToIstanbul(v8list, options);
+
+        const report = await saveIstanbulReport(coverageData, fileSources, options);
+
+        // console.log(report);
+
+        return report;
     }
 
-    let v8list = [];
-    dataList.forEach((item) => {
-        v8list = v8list.concat(item.data);
-    });
-    // merge list again for multiple v8list, maybe collected multiple times
-    v8list = await mergeV8List(v8list, options);
-    return saveV8Report(v8list, options);
+    // functions to ranges, and unpack source maps
+    await unpackV8List(v8list, options);
+
+    const report = await saveV8Report(v8list, options);
+
+    return report;
 };
 
 // global coverage report, run different process with addCoverageReport
-const generateCoverageReport = async (dataList, reporterOptions) => {
+const generateGlobalCoverageReport = async (dataList, reporterOptions) => {
 
     // reporter outputFile
     const outputFile = await Util.resolveOutputFile(reporterOptions.outputFile);
@@ -274,15 +286,27 @@ const generateCoverageReport = async (dataList, reporterOptions) => {
         ... coverageOptions
     };
 
-    const htmlDir = path.resolve(options.outputDir, options.outputName);
-    if (!fs.existsSync(htmlDir)) {
-        fs.mkdirSync(htmlDir, {
+    const reportDir = path.resolve(options.outputDir, options.outputName);
+    if (!fs.existsSync(reportDir)) {
+        fs.mkdirSync(reportDir, {
             recursive: true
         });
     }
-    options.htmlDir = htmlDir;
+    options.htmlDir = reportDir;
+
+    // artifactsDir for temp artifact files
+    const artifactsDir = path.resolve(reportDir, '.artifacts');
+    options.artifactsDir = artifactsDir;
 
-    const report = await generateGlobalCoverageReport(dataList, options);
+    const report = await getGlobalCoverageData(dataList, options);
+    // console.log(report);
+
+    // =============================================================
+    // remove artifacts dir after report generated
+    if (!options.debug) {
+        Util.rmSync(artifactsDir);
+    }
+    // =============================================================
 
     return {
         global: true,
@@ -295,6 +319,6 @@ const generateCoverageReport = async (dataList, reporterOptions) => {
 
 module.exports = {
     addCoverageReport,
-    generateCoverageReport,
+    generateGlobalCoverageReport,
     attachCoverageReport
 };