@react-native-harness/jest 1.5.0 → 1.7.0

package/src/resource-lock.ts

@@ -89,6 +89,37 @@ const isMissingFileError = (error: unknown): boolean => {
   );
 };
 
+// On Windows, a file being deleted by another process can briefly fail
+// reads and deletes with EPERM/EBUSY instead of ENOENT.
+const isTransientFsError = (error: unknown): boolean => {
+  return (
+    error instanceof Error &&
+    'code' in error &&
+    (error.code === 'EPERM' || error.code === 'EBUSY')
+  );
+};
+
+const TRANSIENT_FS_RETRIES = 5;
+const TRANSIENT_FS_RETRY_DELAY_MS = 20;
+
+const retryTransientFsError = async <T>(
+  operation: () => Promise<T>,
+): Promise<T> => {
+  for (let attempt = 1; ; attempt += 1) {
+    try {
+      return await operation();
+    } catch (error) {
+      if (!isTransientFsError(error) || attempt >= TRANSIENT_FS_RETRIES) {
+        throw error;
+      }
+
+      await new Promise((resolve) =>
+        setTimeout(resolve, TRANSIENT_FS_RETRY_DELAY_MS),
+      );
+    }
+  }
+};
+
 const isExclusiveCreateError = (error: unknown): boolean => {
   return (
     error instanceof Error &&
@@ -104,7 +135,9 @@ const ensureLockDirectories = async (paths: LockPaths): Promise<void> => {
 
 const readJsonFile = async <T>(filePath: string): Promise<T | null> => {
   try {
-    const content = await fs.readFile(filePath, 'utf8');
+    const content = await retryTransientFsError(() =>
+      fs.readFile(filePath, 'utf8'),
+    );
     return JSON.parse(content) as T;
   } catch (error) {
     if (isMissingFileError(error)) {
@@ -132,7 +165,7 @@ const writeJsonFileAtomic = async <T>(
 
 const removeFileIfPresent = async (filePath: string): Promise<void> => {
   try {
-    await fs.rm(filePath, { force: true });
+    await retryTransientFsError(() => fs.rm(filePath, { force: true }));
   } catch (error) {
     if (!isMissingFileError(error)) {
       throw error;
@@ -338,7 +371,7 @@ export const createResourceLockManager = (
       scopedLogger.debug('queued ticket %s for key %s', ticketId, key);
 
       let heartbeatTimer: NodeJS.Timeout | null = null;
-      let heartbeatInFlight = false;
+      let heartbeatInFlight: Promise<void> | null = null;
       let released = false;
       let didNotifyWait = false;
       const waitStartedAt = Date.now();
@@ -354,6 +387,10 @@ export const createResourceLockManager = (
           heartbeatTimer = null;
         }
 
+        // Let an in-flight refresh finish so it cannot recreate owner.json
+        // after we remove it.
+        await heartbeatInFlight;
+
         const owner = await readJsonFile<ResourceLockMetadata>(
           paths.ownerFilePath,
         );
@@ -366,13 +403,7 @@ export const createResourceLockManager = (
       };
 
       const startHeartbeat = () => {
-        heartbeatTimer = setInterval(async () => {
-          if (heartbeatInFlight) {
-            return;
-          }
-
-          heartbeatInFlight = true;
-
+        const refreshHeartbeat = async () => {
           try {
             const nextHeartbeatAt = Date.now();
             const owner = await readJsonFile<ResourceLockMetadata>(
@@ -383,33 +414,33 @@ export const createResourceLockManager = (
               return;
             }
 
-            const nextMetadata: ResourceLockMetadata = {
+            await writeJsonFileAtomic(paths.ownerFilePath, {
               ...owner,
               heartbeatAt: nextHeartbeatAt,
-            };
-
-            if (released) {
-              return;
-            }
+            });
+            scopedLogger.debug('refreshed heartbeat for ticket %s', ticketId);
+          } catch (error) {
+            // A failed refresh is not fatal by design: the lock goes stale
+            // and another holder reclaims it. Swallow it so a transient
+            // error (e.g. the owner file racing a concurrent release, or an
+            // EPERM on Windows while a file is being deleted) never surfaces
+            // as an unhandled rejection from this interval.
+            scopedLogger.debug(
+              'heartbeat refresh for ticket %s failed: %s',
+              ticketId,
+              error instanceof Error ? error.message : String(error),
+            );
+          }
+        };
 
-            try {
-              await writeJsonFileAtomic(paths.ownerFilePath, nextMetadata);
-              scopedLogger.debug('refreshed heartbeat for ticket %s', ticketId);
-            } catch (error) {
-              // A failed refresh is not fatal by design: the lock goes stale
-              // and another holder reclaims it. Swallow it so a transient
-              // write error (e.g. the owner file racing a concurrent release,
-              // or an EPERM on Windows when the directory is being torn down)
-              // never surfaces as an unhandled rejection from this interval.
-              scopedLogger.debug(
-                'heartbeat refresh for ticket %s failed: %s',
-                ticketId,
-                error instanceof Error ? error.message : String(error),
-              );
-            }
-          } finally {
-            heartbeatInFlight = false;
+        heartbeatTimer = setInterval(() => {
+          if (heartbeatInFlight) {
+            return;
           }
+
+          heartbeatInFlight = refreshHeartbeat().finally(() => {
+            heartbeatInFlight = null;
+          });
         }, heartbeatIntervalMs);
         heartbeatTimer.unref?.();
       };

package/src/run.ts

@@ -1,4 +1,3 @@
-import path from 'node:path';
 import type { Config as JestConfig } from 'jest-runner';
 import { TestResult as JestTestResult } from '@jest/test-result';
 import type {
@@ -9,6 +8,7 @@ import type { HarnessSession } from './harness-session.js';
 import { formatResultsErrors } from 'jest-message-util';
 import { toTestResult } from './toTestResult.js';
 import { formatHarnessErrorMessage } from './format-harness-error.js';
+import { toRelativePosixPath } from './relative-path.js';
 
 // Helper function to flatten nested test suites into a flat array of tests with hierarchy
 const flattenTests = (
@@ -91,14 +91,14 @@ export const runHarnessTestFile: RunHarnessTestFile = async ({
   session,
 }) => {
   const start = Date.now();
-  const relativeTestPath = path.relative(globalConfig.rootDir, testPath);
+  const relativeTestPath = toRelativePosixPath(globalConfig.rootDir, testPath);
 
   // Extract setup files from Jest config and convert to relative paths
   const setupFiles = projectConfig.setupFiles?.map((setupFile) =>
-    path.relative(globalConfig.rootDir, setupFile)
+    toRelativePosixPath(globalConfig.rootDir, setupFile)
   );
   const setupFilesAfterEnv = projectConfig.setupFilesAfterEnv?.map(
-    (setupFile) => path.relative(globalConfig.rootDir, setupFile)
+    (setupFile) => toRelativePosixPath(globalConfig.rootDir, setupFile)
   );
   const testTimeout =
     session.config.testTimeout ??

package/src/watch-session.ts

@@ -0,0 +1,65 @@
+import type { Config } from 'jest-runner';
+import {
+  createHarnessSession,
+  type HarnessSession,
+} from './harness-session.js';
+
+// Jest constructs a new runner (and scheduler) for every watch-mode run, so a
+// per-instance session would leave the previous run's session holding the
+// resource lock while the next run queues behind it. Watch-mode sessions
+// therefore live at module scope and are shared by all runner instances.
+//
+// There is no explicit teardown here: in interactive watch mode Jest exits
+// via process.exit on Ctrl-C / `q`, which does not dispose the session. The
+// lock is reclaimed by the lock manager's pid / stale-owner detection.
+type WatchSessionEntry = {
+  key: string;
+  promise: Promise<HarnessSession>;
+};
+
+let current: WatchSessionEntry | null = null;
+
+// Everything createHarnessSession reads from the Jest config.
+const getSessionKey = (globalConfig: Config.GlobalConfig): string =>
+  JSON.stringify([globalConfig.rootDir, Boolean(globalConfig.collectCoverage)]);
+
+export const getWatchSession = (
+  globalConfig: Config.GlobalConfig
+): Promise<HarnessSession> => {
+  const key = getSessionKey(globalConfig);
+
+  if (current?.key === key) {
+    return current.promise;
+  }
+
+  const stale = current;
+  // The entry is installed synchronously so concurrent callers share it, even
+  // while a stale session is still being disposed.
+  const entry: WatchSessionEntry = {
+    key,
+    promise: (async () => {
+      if (stale) {
+        // A failed disposal must not fail the run.
+        await stale.promise
+          .then((session) => session.dispose())
+          .catch(() => undefined);
+      }
+      return createHarnessSession(globalConfig);
+    })(),
+  };
+  current = entry;
+
+  // Never cache a failed creation; the next run retries.
+  entry.promise.catch(() => {
+    if (current === entry) {
+      current = null;
+    }
+  });
+
+  return entry.promise;
+};
+
+/** @internal Test-only: forget the module-level session without disposing. */
+export const resetWatchSessionForTests = (): void => {
+  current = null;
+};