fix(selectivity): remove stale test file hashes

Author: KuznetsovRoman

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;
     }

src/browser/cdp/selectivity/index.ts

@@ -1,15 +1,18 @@
+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 { debugSelectivity } from "./debug";
 
 type StopSelectivityFn = (test: Test, shouldWrite: boolean) => Promise<void>;
 
@@ -43,6 +46,71 @@ export const updateSelectivityHashes = async (config: Config): Promise<void> =>
     }
 };
 
+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;

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,7 +208,18 @@ export class Testplane extends BaseTestplane {
         );
 
         if (!shouldDisableSelectivity && !this.isFailed()) {
-            await updateSelectivityHashes(this.config);
+            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) {