monocart-reporter 2.6.5 → 2.7.1

package/README.md

@@ -1087,24 +1087,20 @@ npx playwright test --shard=2/3
 npx playwright test --shard=3/3
 ```
 There are 3 reports will be generated. Using `merge(reportDataList, options)` API to merge all reports into one.
-> Note: One more suite level "shard" will be added, its title will be the machine hostname, and the summary will be restated. You may need to transfer the attachments by yourself and update the path of the attachments with `attachmentPath` API.
+> Note: One more suite level "shard" will be added, its title will be the machine hostname, and the summary will be restated. All attachments will be copied to the merged output directory.
 ```js
 import { merge } from 'monocart-reporter';
 
+// json file path
 const reportDataList = [
-    // json file path
     'path-to/shard1/index.json',
     'path-to/shard2/index.json',
-    // or JSON data
-    JSON.parse(fs.readFileSync(path.resolve('path-to/shard3/index.json')))
+    'path-to/shard3/index.json'
 ];
 
 await merge(reportDataList, {
     name: 'My Merged Report',
     outputFile: 'merged-report/index.html',
-    attachmentPath: (currentPath, extras) => {
-       // return `https://cenfun.github.io/monocart-reporter/${currentPath}`;
-    },
     onEnd: async (reportData, helper) => {
         // send email or third party integration
     }
@@ -1112,6 +1108,17 @@ await merge(reportDataList, {
 ```
 see example [merge.js](https://github.com/cenfun/monocart-reporter-examples/blob/main/scripts/merge.js)
 
+> Note: The coverage reports will be merged automatically if we specify the `raw` report in coverage options:
+```js
+// global coverage options
+coverage: {
+    reports: [
+        // for merging coverage reports
+        'raw'
+    ]
+}
+```
+
 ## onEnd Hook
 The `onEnd` function will be executed after report generated. Arguments:
 - `reportData` all report data, properties:

package/lib/cli.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
 const fs = require('fs');
 const path = require('path');

package/lib/generate-data.js

@@ -33,6 +33,37 @@ const getReportDate = (timestampStart, timezoneOffset = 0) => {
     return timestampStart + offset * 60 * 1000;
 };
 
+const generateMermaid = (options) => {
+    const mermaidOptions = options.mermaid;
+    if (mermaidOptions) {
+        const scriptSrc = mermaidOptions.scriptSrc;
+        if (!scriptSrc) {
+            // try to copy and load from local
+            let mp;
+            try {
+                mp = require.resolve('mermaid');
+            } catch (e) {
+                // ignore error
+            }
+            // console.log(mp);
+            if (mp) {
+                const filename = 'mermaid.min.js';
+                const filePath = path.resolve(path.dirname(mp), filename);
+                if (fs.existsSync(filePath)) {
+                    const assetPath = path.resolve(options.outputDir, 'assets', filename);
+                    fs.cpSync(filePath, assetPath, {
+                        recursive: true,
+                        force: true
+                    });
+                    mermaidOptions.scriptSrc = `assets/${filename}`;
+                }
+            }
+        }
+    }
+    // console.log(mermaidOptions);
+    return mermaidOptions;
+};
+
 const generateData = async (results) => {
 
     Util.logInfo('generating report data ...');
@@ -78,7 +109,7 @@ const generateData = async (results) => {
     data.suiteTypes = ['project', 'file', 'describe', 'shard'];
     data.caseTypes = ['passed', 'flaky', 'skipped', 'failed'];
     data.traceViewerUrl = options.traceViewerUrl;
-    data.mermaid = options.mermaid;
+    data.mermaid = generateMermaid(options);
     data.groupOptions = options.groupOptions;
 
     calculateSummary(data, options);

package/lib/generate-report.js

@@ -197,7 +197,9 @@ const generateReport = async (reportData, options) => {
             const g = report.global ? `${EC.magenta('(global)')}` : '';
             Util.logInfo(`${report.type}: ${EC.cyan(report.path)} ${report.name} ${g}`);
             // convert path to relative reporter
-            report.path = Util.relativePath(report.path, outputDir);
+            if (report.path) {
+                report.path = Util.relativePath(report.path, outputDir);
+            }
         });
 
         reportData.summary.artifacts = {

package/lib/merge-data.js

@@ -4,10 +4,11 @@ const Util = require('./utils/util.js');
 const generateReport = require('./generate-report.js');
 const getDefaultOptions = require('./default/options.js');
 const { calculateSummary, getTrends } = require('./common.js');
+const { mergeGlobalCoverageReport } = require('./plugins/coverage/coverage.js');
 
 const checkReportData = (item) => {
     if (item && typeof item === 'object') {
-        if (Util.isList(item.rows) && Util.isList(item.columns) && item.summary) {
+        if (item.rows && item.columns && item.summary) {
             return true;
         }
     }
@@ -30,6 +31,10 @@ const initDataList = (reportDataList) => {
                 Util.logError(`failed to read report data file: ${item}`);
                 continue;
             }
+
+            // for finding attachments
+            data.jsonDir = path.dirname(item);
+
             list.push(data);
             Util.logInfo(`report data loaded: ${item}`);
             continue;
@@ -39,6 +44,9 @@ const initDataList = (reportDataList) => {
             Util.logError(`unmatched report data format: ${item}`);
             return;
         }
+
+        item.jsonDir = item.outputDir;
+
         list.push(item);
     }
 
@@ -49,26 +57,99 @@ const initDataList = (reportDataList) => {
     return list;
 };
 
-const attachmentsHandler = (data, attachmentPathHandler) => {
-    if (!attachmentPathHandler) {
-        return;
+const copyTarget = (targetPath, fromDir, toDir) => {
+    const oldPath = path.resolve(fromDir, targetPath);
+    if (fs.existsSync(oldPath)) {
+        const newPath = path.resolve(toDir, targetPath);
+        if (oldPath !== newPath) {
+            fs.cpSync(oldPath, newPath, {
+                force: true,
+                recursive: true
+            });
+            return true;
+        }
     }
-    const extras = Util.getAttachmentPathExtras(data);
-    Util.forEach(data.rows, (item) => {
-        if (item.type !== 'case' || !item.attachments) {
+};
+
+const attachmentsHandler = (item, outputDir, attachmentPathHandler) => {
+
+    const jsonDir = item.jsonDir;
+
+    const extras = Util.getAttachmentPathExtras(item);
+    Util.forEach(item.rows, (row) => {
+        if (row.type !== 'case' || !row.attachments) {
             return;
         }
-        item.attachments.forEach((attachment) => {
+        row.attachments.forEach((attachment) => {
             if (!attachment.path) {
                 return;
             }
-            const newPath = attachmentPathHandler(attachment.path, extras);
-            if (!newPath) {
+
+            // copy attachment
+            const done = copyTarget(attachment.path, jsonDir, outputDir);
+            if (!done) {
+                Util.logError(`failed to copy: ${attachment.path}`);
+            }
+
+            if (attachmentPathHandler) {
+                const newPath = attachmentPathHandler(attachment.path, extras);
+                if (newPath) {
+                    attachment.path = newPath;
+                }
+            }
+        });
+    });
+};
+
+const mergeArtifacts = async (artifactsList, options) => {
+
+    const outputDir = options.outputDir;
+
+    const artifacts = [];
+    const coverageRawList = [];
+    artifactsList.forEach((item) => {
+        const jsonDir = item.jsonDir;
+        let hasAssets = false;
+        item.artifacts.forEach((art) => {
+
+            // merge global coverage
+            if (art.global && art.type === 'coverage') {
+
+                const rawDir = path.resolve(jsonDir, art.rawDir);
+                if (fs.existsSync(rawDir)) {
+                    coverageRawList.push(rawDir);
+                }
                 return;
+
             }
-            attachment.path = newPath;
+
+            const targetDirName = path.dirname(art.path);
+            // copy all files in art dir, like network, audit
+            copyTarget(targetDirName, jsonDir, outputDir);
+            hasAssets = true;
+
+            // update path relative to cwd/root
+            art.path = Util.relativePath(path.resolve(outputDir, art.path));
+
+            artifacts.push(art);
+
         });
+
+        // copy assets dir
+        if (hasAssets) {
+            copyTarget('assets', jsonDir, outputDir);
+        }
+
     });
+
+    if (coverageRawList.length) {
+        const coverage = await mergeGlobalCoverageReport(coverageRawList, options);
+        if (coverage) {
+            artifacts.push(coverage);
+        }
+    }
+
+    return artifacts;
 };
 
 const mergeDataList = async (dataList, options) => {
@@ -78,11 +159,18 @@ const mergeDataList = async (dataList, options) => {
     const outputFile = await Util.resolveOutputFile(options.outputFile);
     // init outputDir
     const outputDir = path.dirname(outputFile);
-    if (!fs.existsSync(outputDir)) {
-        fs.mkdirSync(outputDir, {
-            recursive: true
+    // clean
+    if (fs.existsSync(outputDir)) {
+        fs.rmSync(outputDir, {
+            recursive: true,
+            force: true,
+            maxRetries: 10
         });
     }
+
+    fs.mkdirSync(outputDir, {
+        recursive: true
+    });
     // for attachment path handler
     options.outputDir = outputDir;
 
@@ -93,10 +181,11 @@ const mergeDataList = async (dataList, options) => {
     const metadata = {};
     const system = [];
     const rows = [];
+    const artifactsList = [];
 
-    dataList.forEach((item, i) => {
+    for (const item of dataList) {
 
-        attachmentsHandler(item, attachmentPathHandler);
+        attachmentsHandler(item, outputDir, attachmentPathHandler);
 
         dates.push(item.date);
         endDates.push(item.date + item.duration);
@@ -117,7 +206,16 @@ const mergeDataList = async (dataList, options) => {
             subs: item.rows
         });
 
-    });
+        if (item.artifacts) {
+            artifactsList.push({
+                jsonDir: item.jsonDir,
+                artifacts: item.artifacts
+            });
+        }
+
+    }
+
+    const artifacts = await mergeArtifacts(artifactsList, options);
 
     // base on first one
     const mergedData = {
@@ -158,7 +256,9 @@ const mergeDataList = async (dataList, options) => {
         system,
         trends,
 
-        rows
+        rows,
+
+        artifacts
     });
 
     // tag style can be rewrite with new options tags
@@ -185,6 +285,7 @@ module.exports = async (reportDataList, userOptions = {}) => {
     };
 
     const reportData = await mergeDataList(dataList, options);
+    // console.log(reportData.artifacts);
 
     return generateReport(reportData, options);