feat(selectivity): add ability to save incomplete dumps

Author: KuznetsovRoman

src/browser/cdp/selectivity/hash-writer.ts

@@ -61,7 +61,7 @@ export class HashWriter {
         dependencies.modules?.forEach(dependency => this._addModuleDependency(dependency));
     }
 
-    async save(readExisting?: boolean): Promise<void> {
+    async save(): Promise<void> {
         const hasStaged = Boolean(
             this._stagedFileHashes.size || this._stagedModuleHashes.size || this._stagedPatternHashes.size,
         );
@@ -89,13 +89,7 @@ export class HashWriter {
             shallowSortObject(dest);
         };
 
-        const fileContents = readExisting
-            ? await readHashFileContents(this._selectivityHashesPath, this._compresion)
-            : {
-                  files: {},
-                  modules: {},
-                  patterns: {},
-              };
+        const fileContents = await readHashFileContents(this._selectivityHashesPath, this._compresion);
 
         await writeTo(this._stagedFileHashes, fileContents.files);
         await writeTo(this._stagedModuleHashes, fileContents.modules);

src/browser/cdp/selectivity/index.ts

@@ -12,7 +12,7 @@ import { getCollectedTestplaneJsDependencies, getCollectedTestplanePngDependenci
 import { getHashReader } from "./hash-reader";
 import type { Config } from "../../../config";
 import { MasterEvents } from "../../../events";
-import { selectivityShouldRead, selectivityShouldWrite } from "./modes";
+import { selectivityShouldWrite } from "./modes";
 import { debugSelectivity } from "./debug";
 import { getUsedDumpsTracker } from "./used-dumps-tracker";
 import { DebuggerEvents } from "../domains/debugger";
@@ -21,18 +21,22 @@ import { CDPSessionId } from "../types";
 type StopSelectivityFn = (test: Test, shouldWrite: boolean) => Promise<void>;
 
 /**
- * Called at the end of successfull testplane run
+ * Called at the end of testplane run
  * Not using "Promise.all" here because all hashes are already calculated and cached at the start
  */
-export const updateSelectivityHashes = async (config: Config): Promise<void> => {
+export const updateSelectivityHashes = async (config: Config, isRunFailed: boolean): Promise<void> => {
     const browserIds = config.getBrowserIds();
     const processedRoots = new Set();
 
     for (const browserId of browserIds) {
         const browserConfig = config.forBrowser(browserId);
-        const { enabled, testDependenciesPath, compression, disableSelectivityPatterns } = browserConfig.selectivity;
-        const shouldReadExistingHashes = selectivityShouldRead(enabled);
-        const rootKey = `${shouldReadExistingHashes}#${testDependenciesPath}#${compression}`;
+        const { enabled, testDependenciesPath, compression, disableSelectivityPatterns, saveIncompleteDumpOnFail } =
+            browserConfig.selectivity;
+        const rootKey = `${testDependenciesPath}#${compression}`;
+
+        if ((isRunFailed || browserConfig.lastFailed.only) && !saveIncompleteDumpOnFail) {
+            continue;
+        }
 
         if (!selectivityShouldWrite(enabled) || processedRoots.has(rootKey)) {
             continue;
@@ -50,7 +54,7 @@ export const updateSelectivityHashes = async (config: Config): Promise<void> =>
         }
 
         try {
-            await hashWriter.save(shouldReadExistingHashes);
+            await hashWriter.save();
         } catch (cause) {
             throw new Error("Selectivity: couldn't save test dependencies hash", { cause });
         }
@@ -59,16 +63,21 @@ export const updateSelectivityHashes = async (config: Config): Promise<void> =>
     }
 };
 
-export const clearUnusedSelectivityDumps = async (config: Config): Promise<void> => {
+/**
+ * Called at the end of testplane run
+ */
+export const clearUnusedSelectivityDumps = async (config: Config, isRunFailed: boolean): Promise<void> => {
     const usedDumpsTracker = getUsedDumpsTracker();
     const browserIds = config.getBrowserIds();
     const selectivityRoots: string[] = [];
 
     for (const browserId of browserIds) {
         const browserConfig = config.forBrowser(browserId);
-        const { enabled, testDependenciesPath } = browserConfig.selectivity;
+        const { enabled, testDependenciesPath, saveIncompleteDumpOnFail } = browserConfig.selectivity;
 
-        if (selectivityShouldWrite(enabled) && !selectivityRoots.includes(testDependenciesPath)) {
+        if ((isRunFailed && !saveIncompleteDumpOnFail) || browserConfig.lastFailed.only) {
+            continue;
+        } else if (selectivityShouldWrite(enabled) && !selectivityRoots.includes(testDependenciesPath)) {
             selectivityRoots.push(testDependenciesPath);
         }
     }

src/browser/cdp/selectivity/runner.ts

@@ -22,6 +22,16 @@ const shouldDisableBrowserSelectivity = _.memoize(
             return true;
         }
 
+        if (config.lastFailed.only) {
+            if (!config.selectivity.saveIncompleteDumpOnFail) {
+                logger.warn(`Disabling selectivity for ${browserId}: lastFailedOnly mode is enabled`);
+            } else {
+                debugSelectivity(`Not skipping tests for ${browserId}: lastFailedOnly mode controls it`);
+            }
+
+            return true;
+        }
+
         if (!config.selectivity.disableSelectivityPatterns.length) {
             return false;
         }
@@ -65,9 +75,10 @@ const shouldDisableBrowserSelectivity = _.memoize(
     },
     config => {
         const { enabled, testDependenciesPath, compression, disableSelectivityPatterns } = config.selectivity;
+        const lastFailed = config.lastFailed.only;
 
         return selectivityShouldRead(enabled)
-            ? testDependenciesPath + "#" + compression + "#" + disableSelectivityPatterns.join("#")
+            ? lastFailed + "#" + testDependenciesPath + "#" + compression + "#" + disableSelectivityPatterns.join("#")
             : "";
     },
 );

src/config/defaults.js

@@ -132,6 +132,7 @@ module.exports = {
     timeTravel: TimeTravelMode.Off,
     selectivity: {
         enabled: false,
+        saveIncompleteDumpOnFail: false,
         sourceRoot: "",
         testDependenciesPath: ".testplane/selectivity",
         compression: "gz",

src/config/types.ts

@@ -419,6 +419,7 @@ export interface CommonConfig {
 
     selectivity: {
         enabled: SelectivityModeValue;
+        saveIncompleteDumpOnFail: boolean;
         sourceRoot: string;
         testDependenciesPath: string;
         compression: SelectivityCompressionType;

src/test-reader/test-parser.ts

@@ -99,7 +99,7 @@ export class TestParser extends EventEmitter {
                 }
             } catch {
                 logger.warn(
-                    `Could not read failed tests data at ${config.lastFailed.input}. Running all tests instead`,
+                    `Could not read failed tests data at ${config.lastFailed.input}.`,
                 );
             }
         }

src/testplane.ts

@@ -206,10 +206,10 @@ export class Testplane extends BaseTestplane {
             { shouldDisableSelectivity },
         );
 
-        if (!shouldDisableSelectivity && !this.isFailed()) {
+        if (!shouldDisableSelectivity) {
             const [updateResult, clearResult] = await Promise.allSettled([
-                updateSelectivityHashes(this.config),
-                clearUnusedSelectivityDumps(this.config),
+                updateSelectivityHashes(this.config, this.isFailed()),
+                clearUnusedSelectivityDumps(this.config, this.isFailed()),
             ]);
 
             if (updateResult.status === "rejected") {

test/src/browser/cdp/selectivity/hash-writer.ts

@@ -214,24 +214,7 @@ describe("CDP/Selectivity/HashWriter", () => {
             });
         });
 
-        it("should not readHashFileContents when readExisting is false", async () => {
-            const writer = new HashWriter("/test/selectivity", "none");
-            const dependencies = {
-                css: ["src/styles.css"],
-                js: [],
-                modules: [],
-                png: [],
-            };
-
-            fileHashProviderMock.calculateForFile.withArgs("src/styles.css").resolves("css-hash");
-
-            writer.addTestDependencyHashes(dependencies);
-            await writer.save(false);
-
-            assert.notCalled(readHashFileContentsStub);
-        });
-
-        it("should merge staged hashes with existing file contents when readExisting is true", async () => {
+        it("should merge staged hashes with existing file contents", async () => {
             const existingContents = {
                 files: { "src/old.css": "old-hash" },
                 modules: { "node_modules/old-module": "old-module-hash" },
@@ -255,7 +238,7 @@ describe("CDP/Selectivity/HashWriter", () => {
                 .resolves("module-hash");
 
             writer.addTestDependencyHashes(dependencies);
-            await writer.save(true);
+            await writer.save();
 
             assert.calledWith(writeJsonWithCompression, "/test/selectivity/hashes.json", {
                 files: {