Merge pull request #1221 from gemini-testing/TESTPLANE-938.selectivity_report

feat(selectivity): add ability to save selectivity report

Author: KuznetsovRoman

src/browser/cdp/selectivity/runner.ts

@@ -1,5 +1,7 @@
 import _ from "lodash";
+import fs from "fs-extra";
 import pLimit from "p-limit";
+import * as logger from "../../../utils/logger";
 import type { Config } from "../../../config";
 import type { BrowserConfig } from "../../../config/browser-config";
 import type { MainRunner } from "../../../runner";
@@ -115,6 +117,17 @@ interface SelectivityRunnerOptions {
     shouldDisableSelectivity?: boolean;
 }
 
+interface SelectivityBrowserStats {
+    processedCount: number;
+    skippedCount: number;
+}
+
+interface SelectivityReport {
+    totalProcessedCount: number;
+    totalSkippedCount: number;
+    perBrowserStats: Record<string, SelectivityBrowserStats>;
+}
+
 export class SelectivityRunner {
     private readonly _config: Config;
     private readonly _runTestFn: (test: Test, browserId: string) => void;
@@ -123,6 +136,7 @@ export class SelectivityRunner {
     private readonly _testsToRun: [Test, string][] = [];
     private readonly _processingTestLimit = pLimit(16);
     private readonly _processingTestPromises: Array<Promise<void>> = [];
+    private readonly _stats: Record<string, SelectivityBrowserStats> = {};
 
     static create(...args: ConstructorParameters<typeof this>): SelectivityRunner {
         return new this(...args);
@@ -177,10 +191,19 @@ export class SelectivityRunner {
                     return;
                 }
 
+                this._stats[browserId] ||= {
+                    processedCount: 0,
+                    skippedCount: 0,
+                };
+
+                this._stats[browserId].processedCount++;
+
                 const shouldDisableTest = await shouldDisableTestBySelectivity(browserConfig, test);
 
                 if (!shouldDisableTest) {
                     this._testsToRun.push([test, browserId]);
+                } else {
+                    this._stats[browserId].skippedCount++;
                 }
             }),
         );
@@ -189,6 +212,10 @@ export class SelectivityRunner {
     async runNecessaryTests(): Promise<void> {
         await Promise.all(this._processingTestPromises);
 
+        const saveReportPromise = this._saveSelectivityReport().catch(reason => {
+            logger.error("Couldn't save selectivity report. Reason:", reason);
+        });
+
         this._testsToRun.forEach(([test, browserId]) => {
             this._runTestFn(test, browserId);
         });
@@ -204,5 +231,46 @@ export class SelectivityRunner {
 
             getHashReader(selectivity.testDependenciesPath, selectivity.compression).clearCache();
         });
+
+        await saveReportPromise;
+    }
+
+    async _saveSelectivityReport(): Promise<void> {
+        const browserReportPaths = Object.keys(this._stats).reduce((acc, browserId) => {
+            const reportPath =
+                process.env.TESTPLANE_SELECTIVITY_REPORT_PATH ||
+                this._config.forBrowser(browserId).selectivity.reportPath;
+
+            if (reportPath) {
+                acc[reportPath] ||= [];
+                acc[reportPath].push(browserId);
+            }
+
+            return acc;
+        }, {} as Record<string, string[]>);
+
+        const promises = await Promise.allSettled(
+            Object.keys(browserReportPaths).map(async reportPath => {
+                const report: SelectivityReport = {
+                    totalProcessedCount: 0,
+                    totalSkippedCount: 0,
+                    perBrowserStats: {},
+                };
+
+                for (const browserId of browserReportPaths[reportPath]) {
+                    report.totalProcessedCount += this._stats[browserId].processedCount;
+                    report.totalSkippedCount += this._stats[browserId].skippedCount;
+                    report.perBrowserStats[browserId] = this._stats[browserId];
+                }
+
+                await fs.outputJson(reportPath, report, { spaces: 4 });
+            }),
+        );
+
+        const failedPromise = promises.find(promise => promise.status === "rejected");
+
+        if (failedPromise && "reason" in failedPromise) {
+            throw failedPromise.reason;
+        }
     }
 }

src/config/defaults.js

@@ -136,6 +136,7 @@ module.exports = {
         compression: "gz",
         disableSelectivityPatterns: [],
         mapDependencyRelativePath: null,
+        reportPath: "",
     },
 };
 

src/config/types.ts

@@ -411,6 +411,7 @@ export interface CommonConfig {
         compression: SelectivityCompressionType;
         disableSelectivityPatterns: string[];
         mapDependencyRelativePath: null | SelectivityMapDependencyRelativePathFn;
+        reportPath: string;
     };
 
     timeTravel: TimeTravelConfig;