monocart-reporter 1.6.33 → 1.6.35

package/lib/plugins/coverage/v8/v8.js

@@ -1,131 +1,171 @@
-const path = require('path');
+const EC = require('eight-colors');
+
 const Util = require('../../../utils/util.js');
-const { unpackSourceMaps } = require('./source-map.js');
 const { getV8Summary } = require('./v8-summary.js');
-const { dedupeCountRanges, dedupeRanges } = require('./dedupe.js');
-const { sortRanges, getSourcePath } = require('../coverage-utils.js');
-
-// convert functions to ranges
-const initCountRanges = (functions) => {
-    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
-                });
-            }
-        }
-    }
+const { dedupeRanges } = require('./dedupe.js');
+const { getSourcePath, convertFunctionsToRanges } = require('../coverage-utils.js');
+const { collectSourceMaps, unpackSourceMaps } = require('./source-map.js');
+const { mergeScriptCovs } = require('../../../runtime/monocart-coverage.js');
 
-    sortRanges(ranges);
 
-    return {
-        ranges
-    };
-};
+// ========================================================================================================
 
-// Unify the format of js and css
-const initV8List = async (v8list, options) => {
+const initV8ListAndSourcemap = async (v8list, options, inlineSourceMap) => {
 
-    // filter list
+    // filter list first
     const entryFilter = options.entryFilter;
     if (typeof entryFilter === 'function') {
         v8list = v8list.filter(entryFilter);
     }
 
-    // filter no source or text and init type
-    v8list = v8list.map((item) => {
+    // filter no source or text
+    // init type and css source from text
+    // keep functions
+
+    v8list = v8list.filter((item) => {
         if (typeof item.source === 'string' && item.functions) {
-            const {
-                url, source, functions
-            } = item;
-
-            // functions to ranges
-            const { ranges } = initCountRanges(functions);
-
-            return {
-                url,
-                type: 'js',
-                ranges,
-                source
-            };
+            return true;
         }
         if (typeof item.text === 'string' && item.ranges) {
-            const {
-                url, text, ranges
-            } = item;
-            // rename text to source
-            return {
-                url,
-                type: 'css',
-                ranges,
-                source: text
-            };
+            return true;
         }
         // 404 css, text will be empty
         // EC.logRed(`[MCR] Invalid source: ${item.url}`);
         // console.log(item);
-    }).filter((it) => it);
+    });
 
-    // unpack source maps if options.unpackSourceMap = true
-    await unpackSourceMaps(v8list, options);
 
-    // init list properties
-    v8list.forEach((item, i) => {
-        if (!item.sourcePath) {
-            item.sourcePath = getSourcePath(item.url, i + 1, item.type);
+    // do not change original v8list, to work for multiple APIs
+
+    // init id, sourcePath
+    v8list = v8list.map((item, i) => {
+
+        const data = {
+            url: item.url
+        };
+
+        if (item.functions) {
+            data.type = 'js';
+            data.functions = item.functions;
+            data.source = item.source;
+            // useless here
+            // data.scriptId = item.scriptId;
+        } else if (item.ranges) {
+            data.type = 'css';
+            data.ranges = item.ranges;
+            data.source = item.text;
         }
-        item.filename = path.basename(item.sourcePath);
-        item.id = Util.calculateSha1(item.url + item.source);
+
+        data.id = Util.calculateSha1(data.url + data.source);
+        data.sourcePath = getSourcePath(data.url, i + 1, data.type);
+
+        return data;
     });
 
-    v8list = await mergeV8List(v8list, options);
+    // collect sourcemap first
+    await collectSourceMaps(v8list, options, inlineSourceMap);
 
     return v8list;
 };
 
-// ============================================================
+// ========================================================================================================
+
+const unpackV8List = async (v8list, options) => {
+    v8list.forEach((item, i) => {
+        if (item.type === 'js') {
+            item.ranges = convertFunctionsToRanges(item.functions);
+            delete item.functions;
+        }
+    });
+
+    // requires ranges before unpack
+    await unpackSourceMaps(v8list, options);
+
+    // console.log(v8list.length);
+};
+
+// ========================================================================================================
 
 // force to async
-const mergeV8Item = (lastItem, item) => {
+const mergeCssRanges = (itemList) => {
     return new Promise((resolve) => {
-        const concatRanges = [].concat(lastItem.ranges).concat(item.ranges);
-        if (lastItem.type === 'css') {
-            // ranges: [ {start, end} ]
-            lastItem.ranges = dedupeRanges(concatRanges);
-        } else {
-            // ranges: [ {start, end, count} ]
-            lastItem.ranges = dedupeCountRanges(concatRanges);
-        }
-        resolve(lastItem);
+
+        let concatRanges = [];
+        itemList.forEach((item) => {
+            concatRanges = concatRanges.concat(item.ranges);
+        });
+
+        // ranges: [ {start, end} ]
+        const ranges = dedupeRanges(concatRanges);
+
+        resolve(ranges || []);
     });
 };
 
-const mergeV8List = async (v8list, options) => {
+const mergeJsFunctions = (itemList) => {
+    return new Promise((resolve) => {
+
+        const res = mergeScriptCovs(itemList);
+        const functions = res && res.functions;
 
-    // sort by id, id is hash from url and source
-    v8list.sort((a, b) => {
-        return a.id > b.id ? 1 : -1;
+        resolve(functions || []);
     });
+};
+
+const mergeV8Coverage = async (dataList, options) => {
 
-    let lastItem = {};
-    for (const item of v8list) {
-        if (item.id === lastItem.id) {
-            item.dedupe = true;
-            lastItem = await mergeV8Item(lastItem, item);
-            continue;
+    let list = [];
+    dataList.forEach((d) => {
+        list = list.concat(d.data);
+    });
+
+    // console.log('before merge', list.map((it) => it.url));
+
+    // connect all functions and ranges
+    const itemMap = {};
+    const mergeMap = {};
+    list.forEach((item) => {
+        const { id } = item;
+        const prev = itemMap[id];
+        if (prev) {
+            if (mergeMap[id]) {
+                mergeMap[id].push(item);
+            } else {
+                mergeMap[id] = [prev, item];
+            }
+        } else {
+            itemMap[id] = item;
         }
-        lastItem = item;
-    }
+    });
 
-    const list = v8list.filter((it) => !it.dedupe);
+    // merge functions and ranges
+    const mergeIds = Object.keys(mergeMap);
+    for (const id of mergeIds) {
+        const itemList = mergeMap[id];
+        const item = itemMap[id];
+        if (item.type === 'js') {
+            item.functions = await mergeJsFunctions(itemList);
+        } else {
+            item.ranges = await mergeCssRanges(itemList);
+        }
+    }
 
-    // console.log(list.map((it) => it.url));
+    list = Object.values(itemMap);
+
+    // try to load coverage and source by id
+    for (const item of list) {
+        const { id } = item;
+        const sourcePath = Util.resolveArtifactSourcePath(options.artifactsDir, id);
+        const content = await Util.readFile(sourcePath);
+        if (content) {
+            const json = JSON.parse(content);
+            item.source = json.source;
+            item.sourceMap = json.sourceMap;
+        } else {
+            EC.logRed(`[MCR] failed to read source: ${item.url}`);
+            item.source = '';
+        }
+    }
 
     return list;
 };
@@ -221,7 +261,8 @@ const saveV8Report = async (v8list, options) => {
 };
 
 module.exports = {
-    initV8List,
-    mergeV8List,
+    initV8ListAndSourcemap,
+    unpackV8List,
+    mergeV8Coverage,
     saveV8Report
 };

package/lib/plugins/network/network.js

@@ -128,14 +128,14 @@ const attachNetworkReport = async (har, testInfo, options = {}) => {
     }
 
     options = {
+        // default title
+        title: `Network Report - ${testInfo.title}`,
         outputDir: Util.resolveOutputDir(testInfo),
-        outputName: `network-${Util.shortTestId(testInfo.testId)}`,
+        outputName: `network-${Util.resolveTestIdWithRetry(testInfo)}`,
         inline: false,
         ... options
     };
 
-    const title = options.title || `Network Report - ${testInfo.title}`;
-
     const htmlDir = path.resolve(options.outputDir, options.outputName);
     if (!fs.existsSync(htmlDir)) {
         fs.mkdirSync(htmlDir, {
@@ -148,7 +148,7 @@ const attachNetworkReport = async (har, testInfo, options = {}) => {
 
     // save har
     const reportData = {
-        title,
+        title: options.title,
         summary,
         ... harData
     };
@@ -156,7 +156,7 @@ const attachNetworkReport = async (har, testInfo, options = {}) => {
     const htmlPath = await saveNetworkHtmlReport(reportData, options);
 
     const report = {
-        title,
+        title: options.title,
         ... harData.log,
         htmlPath,
         summary
@@ -182,12 +182,12 @@ const addNetworkReport = async () => {
 
 };
 
-const generateNetworkReport = async () => {
+const generateGlobalNetworkReport = async () => {
 
 };
 
 module.exports = {
     addNetworkReport,
-    generateNetworkReport,
+    generateGlobalNetworkReport,
     attachNetworkReport
 };