Merge pull request #1214 from gemini-testing/TESTPLANE-921.clear_dump_unused

KuznetsovRoman · web-flow · commit 0bc46f69df21 · 2026-03-18T17:58:55.000+03:00
fix(selectivity): ensure selectivity dump has no stale data
diff --git a/src/browser/cdp/selectivity/fs-cache.ts b/src/browser/cdp/selectivity/fs-cache.ts
@@ -1,5 +1,6 @@
 import os from "node:os";
 import path from "node:path";
+import { performance } from "node:perf_hooks";
 import pLimit from "p-limit";
 import lockfile from "proper-lockfile";
 import fs from "fs-extra";
@@ -14,7 +15,6 @@ export const CacheType = {
 type CacheTypeValue = (typeof CacheType)[keyof typeof CacheType];
 
 // Cache is considered fresh if it was created after process start
-const processStartTime = Number(new Date());
 const tmpDir = path.join(os.tmpdir(), SELECTIVITY_CACHE_DIRECTIRY);
 
 // https://nodejs.org/api/cli.html#uv_threadpool_sizesize
@@ -27,7 +27,7 @@ const ensureSelectivityCacheDirectory = async (): Promise<void> => {
 const wasModifiedAfterProcessStart = async (flagFilePath: string): Promise<boolean> => {
     try {
         const stats = await libUVLimited(() => fs.stat(flagFilePath));
-        return stats.mtimeMs >= processStartTime;
+        return stats.mtimeMs >= performance.timeOrigin;
     } catch {
         return false;
     }
diff --git a/src/browser/cdp/selectivity/hash-writer.ts b/src/browser/cdp/selectivity/hash-writer.ts
@@ -1,16 +1,16 @@
 import { memoize } from "lodash";
 import path from "node:path";
 import { HashProvider } from "./hash-provider";
-import { getSelectivityHashesPath, readHashFileContents, shallowSortObject } from "./utils";
+import { getSelectivityHashesPath } from "./utils";
 import { writeJsonWithCompression } from "./json-utils";
-import type { NormalizedDependencies, SelectivityCompressionType } from "./types";
+import type { HashFileContents, NormalizedDependencies, SelectivityCompressionType } from "./types";
 
 export class HashWriter {
     private readonly _hashProvider = new HashProvider();
-    // "null" - successfully writed, "Promise<string>" - file/module hash, "Promise<Error>" - calculating hash error
-    private readonly _stagedFileHashes = new Map<string, null | Promise<string | Error>>();
-    private readonly _stagedModuleHashes = new Map<string, null | Promise<string | Error>>();
-    private readonly _stagedPatternHashes = new Map<string, null | Promise<string | Error>>();
+    // "Promise<string>" - file/module hash, "Promise<Error>" - calculating hash error
+    private readonly _stagedFileHashes = new Map<string, Promise<string | Error>>();
+    private readonly _stagedModuleHashes = new Map<string, Promise<string | Error>>();
+    private readonly _stagedPatternHashes = new Map<string, Promise<string | Error>>();
     private readonly _selectivityHashesPath: string;
     private readonly _compresion: SelectivityCompressionType;
 
@@ -50,8 +50,8 @@ export class HashWriter {
         this._stagedModuleHashes.set(modulePath, value);
     }
 
-    addPatternDependencyHash(dependencyPatterns: string): void {
-        return this._addPatternDependency(dependencyPatterns);
+    addPatternDependencyHash(dependencyPattern: string): void {
+        return this._addPatternDependency(dependencyPattern);
     }
 
     addTestDependencyHashes(dependencies: NormalizedDependencies): void {
@@ -60,7 +60,7 @@ export class HashWriter {
         dependencies.modules.forEach(dependency => this._addModuleDependency(dependency));
     }
 
-    async commit(): Promise<void> {
+    async save(): Promise<void> {
         const hasStaged = Boolean(
             this._stagedFileHashes.size || this._stagedModuleHashes.size || this._stagedPatternHashes.size,
         );
@@ -69,96 +69,34 @@ export class HashWriter {
             return;
         }
 
-        const stagedModuleNames = Array.from(this._stagedModuleHashes.keys());
-        const stagedFileNames = Array.from(this._stagedFileHashes.keys());
-        const stagedPatternNames = Array.from(this._stagedPatternHashes.keys());
-
-        const filterMatchingHashes = async (
-            keys: string[],
-            src: Map<string, null | Promise<string | Error>>,
-            dest: Record<string, string>,
-        ): Promise<string[]> => {
-            const remainingKeys: string[] = [];
-
-            for (const key of keys) {
-                const oldValue = dest[key];
-                const newValue = await src.get(key);
-
-                if (newValue === null) {
-                    continue;
-                }
-
-                if (newValue === oldValue) {
-                    src.set(key, null);
-                } else {
-                    remainingKeys.push(key);
-                }
-            }
-
-            return remainingKeys;
-        };
-
         const writeTo = async (
-            keys: string[],
-            src: Map<string, null | Promise<string | Error>>,
+            src: Map<string, Promise<string | Error>>,
             dest: Record<string, string>,
         ): Promise<void> => {
-            let needsReSort = false;
+            const keys = Array.from(src.keys());
 
             for (const key of keys) {
                 const hash = await src.get(key);
 
-                if (!hash) {
-                    continue;
-                }
-
                 if (hash instanceof Error) {
                     throw hash;
                 }
 
-                needsReSort = needsReSort || !Object.hasOwn(dest, key);
-
-                dest[key] = hash;
-            }
-
-            if (needsReSort) {
-                shallowSortObject(dest);
+                dest[key] = hash as string;
             }
         };
 
-        const markAsCommited = (keys: string[], src: Map<string, null | Promise<string | Error>>): void => {
-            keys.forEach(key => src.set(key, null));
+        const fileContents: HashFileContents = {
+            files: {},
+            modules: {},
+            patterns: {},
         };
 
-        // Waiting for hashes to be calculated before locking file to reduce lock time
-        await Promise.all([
-            ...Object.values(this._stagedFileHashes),
-            ...Object.values(this._stagedModuleHashes),
-            ...Object.values(this._stagedPatternHashes),
-        ]);
-
-        const existingHashesContent = await readHashFileContents(this._selectivityHashesPath, this._compresion);
-
-        const [updatedModules, updatedFiles, updatedPatterns] = await Promise.all([
-            filterMatchingHashes(stagedModuleNames, this._stagedModuleHashes, existingHashesContent.modules),
-            filterMatchingHashes(stagedFileNames, this._stagedFileHashes, existingHashesContent.files),
-            filterMatchingHashes(stagedPatternNames, this._stagedPatternHashes, existingHashesContent.patterns),
-        ]);
-
-        if (!updatedFiles.length && !updatedModules.length && !updatedPatterns.length) {
-            return;
-        }
-
-        await Promise.all([
-            writeTo(updatedModules, this._stagedModuleHashes, existingHashesContent.modules),
-            writeTo(updatedFiles, this._stagedFileHashes, existingHashesContent.files),
-            writeTo(updatedPatterns, this._stagedPatternHashes, existingHashesContent.patterns),
-        ]);
-
-        await writeJsonWithCompression(this._selectivityHashesPath, existingHashesContent, this._compresion);
+        await writeTo(this._stagedFileHashes, fileContents.files);
+        await writeTo(this._stagedModuleHashes, fileContents.modules);
+        await writeTo(this._stagedPatternHashes, fileContents.patterns);
 
-        markAsCommited(updatedModules, this._stagedModuleHashes);
-        markAsCommited(updatedFiles, this._stagedFileHashes);
+        await writeJsonWithCompression(this._selectivityHashesPath, fileContents, this._compresion);
     }
 }
 
diff --git a/src/browser/cdp/selectivity/index.ts b/src/browser/cdp/selectivity/index.ts
@@ -1,16 +1,19 @@
+import path from "node:path";
+import fs from "fs-extra";
 import { CSSSelectivity } from "./css-selectivity";
 import { JSSelectivity } from "./js-selectivity";
 import type { ExistingBrowser } from "../../existing-browser";
 import { getTestDependenciesWriter } from "./test-dependencies-writer";
 import type { Test, TestDepsContext, TestDepsData } from "../../../types";
-import { mergeSourceDependencies, transformSourceDependencies } from "./utils";
+import { getSelectivityTestsPath, mergeSourceDependencies, transformSourceDependencies } from "./utils";
 import { getHashWriter } from "./hash-writer";
 import { Compression } from "./types";
 import { getCollectedTestplaneDependencies } from "./testplane-selectivity";
 import { getHashReader } from "./hash-reader";
 import type { Config } from "../../../config";
 import { MasterEvents } from "../../../events";
 import { selectivityShouldWrite } from "./modes";
+import { debugSelectivity } from "./debug";
 
 type StopSelectivityFn = (test: Test, shouldWrite: boolean) => Promise<void>;
 
@@ -41,13 +44,78 @@ export const updateSelectivityHashes = async (config: Config): Promise<void> =>
         }
 
         try {
-            await hashWriter.commit();
+            await hashWriter.save();
         } catch (cause) {
             throw new Error("Selectivity: couldn't save test dependencies hash", { cause });
         }
     }
 };
 
+export const clearUnusedSelectivityDumps = async (config: Config): Promise<void> => {
+    const browserIds = config.getBrowserIds();
+    const selectivityRoots: string[] = [];
+
+    for (const browserId of browserIds) {
+        const browserConfig = config.forBrowser(browserId);
+        const { enabled, testDependenciesPath } = browserConfig.selectivity;
+
+        if (enabled && !selectivityRoots.includes(testDependenciesPath)) {
+            selectivityRoots.push(testDependenciesPath);
+        }
+    }
+
+    let filesTotal = 0;
+    let filesDeleted = 0;
+
+    // eslint-disable-next-line no-bitwise
+    const rwMode = fs.constants.R_OK | fs.constants.W_OK;
+
+    await Promise.all(
+        selectivityRoots.map(async selectivityRoot => {
+            const testsPath = getSelectivityTestsPath(selectivityRoot);
+            const accessError = await fs.access(testsPath, rwMode).catch((err: Error) => err);
+
+            if (accessError) {
+                if (!("code" in accessError && accessError.code === "ENOENT")) {
+                    debugSelectivity(`Couldn't access "${testsPath}" to clear stale files: %O`, accessError);
+                }
+
+                return;
+            }
+
+            const testsFileNames = await fs.readdir(testsPath);
+
+            filesTotal += testsFileNames.length;
+
+            for (const testFileName of testsFileNames) {
+                const filePath = path.join(testsPath, testFileName);
+                const fileStat = await fs.stat(filePath).catch(() => null);
+
+                if (!fileStat) {
+                    debugSelectivity(`Couldn't access file "${filePath}" to check if it was used. Skipping`);
+                    continue;
+                }
+
+                // File was not used in this run
+                if (fileStat.atimeMs < performance.timeOrigin && fileStat.isFile()) {
+                    await fs
+                        .unlink(filePath)
+                        .then(() => {
+                            filesDeleted++;
+                        })
+                        .catch(err => {
+                            debugSelectivity(`Couldn't remove stale file "${filePath}": %O`, err);
+                        });
+                }
+            }
+        }),
+    );
+
+    if (filesDeleted) {
+        debugSelectivity(`Out of ${filesTotal} files, ${filesDeleted} were considered as outdated and deleted`);
+    }
+};
+
 export const startSelectivity = async (browser: ExistingBrowser): Promise<StopSelectivityFn> => {
     const { enabled, compression, sourceRoot, testDependenciesPath, mapDependencyRelativePath } =
         browser.config.selectivity;
diff --git a/src/testplane.ts b/src/testplane.ts
@@ -18,7 +18,7 @@ import { initDevServer } from "./dev-server";
 import { ConfigInput } from "./config/types";
 import { MasterEventHandler, Test, TestResult } from "./types";
 import { preloadWebdriverIO } from "./utils/preload-utils";
-import { updateSelectivityHashes } from "./browser/cdp/selectivity";
+import { clearUnusedSelectivityDumps, updateSelectivityHashes } from "./browser/cdp/selectivity";
 import { TagFilter } from "./utils/cli";
 import { ViteServer } from "./runner/browser-env/vite/server";
 import { getGlobalFilesToRemove, initGlobalFilesToRemove } from "./globalFilesToRemove";
@@ -208,9 +208,18 @@ export class Testplane extends BaseTestplane {
         );
 
         if (!shouldDisableSelectivity && !this.isFailed()) {
-            await updateSelectivityHashes(this.config).catch(err => {
-                console.error("Skipping selectivity state update because of an error:", err);
-            });
+            const [updateResult, clearResult] = await Promise.allSettled([
+                updateSelectivityHashes(this.config),
+                clearUnusedSelectivityDumps(this.config),
+            ]);
+
+            if (updateResult.status === "rejected") {
+                console.error("Couldn't update selectivity state: ", updateResult.reason);
+            }
+
+            if (clearResult.status === "rejected") {
+                console.error("Couldn't clear stale selectivity files: ", clearResult.reason);
+            }
         }
 
         if (this.config.afterAll) {
diff --git a/test/src/browser/cdp/selectivity/hash-writer.ts b/test/src/browser/cdp/selectivity/hash-writer.ts
diff --git a/test/src/browser/cdp/selectivity/index.ts b/test/src/browser/cdp/selectivity/index.ts
