@react-native-harness/jest 1.1.0-rc.1 → 1.1.0-rc.3

package/src/__tests__/index.test.ts

@@ -0,0 +1,61 @@
+import { describe, expect, it, vi } from 'vitest';
+import type { Harness } from '../harness.js';
+import type { Config as HarnessConfig } from '@react-native-harness/config';
+import type { Config, Test, TestWatcher } from 'jest-runner';
+import JestHarness from '../index.js';
+import { StartupStallError } from '../errors.js';
+
+describe('JestHarness', () => {
+  it('reports StartupStallError without a stack trace', async () => {
+    const runner = new JestHarness({} as Config.GlobalConfig);
+    const onFailure = vi.fn();
+
+    const harness = {
+      ensureAppReady: vi
+        .fn()
+        .mockRejectedValue(new StartupStallError(1500, 3)),
+      callHook: vi.fn(async () => undefined),
+      setRunState: vi.fn(),
+      getRunState: vi.fn(() => null),
+      crashSupervisor: {
+        beginTestRun: vi.fn(),
+        waitForCrash: vi.fn(),
+        cancelCrashWaiters: vi.fn(),
+        reset: vi.fn(),
+      },
+    } as unknown as Harness;
+
+    await runner._createInBandTestRun(
+      [
+        {
+          path: '/tmp/example.harness.ts',
+          context: {
+            config: {},
+          },
+        } as Test,
+      ],
+      {
+        isInterrupted: () => false,
+      } as TestWatcher,
+      harness,
+      {
+        detectNativeCrashes: true,
+        resetEnvironmentBetweenTestFiles: false,
+      } as HarnessConfig,
+      () => Promise.resolve(),
+      () => Promise.resolve(),
+      onFailure
+    );
+
+    expect(onFailure).toHaveBeenCalledWith(
+      expect.objectContaining({
+        path: '/tmp/example.harness.ts',
+      }),
+      {
+        message:
+          'The app did not request its Metro bundle after 3 launch attempts within 1500ms. Last Metro status: unknown.',
+        stack: '',
+      }
+    );
+  });
+});

package/src/__tests__/resource-lock.test.ts

