monocart-reporter 2.9.3 → 2.9.5

package/README.md

@@ -1060,13 +1060,14 @@ see example [merge.js](https://github.com/cenfun/monocart-reporter-examples/blob
 
 ### Using `merge` CLI
 ```sh
-npx monocart merge <glob-patterns>
+# NOTE: The asterisk(*) is a special character which is interpreted by some operating systems (Mac and Linux), please put it in quotes
+npx monocart merge '<glob-patterns>'
 
 # -o --outputFile
-npx monocart merge path-to/shard*/index.json -o merged-reports/index.html
+npx monocart merge 'path-to/shard*/index.json' -o merged-reports/index.html
 
 # -c --config
-npx monocart merge path-to/shard*/index.json -c mr.config.js
+npx monocart merge 'path-to/shard*/my-report.zip' -c mr.config.js
 ```
 The default config files (In order of priority)
 - mr.config.js

package/lib/generate-report.js

@@ -18,64 +18,85 @@ const generateJson = (outputDir, filename, reportData, options) => {
     reportData.jsonPath = Util.relativePath(jsonPath);
 };
 
-const forEachFile = (dir, callback) => {
-    if (!fs.existsSync(dir)) {
-        return;
+const initZipOptions = (outputDir, filename, zipOptions) => {
+    let clean = false;
+    let outputFile;
+    if (typeof zipOptions === 'string') {
+        outputFile = zipOptions;
+    } else if (typeof zipOptions === 'object') {
+        if (zipOptions.outputFile) {
+            outputFile = zipOptions.outputFile;
+        }
+        if (zipOptions.clean) {
+            clean = true;
+        }
     }
-    const dirs = [];
-    fs.readdirSync(dir, {
-        withFileTypes: true
-    }).forEach((it) => {
 
-        if (it.isFile()) {
-            callback(it.name, dir);
-            return;
+    if (outputFile) {
+        if (!outputFile.endsWith('.zip')) {
+            outputFile += '.zip';
         }
-
-        if (it.isDirectory()) {
-            dirs.push(path.resolve(dir, it.name));
+        const zipDir = path.dirname(outputFile);
+        if (!fs.existsSync(zipDir)) {
+            fs.mkdirSync(zipDir, {
+                recursive: true
+            });
         }
-    });
 
-    for (const subDir of dirs) {
-        forEachFile(subDir, callback);
+    } else {
+        outputFile = path.resolve(outputDir, `${filename}.zip`);
     }
 
+
+    return {
+        outputFile,
+        clean
+    };
 };
 
 const generateZip = (outputDir, filename, reportData, options) => {
 
-    if (!options.zip) {
+    const zipOptions = options.zip;
+    if (!zipOptions) {
         return;
     }
 
-    let zipPath = path.resolve(outputDir, `${filename}.zip`);
-    if (typeof options.zip === 'string') {
-        zipPath = options.zip;
-        if (!zipPath.endsWith('.zip')) {
-            zipPath += '.zip';
-        }
-        const zipDir = path.dirname(zipPath);
-        if (!fs.existsSync(zipDir)) {
-            fs.mkdirSync(zipDir, {
-                recursive: true
-            });
-        }
-    }
+    const { outputFile, clean } = initZipOptions(outputDir, filename, zipOptions);
 
     const reportFiles = [];
     return new Promise((resolve) => {
         const zipFile = new ZipFile();
-        zipFile.outputStream.pipe(fs.createWriteStream(zipPath)).on('close', function() {
+        zipFile.outputStream.pipe(fs.createWriteStream(outputFile)).on('close', function() {
 
-            // remove files after zip
             reportData.reportFiles = reportFiles;
-            reportData.zipPath = Util.relativePath(zipPath);
+
+            // whether to clean the files after zipped
+            if (clean) {
+                // console.log('clean', reportFiles);
+                const dirSet = new Set();
+                reportFiles.forEach((f) => {
+                    const fp = path.resolve(outputDir, f);
+                    dirSet.add(path.dirname(fp));
+                    Util.rmSync(fp);
+                });
+
+                // clean empty dirs
+                const dirList = Array.from(dirSet).reverse();
+                dirList.forEach((dir) => {
+                    const files = fs.readdirSync(dir);
+                    if (files.length === 0) {
+                        Util.rmSync(dir);
+                    }
+                });
+
+            }
+
+            reportData.zipPath = Util.relativePath(outputFile);
 
             resolve();
         });
 
-        forEachFile(outputDir, (name, dir) => {
+        Util.forEachFile(outputDir, (name, dir) => {
             const absPath = path.resolve(dir, name);
             const relPath = Util.relativePath(absPath, outputDir);
             reportFiles.push(relPath);

package/lib/index.d.ts

@@ -61,7 +61,12 @@ export type MonocartReporterOptions = {
      * {boolean} using default path
      * {string} zip file path
      */
-    zip?: boolean | string;
+    zip?: boolean | string | {
+        /** the zip file path */
+        outputFile?: string;
+        /** whether to clean the files after zipped */
+        clean?: boolean;
+    };
 
     /**
      *  whether to copy attachments to the reporter output dir, defaults to true

package/lib/merge-data.js

@@ -37,7 +37,31 @@ const unzipDataFile = async (item, num, options) => {
     await zip.close();
 
     const filename = path.basename(item, '.zip');
-    return path.resolve(unzipDir, `${filename}.json`);
+    let jsonPath = path.resolve(unzipDir, `${filename}.json`);
+    if (fs.existsSync(jsonPath)) {
+        return jsonPath;
+    }
+
+    // filename for both html and json
+    const htmlMap = {};
+    const jsonMap = {};
+    Util.forEachFile(unzipDir, (name, dir) => {
+        if (name.endsWith('.html')) {
+            htmlMap[path.basename(name, '.html')] = true;
+        } else if (name.endsWith('.json')) {
+            jsonMap[path.basename(name, '.json')] = true;
+        }
+    }, true);
+
+    const keys = Object.keys(htmlMap);
+    for (const fn of keys) {
+        if (jsonMap[fn]) {
+            jsonPath = path.resolve(unzipDir, `${fn}.json`);
+            break;
+        }
+    }
+
+    return jsonPath;
 };
 
 const getReportData = async (item, num, options) => {

package/lib/utils/util.js

@@ -277,6 +277,50 @@ const Util = {
         }
     },
 
+    // eslint-disable-next-line complexity
+    forEachFile: (dir, callback, shallow) => {
+        if (!fs.existsSync(dir)) {
+            return;
+        }
+
+        const isBreak = (res) => {
+            return res === 'break' || res === false;
+        };
+
+        const dirs = [];
+        const list = fs.readdirSync(dir, {
+            withFileTypes: true
+        });
+
+        for (const item of list) {
+
+            if (item.isFile()) {
+                const res = callback(item.name, dir);
+                if (isBreak(res)) {
+                    return res;
+                }
+                continue;
+            }
+
+            if (item.isDirectory()) {
+                dirs.push(path.resolve(dir, item.name));
+            }
+
+        }
+
+        if (shallow) {
+            return;
+        }
+
+        for (const subDir of dirs) {
+            const res = Util.forEachFile(subDir, callback, shallow);
+            if (isBreak(res)) {
+                return res;
+            }
+        }
+
+    },
+
     getTemplate: function(templatePath) {
         if (!Util.templateCache) {
             Util.templateCache = {};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "monocart-reporter",
-    "version": "2.9.3",
+    "version": "2.9.5",
     "description": "A playwright test reporter. Shows suites/cases/steps with tree style, markdown annotations, custom columns/formatters/data collection visitors, console logs, style tags, send email.",
     "main": "lib/index.js",
     "bin": {
@@ -53,7 +53,7 @@
     },
     "devDependencies": {
         "@babel/code-frame": "^7.25.7",
-        "@playwright/test": "^1.47.2",
+        "@playwright/test": "^1.48.0",
         "ansi-to-html": "^0.7.2",
         "async-tick": "^1.0.0",
         "autolinker": "^4.0.0",