Merge pull request #647 from gemini-testing/TESTPLANE-485.fix_merge_reports

DudaGod · web-flow · commit 45f6214ef289 · 2025-04-18T15:39:51.000+03:00
fix(merge-reports): ability to merge reports locally
diff --git a/.eslintignore b/.eslintignore
@@ -5,6 +5,7 @@ hot
 /lib/static/*.min.js
 /lib/static/data.js
 /lib/static/sql-wasm.js
+/@
 /test/func/**/report
 /test/func/**/report-backup
 /test/func/**/reports
diff --git a/lib/adapters/event-handling/testplane/snapshots.ts b/lib/adapters/event-handling/testplane/snapshots.ts
@@ -33,12 +33,13 @@ interface CreateSnapshotFilePathParams {
     attempt: number;
     hash: string;
     browserId: string;
+    timestamp: number;
 }
 
-export function createSnapshotFilePath({attempt: attemptInput, hash, browserId}: CreateSnapshotFilePathParams): string {
+export function createSnapshotFilePath({attempt: attemptInput, hash, browserId, timestamp}: CreateSnapshotFilePathParams): string {
     const attempt: number = attemptInput || 0;
-    const imageDir = _.compact([SNAPSHOTS_PATH, hash]);
-    const components = imageDir.concat(`${browserId}_${attempt}.zip`);
+    const snapshotDir = _.compact([SNAPSHOTS_PATH, hash]);
+    const components = snapshotDir.concat(`${browserId}_${timestamp}_${attempt}.zip`);
 
     return path.join(...components);
 }
@@ -141,7 +142,8 @@ export const finalizeSnapshotsForTest = async ({testResult, attempt, reportPath,
         const zipFilePath = createSnapshotFilePath({
             attempt,
             hash: testResult.imageDir,
-            browserId: testResult.browserId
+            browserId: testResult.browserId,
+            timestamp: testResult.timestamp
         });
         const absoluteZipFilePath = path.resolve(reportPath, zipFilePath);
         await fsExtra.ensureDir(path.dirname(absoluteZipFilePath));
diff --git a/lib/adapters/test-result/index.ts b/lib/adapters/test-result/index.ts
@@ -22,7 +22,7 @@ export interface ReporterTestResult {
     readonly status: TestStatus;
     readonly testPath: string[];
     /** Test start timestamp in ms */
-    readonly timestamp: number | undefined;
+    readonly timestamp: number;
     readonly url?: string;
     /** Test duration in ms */
     readonly duration: number;
diff --git a/lib/adapters/test-result/playwright.ts b/lib/adapters/test-result/playwright.ts
@@ -350,7 +350,7 @@ export class PlaywrightTestResultAdapter implements ReporterTestResult {
         return this._testCase.titlePath().slice(3);
     }
 
-    get timestamp(): number | undefined {
+    get timestamp(): number {
         return this._testResult.startTime.getTime();
     }
 
diff --git a/lib/adapters/test-result/reporter.ts b/lib/adapters/test-result/reporter.ts
@@ -108,7 +108,7 @@ export class ReporterTestAdapter implements ReporterTestResult {
         return this._testResult.testPath;
     }
 
-    get timestamp(): number | undefined {
+    get timestamp(): number {
         return this._testResult.timestamp;
     }
 
diff --git a/lib/adapters/test-result/sqlite.ts b/lib/adapters/test-result/sqlite.ts
@@ -144,7 +144,7 @@ export class SqliteTestResultAdapter implements ReporterTestResult {
         return this._parsedTestResult.testPath as string[];
     }
 
-    get timestamp(): number | undefined {
+    get timestamp(): number {
         return Number(this._testResult[DB_COLUMN_INDEXES.timestamp]);
     }
 
diff --git a/lib/adapters/test-result/testplane.ts b/lib/adapters/test-result/testplane.ts
@@ -258,7 +258,7 @@ export class TestplaneTestResultAdapter implements ReporterTestResult {
         return true;
     }
 
-    get timestamp(): number | undefined {
+    get timestamp(): number {
         return this._timestamp;
     }
 
diff --git a/lib/cli/commands/merge-reports.js b/lib/cli/commands/merge-reports.js
@@ -3,24 +3,17 @@
 const {commands} = require('..');
 const mergeReports = require('../../merge-reports');
 const {logError} = require('../../server-utils');
-const {ToolName} = require('../../constants');
 
 const {MERGE_REPORTS: commandName} = commands;
 
 module.exports = (program, toolAdapter) => {
-    const {toolName} = toolAdapter;
-
     program
         .command(`${commandName} [paths...]`)
         .allowUnknownOption()
         .description('merge reports')
         .option('-d, --destination <destination>', 'path to directory with merged report', toolAdapter.reporterConfig.path)
         .option('-h, --header <header>', 'http header for databaseUrls.json files from source paths', collect, [])
         .action(async (paths, options) => {
-            if (toolName !== ToolName.Testplane) {
-                throw new Error(`CLI command "${commandName}" supports only "${ToolName.Testplane}" tool`);
-            }
-
             try {
                 const {destination: destPath, header: headers} = options;
 
diff --git a/lib/constants/database.ts b/lib/constants/database.ts
@@ -67,3 +67,5 @@ export const DB_COLUMN_INDEXES = SUITES_TABLE_COLUMNS.reduce((acc: Record<string
     acc[name] = index;
     return acc;
 }, {}) as unknown as DbColumnIndexes;
+
+export const DB_FILE_EXTENSION = '.db';
diff --git a/lib/db-utils/server.ts b/lib/db-utils/server.ts
@@ -18,7 +18,11 @@ import {SqliteClient} from '../sqlite-client';
 
 export * from './common';
 
-export const prepareUrls = (urls: string[], baseUrl: string): string[] => isUrl(baseUrl) ? normalizeUrls(urls, baseUrl) : urls;
+export const prepareUrls = (urls: string[], baseUrl: string): string[] => {
+    return isUrl(baseUrl)
+        ? normalizeUrls(urls, baseUrl)
+        : urls.map(u => isUrl(u) ? u : path.join(path.parse(baseUrl).dir, u));
+};
 
 export async function downloadDatabases(dbJsonUrls: string[], opts: HandleDatabasesOptions): Promise<(string | DbLoadResult)[]> {
     const loadDbJsonUrl = async (dbJsonUrl: string): Promise<{data: DbUrlsJsonData | null}> => {
diff --git a/lib/merge-reports/index.js b/lib/merge-reports/index.js
@@ -1,12 +1,19 @@
 'use strict';
 
+const url = require('url');
+const urljoin = require('url-join');
+const path = require('path');
+const fs = require('fs-extra');
 const axios = require('axios');
 const _ = require('lodash');
+
 const serverUtils = require('../server-utils');
+const {isUrl, logger} = require('../common-utils');
 const dbServerUtils = require('../db-utils/server');
+const {DB_FILE_EXTENSION, IMAGES_PATH, SNAPSHOTS_PATH, ERROR_DETAILS_PATH, DATABASE_URLS_JSON_NAME, LOCAL_DATABASE_NAME} = require('../constants');
 
 module.exports = async (toolAdapter, srcPaths, {destPath, headers}) => {
-    validateOpts({srcPaths, destPath, headers});
+    await validateOpts({srcPaths, destPath, headers});
 
     let headersFromEnv;
     const {htmlReporter, reporterConfig} = toolAdapter;
@@ -24,24 +31,81 @@ module.exports = async (toolAdapter, srcPaths, {destPath, headers}) => {
     const parsedHeaders = {...headersFromCli, ...headersFromEnv};
 
     const resolvedUrls = await tryResolveUrls(srcPaths, parsedHeaders);
+    const resolvedDbFiles = resolvedUrls.filter(serverUtils.isDbFile);
+
+    const {true: remoteDbUrls = [], false: localDbPaths = []} = _.groupBy(resolvedDbFiles, isUrl);
+    const dbPaths = localDbPaths.map((db, ind, arr) => {
+        const dbName = arr.length > 1 ? genUniqDbName(db, ind + 1) : path.basename(db);
+        return {src: path.resolve(process.cwd(), db), dest: path.resolve(destPath, dbName)};
+    });
+
+    const allDbPaths = [...remoteDbUrls, ...dbPaths.map(({dest}) => path.parse(dest).base)];
+    const copyFilePromises = [];
+
+    if (!_.isEmpty(localDbPaths)) {
+        const srcReportPaths = _.uniq(localDbPaths.map(db => path.resolve(process.cwd(), path.parse(db).dir)));
+
+        copyFilePromises.push(...[
+            copyDbFiles(dbPaths),
+            copyArtifacts({srcPaths: srcReportPaths, destPath, folderName: IMAGES_PATH}),
+            copyArtifacts({srcPaths: srcReportPaths, destPath, folderName: SNAPSHOTS_PATH}),
+            copyArtifacts({srcPaths: srcReportPaths, destPath, folderName: ERROR_DETAILS_PATH})
+        ]);
+    }
 
     await Promise.all([
         serverUtils.saveStaticFilesToReportDir(htmlReporter, reporterConfig, destPath),
-        serverUtils.writeDatabaseUrlsFile(destPath, resolvedUrls)
+        serverUtils.writeDatabaseUrlsFile(destPath, allDbPaths),
+        ...copyFilePromises
     ]);
 
     await htmlReporter.emitAsync(htmlReporter.events.REPORT_SAVED, {reportPath: destPath});
 };
 
-function validateOpts({srcPaths, destPath, headers}) {
+async function validateOpts({srcPaths, destPath, headers}) {
     if (!srcPaths.length) {
         throw new Error('Nothing to merge, no source reports are passed');
     }
 
+    if (srcPaths.length === 1) {
+        throw new Error(`Nothing to merge, only one source report is passed: ${srcPaths[0]}`);
+    }
+
     if (srcPaths.includes(destPath)) {
         throw new Error(`Destination report path: ${destPath}, exists in source report paths`);
     }
 
+    for (const srcPath of srcPaths) {
+        if (isUrl(srcPath)) {
+            continue;
+        }
+
+        let srcPathStat;
+
+        try {
+            srcPathStat = await fs.stat(srcPath);
+        } catch (err) {
+            if (err.code !== 'ENOENT') {
+                throw err;
+            } else {
+                throw new Error(`Specified source path: ${srcPath} doesn't exists on file system`);
+            }
+        }
+
+        if (srcPathStat.isDirectory()) {
+            const dbUrlsJsonPath = path.join(srcPath, DATABASE_URLS_JSON_NAME);
+            const isDbUrlsJsonPathExists = await fs.pathExists(dbUrlsJsonPath);
+
+            if (!isDbUrlsJsonPathExists) {
+                throw new Error(`${DATABASE_URLS_JSON_NAME} doesn't exist in specified source path: ${srcPath}`);
+            }
+        } else {
+            if (!srcPath.endsWith(DATABASE_URLS_JSON_NAME) && !srcPath.endsWith(LOCAL_DATABASE_NAME)) {
+                throw new Error(`Specified source path: ${srcPath} must ends with ${DATABASE_URLS_JSON_NAME} or ${LOCAL_DATABASE_NAME}`);
+            }
+        }
+    }
+
     for (const header of headers) {
         if (!header.includes('=')) {
             throw new Error(`Header must has key and value separated by "=" symbol, but got "${header}"`);
@@ -51,7 +115,15 @@ function validateOpts({srcPaths, destPath, headers}) {
 
 async function tryResolveUrls(urls, headers) {
     const resolvedUrls = [];
-    const results = await Promise.all(urls.map(url => tryResolveUrl(url, headers)));
+    const results = await Promise.all(urls.map(async u => {
+        const extName = path.extname(isUrl(u) ? url.parse(u).pathname : u);
+
+        if (!extName) {
+            u = isUrl(u) ? urljoin(u, DATABASE_URLS_JSON_NAME) : path.join(u, DATABASE_URLS_JSON_NAME);
+        }
+
+        return tryResolveUrl(u, headers);
+    }));
 
     results.forEach(({jsonUrls, dbUrls}) => {
         resolvedUrls.push(...jsonUrls.concat(dbUrls));
@@ -64,11 +136,14 @@ async function tryResolveUrl(url, headers) {
     const jsonUrls = [];
     const dbUrls = [];
 
-    if (serverUtils.isDbUrl(url)) {
+    if (serverUtils.isDbFile(url)) {
         dbUrls.push(url);
     } else if (serverUtils.isJsonUrl(url)) {
         try {
-            const {data} = await axios.get(url, {headers});
+            const data = isUrl(url)
+                ? (await axios.get(url, {headers})).data
+                : await fs.readJSON(url);
+
             const currentDbUrls = _.get(data, 'dbUrls', []);
             const currentJsonUrls = _.get(data, 'jsonUrls', []);
 
@@ -84,9 +159,32 @@ async function tryResolveUrl(url, headers) {
                 jsonUrls.push(...response.jsonUrls);
             });
         } catch (e) {
+            logger.warn(`Failed to handle ${url}: ${e.message}`);
             jsonUrls.push(url);
         }
     }
 
     return {jsonUrls, dbUrls};
 }
+
+function genUniqDbName(dbPath, num) {
+    return `${path.basename(dbPath, DB_FILE_EXTENSION)}_${num}${DB_FILE_EXTENSION}`;
+}
+
+async function copyDbFiles(dbPaths) {
+    await Promise.all(dbPaths.map(({src, dest}) => fs.copy(src, dest)));
+}
+
+async function copyArtifacts({srcPaths, destPath, folderName}) {
+    for (const reportPath of srcPaths) {
+        const src = path.resolve(reportPath, folderName);
+        const dest = path.resolve(destPath, folderName);
+
+        const exists = await fs.pathExists(src);
+        if (!exists) {
+            continue;
+        }
+
+        await fs.copy(src, dest, {recursive: true, overwrite: false});
+    }
+}
diff --git a/lib/server-utils.ts b/lib/server-utils.ts
@@ -9,8 +9,8 @@ import type {Test as TestplaneTest} from 'testplane';
 import _ from 'lodash';
 import tmp from 'tmp';
 
-import {getShortMD5, logger, mkTestId} from './common-utils';
-import {UPDATED, RUNNING, IDLE, SKIPPED, IMAGES_PATH, TestStatus, UNKNOWN_ATTEMPT} from './constants';
+import {getShortMD5, logger, mkTestId, isUrl} from './common-utils';
+import {UPDATED, RUNNING, IDLE, SKIPPED, IMAGES_PATH, TestStatus, UNKNOWN_ATTEMPT, DB_FILE_EXTENSION} from './constants';
 import type {HtmlReporter} from './plugin-api';
 import type {ReporterTestResult} from './adapters/test-result';
 import {
@@ -27,29 +27,30 @@ interface GetPathOptions {
     imageDir: string;
     attempt: number;
     browserId: string;
+    timestamp: number;
 }
 
 export const getReferencePath = (options: GetPathOptions, stateName?: string): string =>
-    createPath({kind: 'ref', stateName, ..._.pick(options, ['attempt', 'browserId', 'imageDir'])});
+    createPath({kind: 'ref', stateName, ..._.pick(options, ['attempt', 'browserId', 'imageDir', 'timestamp'])});
 export const getCurrentPath = (options: GetPathOptions, stateName?: string): string =>
-    createPath({kind: 'current', stateName, ..._.pick(options, ['attempt', 'browserId', 'imageDir'])});
+    createPath({kind: 'current', stateName, ..._.pick(options, ['attempt', 'browserId', 'imageDir', 'timestamp'])});
 export const getDiffPath = (options: GetPathOptions, stateName?: string): string =>
-    createPath({kind: 'diff', stateName, ..._.pick(options, ['attempt', 'browserId', 'imageDir'])});
+    createPath({kind: 'diff', stateName, ..._.pick(options, ['attempt', 'browserId', 'imageDir', 'timestamp'])});
 
 export const getReferenceAbsolutePath = (testResult: ReporterTestResult, reportDir: string, stateName: string): string => {
-    const referenceImagePath = getReferencePath({attempt: testResult.attempt, imageDir: testResult.imageDir, browserId: testResult.browserId}, stateName);
+    const referenceImagePath = getReferencePath({attempt: testResult.attempt, imageDir: testResult.imageDir, browserId: testResult.browserId, timestamp: testResult.timestamp}, stateName);
 
     return path.resolve(reportDir, referenceImagePath);
 };
 
 export const getCurrentAbsolutePath = (testResult: ReporterTestResult, reportDir: string, stateName: string): string => {
-    const currentImagePath = getCurrentPath({attempt: testResult.attempt, imageDir: testResult.imageDir, browserId: testResult.browserId}, stateName);
+    const currentImagePath = getCurrentPath({attempt: testResult.attempt, imageDir: testResult.imageDir, browserId: testResult.browserId, timestamp: testResult.timestamp}, stateName);
 
     return path.resolve(reportDir, currentImagePath);
 };
 
 export const getDiffAbsolutePath = (testResult: ReporterTestResult, reportDir: string, stateName: string): string => {
-    const diffImagePath = getDiffPath({attempt: testResult.attempt, imageDir: testResult.imageDir, browserId: testResult.browserId}, stateName);
+    const diffImagePath = getDiffPath({attempt: testResult.attempt, imageDir: testResult.imageDir, browserId: testResult.browserId, timestamp: testResult.timestamp}, stateName);
 
     return path.resolve(reportDir, diffImagePath);
 };
@@ -59,10 +60,10 @@ interface CreatePathOptions extends GetPathOptions {
     kind: string;
 }
 
-export function createPath({attempt: attemptInput, imageDir: imageDirInput, browserId, kind, stateName}: CreatePathOptions): string {
+export function createPath({attempt: attemptInput, imageDir: imageDirInput, timestamp, browserId, kind, stateName}: CreatePathOptions): string {
     const attempt: number = attemptInput || 0;
     const imageDir = _.compact([IMAGES_PATH, imageDirInput, stateName]);
-    const components = imageDir.concat(`${browserId}~${kind}_${attempt}.png`);
+    const components = imageDir.concat(`${browserId}~${kind}_${timestamp}_${attempt}.png`);
 
     return path.join(...components);
 }
@@ -126,6 +127,7 @@ export function shouldUpdateAttempt(status: TestStatus): boolean {
 
 export async function saveStaticFilesToReportDir(htmlReporter: HtmlReporter, pluginConfig: ReporterConfig, destPath: string): Promise<void> {
     const staticFolder = path.resolve(__dirname, './static');
+
     await fs.ensureDir(destPath);
     await Promise.all([
         fs.writeFile(
@@ -179,13 +181,13 @@ export function isJsonUrl(url: string): boolean {
     return urlPathNameEndsWith(url, '.json');
 }
 
-export function isDbUrl(url: string): boolean {
-    return urlPathNameEndsWith(url, '.db');
+export function isDbFile(filePath: string): boolean {
+    return isUrl(filePath) ? urlPathNameEndsWith(filePath, DB_FILE_EXTENSION) : filePath.endsWith(DB_FILE_EXTENSION);
 }
 
 export async function writeDatabaseUrlsFile(destPath: string, srcPaths: string[]): Promise<void> {
     const jsonUrls = srcPaths.filter(isJsonUrl);
-    const dbUrls = srcPaths.filter(isDbUrl);
+    const dbUrls = srcPaths.filter(isDbFile);
     const data = {
         dbUrls,
         jsonUrls
diff --git a/package-lock.json b/package-lock.json
diff --git a/package.json b/package.json
diff --git a/test/unit/lib/merge-reports/index.js b/test/unit/lib/merge-reports/index.js
diff --git a/test/unit/lib/server-utils.js b/test/unit/lib/server-utils.js

Original file line number	Diff line number	Diff line change
`@@ -350,7 +350,7 @@ export class PlaywrightTestResultAdapter implements ReporterTestResult {`
`350`	`350`	`return this._testCase.titlePath().slice(3);`
`351`	`351`	`}`
`352`	`352`
`353`		`- get timestamp(): number \| undefined {`
	`353`	`+ get timestamp(): number {`
`354`	`354`	`return this._testResult.startTime.getTime();`
`355`	`355`	`}`
`356`	`356`
Original file line number	Diff line number	Diff line change
`@@ -108,7 +108,7 @@ export class ReporterTestAdapter implements ReporterTestResult {`
`108`	`108`	`return this._testResult.testPath;`
`109`	`109`	`}`
`110`	`110`
`111`		`- get timestamp(): number \| undefined {`
	`111`	`+ get timestamp(): number {`
`112`	`112`	`return this._testResult.timestamp;`
`113`	`113`	`}`
`114`	`114`
Original file line number	Diff line number	Diff line change
`@@ -144,7 +144,7 @@ export class SqliteTestResultAdapter implements ReporterTestResult {`
`144`	`144`	`return this._parsedTestResult.testPath as string[];`
`145`	`145`	`}`
`146`	`146`
`147`		`- get timestamp(): number \| undefined {`
	`147`	`+ get timestamp(): number {`
`148`	`148`	`return Number(this._testResult[DB_COLUMN_INDEXES.timestamp]);`
`149`	`149`	`}`
`150`	`150`
Original file line number	Diff line number	Diff line change
`@@ -258,7 +258,7 @@ export class TestplaneTestResultAdapter implements ReporterTestResult {`
`258`	`258`	`return true;`
`259`	`259`	`}`
`260`	`260`
`261`		`- get timestamp(): number \| undefined {`
	`261`	`+ get timestamp(): number {`
`262`	`262`	`return this._timestamp;`
`263`	`263`	`}`
`264`	`264`