@@ -0,0 +1,138 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import {
+  createResourceLockManager,
+  hashResourceLockKey,
+} from '../resource-lock.js';
+
+describe('resource lock manager', () => {
+  let rootDir: string;
+
+  beforeEach(async () => {
+    rootDir = await fs.mkdtemp(
+      path.join(os.tmpdir(), 'react-native-harness-resource-lock-test-')
+    );
+  });
+
+  afterEach(async () => {
+    await fs.rm(rootDir, { recursive: true, force: true });
+  });
+
+  it('queues access in FIFO order', async () => {
+    const manager = createResourceLockManager({
+      rootDir,
+      pollIntervalMs: 5,
+      heartbeatIntervalMs: 20,
+      staleLockTimeoutMs: 200,
+    });
+    const order: string[] = [];
+
+    const firstLease = await manager.acquire(
+      'ios:simulator:iPhone 17 Pro:26.2'
+    );
+    const secondAcquire = manager
+      .acquire('ios:simulator:iPhone 17 Pro:26.2', {
+        onWait: () => {
+          order.push('waiting');
+        },
+      })
+      .then(async (lease) => {
+        order.push('acquired');
+        await lease.release();
+      });
+
+    await new Promise((resolve) => setTimeout(resolve, 30));
+    expect(order).toEqual(['waiting']);
+
+    await firstLease.release();
+    await secondAcquire;
+
+    expect(order).toEqual(['waiting', 'acquired']);
+  });
+
+  it('removes the queued ticket when waiting is aborted', async () => {
+    const manager = createResourceLockManager({
+      rootDir,
+      pollIntervalMs: 5,
+      heartbeatIntervalMs: 20,
+      staleLockTimeoutMs: 200,
+    });
+    const key = 'android:emulator:Pixel_8_API_35';
+    const firstLease = await manager.acquire(key);
+    const controller = new AbortController();
+
+    const acquirePromise = manager.acquire(key, {
+      signal: controller.signal,
+    });
+
+    await new Promise((resolve) => setTimeout(resolve, 30));
+    controller.abort();
+
+    await expect(acquirePromise).rejects.toMatchObject({
+      name: 'AbortError',
+    });
+
+    const queueDir = path.join(rootDir, hashResourceLockKey(key), 'queue');
+    const queuedEntries = await fs.readdir(queueDir);
+    expect(queuedEntries).toHaveLength(0);
+
+    await firstLease.release();
+  });
+
+  it('keeps queued tickets alive while the waiting process is still active', async () => {
+    const manager = createResourceLockManager({
+      rootDir,
+      pollIntervalMs: 5,
+      heartbeatIntervalMs: 20,
+      staleLockTimeoutMs: 30,
+      isProcessActive: () => true,
+    });
+    const key = 'ios:simulator:iPhone 17 Pro:26.2';
+    const firstLease = await manager.acquire(key);
+
+    const secondAcquire = manager.acquire(key);
+
+    await new Promise((resolve) => setTimeout(resolve, 80));
+
+    await firstLease.release();
+    const secondLease = await secondAcquire;
+    await secondLease.release();
+  });
+
+  it('reclaims a stale owner before granting the lock', async () => {
+    const manager = createResourceLockManager({
+      rootDir,
+      pollIntervalMs: 5,
+      heartbeatIntervalMs: 20,
+      staleLockTimeoutMs: 50,
+      isProcessActive: () => false,
+    });
+    const key = 'web:browser:chromium';
+    const keyDir = path.join(rootDir, hashResourceLockKey(key));
+    const queueDir = path.join(keyDir, 'queue');
+    const ownerFilePath = path.join(keyDir, 'owner.json');
+
+    await fs.mkdir(queueDir, { recursive: true });
+    await fs.writeFile(
+      ownerFilePath,
+      JSON.stringify({
+        ticketId: 'stale-owner',
+        key,
+        pid: 999999,
+        createdAt: Date.now() - 1000,
+        heartbeatAt: Date.now() - 1000,
+      }),
+      'utf8'
+    );
+
+    const lease = await manager.acquire(key);
+    const owner = JSON.parse(await fs.readFile(ownerFilePath, 'utf8')) as {
+      ticketId: string;
+    };
+    expect(owner.ticketId).not.toBe('stale-owner');
+
+    await lease.release();
+  });
+});

package/src/action-hooks.ts

@@ -0,0 +1,66 @@
+import {
+  definePlugin,
+  type HarnessPlugin,
+} from '@react-native-harness/plugins';
+import type { Config as HarnessConfig } from '@react-native-harness/config';
+import type { HarnessPlatform } from '@react-native-harness/platforms';
+import { spawn } from '@react-native-harness/tools';
+
+type ActionHookState = {
+  _unused?: never;
+};
+
+const getInlineHookScript = (
+  name: 'PRE_RUN_HOOK' | 'AFTER_RUN_HOOK'
+): string | null => {
+  const value = process.env[name]?.trim();
+
+  return value ? value : null;
+};
+
+const runInlineHook = async (script: string): Promise<void> => {
+  const env = Object.fromEntries(
+    Object.entries(process.env).filter(
+      (entry): entry is [string, string] => entry[1] != null
+    )
+  );
+
+  await spawn('bash', ['-lc', script], {
+    env,
+    cwd: process.env.HARNESS_PROJECT_ROOT,
+  });
+};
+
+export const createActionHooksPlugin = (): HarnessPlugin<
+  ActionHookState,
+  HarnessConfig,
+  HarnessPlatform
+> =>
+  definePlugin({
+    name: 'github-action-hooks',
+    createState: () => ({}),
+    hooks: {
+      harness: {
+        beforeRun: async () => {
+          const script = getInlineHookScript('PRE_RUN_HOOK');
+
+          if (!script) {
+            return;
+          }
+
+          await runInlineHook(script);
+        },
+        afterRun: async (ctx) => {
+          const script = getInlineHookScript('AFTER_RUN_HOOK');
+
+          if (!script) {
+            return;
+          }
+
+          process.env.HARNESS_EXIT_CODE = ctx.status === 'passed' ? '0' : '1';
+
+          await runInlineHook(script);
+        },
+      },
+    },
+  });

package/src/cli-args.ts

