monocart-reporter 2.8.4 → 2.9.0

package/README.md

@@ -59,6 +59,7 @@
 ![](/docs/report.gif)
 
 ![](/docs/cli.png)
+(For Github actions, we can enforce color with env: `FORCE_COLOR: true`)
 
 ## Install
 ```sh
@@ -1064,6 +1065,12 @@ The default config files (In order of priority)
 - mr.config.json
 - mr.config.ts
 
+Preload for TypeScript config file:
+- It requires node 18.19.0+
+- Installing tsx: `npm i -D tsx`
+- Using the `--import tsx` flag
+- see [comment](https://github.com/cenfun/monocart-reporter/issues/145#issuecomment-2365460013)
+
 
 ## onEnd Hook
 The `onEnd` function will be executed after report generated. Arguments:

package/lib/default/options.js

@@ -8,6 +8,9 @@ module.exports = () => ({
     // the output html file path (relative process.cwd)
     outputFile: './monocart-report/index.html',
 
+    json: true,
+    zip: false,
+
     // whether to copy attachments to the reporter output dir, defaults to true
     // it is useful when there are multiple html reports being output.
     copyAttachments: true,
@@ -22,6 +25,9 @@ module.exports = () => ({
     // timezone offset in minutes, GMT+0800 = -480
     timezoneOffset: 0,
 
+    // normal or exclude-idle
+    durationStrategy: null,
+
     // global coverage settings for addCoverageReport API
     coverage: null,
     // coverage: {

package/lib/generate-report.js

@@ -1,26 +1,92 @@
+const fs = require('fs');
 const path = require('path');
 const EC = require('eight-colors');
 const nodemailer = require('nodemailer');
 const Util = require('./utils/util.js');
 const emailPlugin = require('./plugins/email.js');
 const Assets = require('./assets.js');
-
+const { ZipFile } = require('./packages/monocart-reporter-vendor.js');
 // ===========================================================================
 
-const generateJson = (outputDir, htmlFile, reportData) => {
-    const filename = path.basename(htmlFile, '.html');
-    let jsonPath = path.resolve(outputDir, `${filename}.json`);
+const generateJson = (outputDir, filename, reportData, options) => {
+    if (!options.json) {
+        return;
+    }
+
+    const jsonPath = path.resolve(outputDir, `${filename}.json`);
     Util.writeJSONSync(jsonPath, reportData);
-    jsonPath = Util.relativePath(jsonPath);
-    return jsonPath;
+    reportData.jsonPath = Util.relativePath(jsonPath);
+};
+
+const forEachFile = (dir, callback) => {
+    if (!fs.existsSync(dir)) {
+        return;
+    }
+    const dirs = [];
+    fs.readdirSync(dir, {
+        withFileTypes: true
+    }).forEach((it) => {
+
+        if (it.isFile()) {
+            callback(it.name, dir);
+            return;
+        }
+
+        if (it.isDirectory()) {
+            dirs.push(path.resolve(dir, it.name));
+        }
+    });
+
+    for (const subDir of dirs) {
+        forEachFile(subDir, callback);
+    }
+
+};
+
+const generateZip = (outputDir, filename, reportData, options) => {
+
+    if (!options.zip) {
+        return;
+    }
+
+    const zipPath = path.resolve(outputDir, `${filename}.zip`);
+    const reportFiles = [];
+    return new Promise((resolve) => {
+        const zipFile = new ZipFile();
+        zipFile.outputStream.pipe(fs.createWriteStream(zipPath)).on('close', function() {
+
+            // remove files after zip
+            reportData.reportFiles = reportFiles;
+            reportData.zipPath = Util.relativePath(zipPath);
+
+            resolve();
+        });
+
+        forEachFile(outputDir, (name, dir) => {
+            const absPath = path.resolve(dir, name);
+            const relPath = Util.relativePath(absPath, outputDir);
+            reportFiles.push(relPath);
+            // console.log(relPath);
+            zipFile.addFile(absPath, relPath);
+        });
+
+        zipFile.end();
+    });
 };
 
-const generateHtml = async (outputDir, htmlFile, reportData, inline) => {
+const generateHtml = async (outputDir, filename, reportData, options) => {
+
+    // generate html
+    let inline = true;
+    if (typeof options.inline === 'boolean') {
+        inline = options.inline;
+    }
 
     // deps
     const jsFiles = ['monocart-reporter-app'];
+    const htmlFile = `${filename}.html`;
 
-    const options = {
+    const htmlPath = await Assets.saveHtmlReport({
         inline,
         reportData,
         jsFiles,
@@ -29,11 +95,10 @@ const generateHtml = async (outputDir, htmlFile, reportData, inline) => {
         htmlFile,
 
         reportDataFile: 'report-data.js'
-    };
+    });
 
-    const htmlPath = await Assets.saveHtmlReport(options);
+    reportData.htmlPath = htmlPath;
 
-    return htmlPath;
 };
 
 const showTestResults = (reportData) => {
@@ -221,30 +286,38 @@ const generateReport = async (reportData, options, rawData) => {
     await onDataHandler(reportData, options, rawData);
 
     // console.log(reportData);
-    const htmlFile = path.basename(outputFile);
-
-    // generate json
-    const jsonPath = await generateJson(outputDir, htmlFile, reportData);
-
-    // generate html
-    let inline = true;
-    if (typeof options.inline === 'boolean') {
-        inline = options.inline;
-    }
-    const htmlPath = await generateHtml(outputDir, htmlFile, reportData, inline);
+    const filename = path.basename(outputFile, '.html');
 
-    // for onEnd after saved
-    Object.assign(reportData, {
-        htmlPath,
-        jsonPath
-    });
+    await generateHtml(outputDir, filename, reportData, options);
+    await generateJson(outputDir, filename, reportData, options);
+    await generateZip(outputDir, filename, reportData, options);
 
     await onEndHandler(reportData, options);
 
     // after onEnd for summary changes
     showTestResults(reportData);
 
-    Util.logInfo(`html report: ${EC.cyan(htmlPath)} (json: ${jsonPath})`);
+    // clean .cache for merge
+    if (options.cacheDir) {
+        Util.rmSync(options.cacheDir);
+    }
+
+    const {
+        htmlPath, jsonPath, zipPath
+    } = reportData;
+
+    const assets = [];
+    if (jsonPath) {
+        assets.push(`json: ${EC.cyan(jsonPath)}`);
+    }
+    if (zipPath) {
+        assets.push(`zip: ${EC.cyan(zipPath)}`);
+    }
+
+    if (assets.length) {
+        Util.logInfo(assets.join('  '));
+    }
+
     Util.logInfo(`view report: ${EC.cyan(`npx monocart show-report ${htmlPath}`)}`);
 
 };

package/lib/index.d.ts

@@ -54,6 +54,11 @@ export type MonocartReporterOptions = {
     /** the output file path (relative process.cwd) */
     outputFile?: string;
 
+    /** output json file for data only */
+    json?: boolean;
+    /** output zip file for all report files */
+    zip?: boolean;
+
     /**
      *  whether to copy attachments to the reporter output dir, defaults to true
      *  it is useful when there are multiple html reports being output
@@ -73,6 +78,9 @@ export type MonocartReporterOptions = {
     /** timezone offset in minutes, For example: GMT+0800 = -480 */
     timezoneOffset?: number;
 
+    /** normal or exclude-idle */
+    durationStrategy?: 'normal' | 'exclude-idle',
+
     /** global coverage options: https://github.com/cenfun/monocart-reporter?#code-coverage-report 
      * ```js
      * coverage: {

package/lib/index.js

@@ -55,6 +55,7 @@ class MonocartReporter {
         this.tickTime = this.options.tickTime || 1000;
         this.tickStart();
 
+        this.trends = [];
         // read trends from json before clean dir
         getTrends(this.options.trend).then((trends) => {
             // console.log('=========================== ', 'trends', trends.length);
@@ -65,12 +66,12 @@ class MonocartReporter {
 
     }
 
-    async init() {
+    init() {
 
         this.options.cwd = Util.formatPath(process.cwd());
 
         // init outputDir
-        const outputFile = await Util.resolveOutputFile(this.options.outputFile);
+        const outputFile = Util.resolveOutputFile(this.options.outputFile);
         this.options.outputFile = outputFile;
 
         const outputDir = path.dirname(outputFile);

package/lib/merge-data.js

@@ -5,6 +5,7 @@ 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 { StreamZip } = require('./packages/monocart-reporter-vendor.js');
 
 const checkReportData = (item) => {
     if (item && typeof item === 'object') {
@@ -14,7 +15,71 @@ const checkReportData = (item) => {
     }
 };
 
-const initDataList = (reportDataList) => {
+const unzipDataFile = async (item, num, options) => {
+
+    if (!options.cacheDir) {
+        options.cacheDir = path.resolve(options.outputDir, '.cache');
+    }
+
+    const unzipDir = path.resolve(options.cacheDir, `extracted-${num}`);
+
+    fs.mkdirSync(unzipDir, {
+        recursive: true
+    });
+
+    const zip = new StreamZip({
+        file: item
+    });
+
+    await zip.extract(null, unzipDir);
+
+    // Do not forget to close the file once you're done
+    await zip.close();
+
+    const filename = path.basename(item, '.zip');
+    return path.resolve(unzipDir, `${filename}.json`);
+};
+
+const getReportData = async (item, num, options) => {
+    if (typeof item === 'string') {
+
+        // json or zip path
+        const extname = path.extname(item);
+        if (extname === '.zip') {
+            item = await unzipDataFile(item, num, options);
+            // console.log(item);
+        }
+
+        // json path
+        const data = Util.readJSONSync(item);
+        if (!data) {
+            Util.logError(`failed to read report data file: ${item}`);
+            return;
+        }
+
+        // for finding attachments
+        const jsonDir = Util.relativePath(path.dirname(item));
+
+        Util.logInfo(`report data loaded: ${item}`);
+        return {
+            jsonDir,
+            data
+        };
+    }
+
+    if (!checkReportData(item)) {
+        Util.logError(`unmatched report data format: ${item}`);
+        return;
+    }
+
+    // json
+    return {
+        jsonDir: item.outputDir,
+        data: item
+    };
+};
+
+const initDataList = async (reportDataList, options) => {
     if (!Util.isList(reportDataList)) {
         Util.logError(`invalid report data list: ${reportDataList}`);
         return;
@@ -23,31 +88,17 @@ const initDataList = (reportDataList) => {
     let hasError = false;
     const list = [];
 
+    let num = 1;
     for (const item of reportDataList) {
-        if (typeof item === 'string') {
-            const data = Util.readJSONSync(item);
-            if (!data) {
-                hasError = true;
-                Util.logError(`failed to read report data file: ${item}`);
-                continue;
-            }
-
-            // for finding attachments
-            data.jsonDir = Util.relativePath(path.dirname(item));
 
-            list.push(data);
-            Util.logInfo(`report data loaded: ${item}`);
-            continue;
+        const data = await getReportData(item, num, options);
+        if (!data) {
+            hasError = true;
+            break;
         }
+        num += 1;
 
-        if (!checkReportData(item)) {
-            Util.logError(`unmatched report data format: ${item}`);
-            return;
-        }
-
-        item.jsonDir = item.outputDir;
-
-        list.push(item);
+        list.push(data);
     }
 
     if (hasError) {
@@ -82,12 +133,10 @@ const copyTarget = (targetPath, fromDir, toDir) => {
     }
 };
 
-const attachmentsHandler = (item, outputDir, attachmentPathHandler) => {
+const attachmentsHandler = (data, jsonDir, outputDir, attachmentPathHandler) => {
 
-    const jsonDir = item.jsonDir;
-
-    const extras = Util.getAttachmentPathExtras(item);
-    Util.forEach(item.rows, (row) => {
+    const extras = Util.getAttachmentPathExtras(data);
+    Util.forEach(data.rows, (row) => {
         if (row.type !== 'case' || !row.attachments) {
             return;
         }
@@ -195,62 +244,51 @@ const mergeArtifacts = async (artifactsList, options) => {
 
 const mergeDataList = async (dataList, options) => {
 
-    const trends = await getTrends(options.trend);
-
-    const outputFile = await Util.resolveOutputFile(options.outputFile);
-    // init outputDir
-    const outputDir = path.dirname(outputFile);
-    // clean
-    if (fs.existsSync(outputDir)) {
-        fs.rmSync(outputDir, {
-            recursive: true,
-            force: true,
-            maxRetries: 10
-        });
-    }
+    const { outputFile, outputDir } = options;
 
-    fs.mkdirSync(outputDir, {
-        recursive: true
-    });
-    // for attachment path handler
-    options.outputDir = outputDir;
+    const trends = await getTrends(options.trend);
 
     const attachmentPathHandler = typeof options.attachmentPath === 'function' ? options.attachmentPath : null;
 
-    const dates = [];
-    const endDates = [];
+    const startDates = [];
+    const dateRanges = [];
     const metadata = {};
     const system = [];
     const rows = [];
     const artifactsList = [];
 
-    for (const item of dataList) {
+    for (const dataItem of dataList) {
 
-        attachmentsHandler(item, outputDir, attachmentPathHandler);
+        const { data, jsonDir } = dataItem;
 
-        dates.push(item.date);
-        endDates.push(item.date + item.duration);
+        attachmentsHandler(data, jsonDir, outputDir, attachmentPathHandler);
+
+        startDates.push(data.date);
+        dateRanges.push({
+            start: data.date,
+            end: data.date + data.duration
+        });
 
         // merge metadata (may collect from diff shard)
-        Object.assign(metadata, item.metadata);
+        Object.assign(metadata, data.metadata);
 
         // merge system
-        system.push(item.system);
+        system.push(data.system);
 
         // merge rows
         rows.push({
             // add shard level suite
-            title: item.system.hostname,
+            title: data.system.hostname,
             type: 'suite',
             suiteType: 'shard',
-            caseNum: item.summary.tests.value,
-            subs: item.rows
+            caseNum: data.summary.tests.value,
+            subs: data.rows
         });
 
-        if (item.artifacts) {
+        if (data.artifacts) {
             artifactsList.push({
-                jsonDir: item.jsonDir,
-                artifacts: item.artifacts
+                jsonDir,
+                artifacts: data.artifacts
             });
         }
 
@@ -260,7 +298,7 @@ const mergeDataList = async (dataList, options) => {
 
     // base on first one, do not change dataList (need for onData)
     const mergedData = {
-        ... dataList[0]
+        ... dataList[0].data
     };
 
     // merge new options
@@ -272,11 +310,10 @@ const mergeDataList = async (dataList, options) => {
 
     const reportName = options.name || mergedData.name;
 
-    const date = Math.min.apply(null, dates);
+    const date = Math.min.apply(null, startDates);
     const dateH = new Date(date).toLocaleString();
 
-    const endDate = Math.max.apply(null, endDates);
-    const duration = endDate - date;
+    const duration = Util.getDuration(dateRanges, options.durationStrategy);
     const durationH = Util.TF(duration);
 
     Object.assign(mergedData, {
@@ -315,19 +352,30 @@ module.exports = async (reportDataList, userOptions = {}) => {
 
     Util.logInfo('merging report data ...');
 
-    const dataList = await initDataList(reportDataList);
-    if (!dataList) {
-        return;
-    }
-
     const options = {
         ... getDefaultOptions(),
         ... userOptions
     };
 
+    // init options
+    const outputFile = Util.resolveOutputFile(options.outputFile);
+    options.outputFile = outputFile;
+    // init outputDir
+    const outputDir = path.dirname(outputFile);
+    // clean
+    Util.initDir(outputDir);
+    // for attachment path handler
+    options.outputDir = outputDir;
+
+    const dataList = await initDataList(reportDataList, options);
+    if (!dataList) {
+        return;
+    }
+
     const reportData = await mergeDataList(dataList, options);
     // console.log(reportData.artifacts);
 
-    return generateReport(reportData, options, dataList);
+    const rawData = dataList.map((it) => it.data);
+    return generateReport(reportData, options, rawData);
 
 };