@@ -3,6 +3,7 @@ import { hideBin } from 'yargs/helpers';
 
 export type HarnessCliArgs = {
   harnessRunner?: string;
+  metroPort?: number;
 };
 
 export const getAdditionalCliArgs = (): HarnessCliArgs => {
@@ -11,6 +12,10 @@ export const getAdditionalCliArgs = (): HarnessCliArgs => {
       type: 'string',
       description: 'Specify which Harness runner to use',
     })
+    .option('metroPort', {
+      type: 'number',
+      description: 'Override the Metro bundler port',
+    })
     .strict(false)
     .help(false)
     .version(false)
@@ -19,5 +24,6 @@ export const getAdditionalCliArgs = (): HarnessCliArgs => {
 
   return {
     harnessRunner: argv.harnessRunner,
+    metroPort: argv.metroPort,
   };
 };

package/src/crash-supervisor.ts

@@ -12,6 +12,8 @@ import {
 } from './errors.js';
 import { logger } from '@react-native-harness/tools';
 
+const crashLogger = logger.child('crash');
+
 export type CrashSupervisorState =
   | 'idle'
   | 'launching'
@@ -113,15 +115,20 @@ export const createCrashSupervisor = ({
     }
 
     if (!activeTestFilePath) {
-      logger.debug(`Ignoring crash signal without active test: ${reason}`);
+      crashLogger.debug('ignoring crash signal without active test: %s', reason);
       return;
     }
 
     isResolvingCrash = true;
-    logger.debug(`Native crash detected during ${activeTestFilePath} (state: ${state}, reason: ${reason || '(none)'})`);
+    crashLogger.debug(
+      'native crash detected during %s (state=%s reason=%s)',
+      activeTestFilePath,
+      state,
+      reason || '(none)'
+    );
 
     for (const line of details?.rawLines ?? []) {
-      logger.debug(line);
+      crashLogger.debug('%s', line);
     }
 
     const phase = getCrashPhase(state);
@@ -136,7 +143,7 @@ export const createCrashSupervisor = ({
       });
 
       const mergedDetails = mergeCrashDetails(phase, details, enrichedDetails, reason);
-      logger.debug('Crash details:', {
+      crashLogger.debug('crash details: %o', {
         phase: mergedDetails.phase,
         source: mergedDetails.source,
         summary: mergedDetails.summary,
@@ -160,10 +167,10 @@ export const createCrashSupervisor = ({
       const isRunning = await platformRunner.isAppRunning();
 
       if (!isRunning) {
-        handleCrash(reason, details);
+        void handleCrash(reason, details);
       }
     } catch (error) {
-      logger.debug('Crash confirmation failed', error);
+      crashLogger.debug('crash confirmation failed', error);
     }
   };
 

package/src/env.d.ts

@@ -1,4 +1,4 @@
-import type { Harness } from '@react-native-harness/cli/external';
+import type { Harness } from './harness.js';
 import type { Config as HarnessConfig } from '@react-native-harness/config';
 
 declare global {

package/src/errors.ts

@@ -1,5 +1,10 @@
 import { HarnessError } from '@react-native-harness/tools';
 import type { AppCrashDetails } from '@react-native-harness/platforms';
+export {
+  StartupStallError,
+  type StartupStallCode,
+  type StartupStallDetails,
+} from '@react-native-harness/bundler-metro';
 
 export class NoRunnerSpecifiedError extends HarnessError {
   constructor() {
@@ -22,6 +27,15 @@ export class InitializationTimeoutError extends HarnessError {
   }
 }
 
+export class PlatformReadyTimeoutError extends HarnessError {
+  constructor(public readonly timeout: number) {
+    super(
+      `The platform did not become ready within ${timeout}ms. Increase "platformReadyTimeout" if your device, simulator, or emulator needs more time to start.`
+    );
+    this.name = 'PlatformReadyTimeoutError';
+  }
+}
+
 export type NativeCrashPhase = 'startup' | 'execution';
 
 export type NativeCrashDetails = AppCrashDetails & {
@@ -46,10 +60,7 @@ const buildNativeCrashMessage = ({
   const hasCrashBlock = summary?.includes('\n') ?? false;
   const shouldRenderSummary =
     Boolean(summary) &&
-    !(
-      !hasCrashBlock &&
-      artifactType === 'ios-crash-report'
-    );
+    !(!hasCrashBlock && artifactType === 'ios-crash-report');
 
   if (shouldRenderSummary && summary) {
     lines.push('');