@react-native-harness/jest 1.1.0-rc.2 → 1.1.0-rc.4

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

@@ -0,0 +1,192 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it, vi } 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();
+  });
+
+  it('keeps owner metadata valid when heartbeat writes overlap', async () => {
+    const manager = createResourceLockManager({
+      rootDir,
+      pollIntervalMs: 5,
+      heartbeatIntervalMs: 10,
+      staleLockTimeoutMs: 200,
+    });
+    const key = 'ios:simulator:iPhone 17 Pro:26.2';
+    const ownerFilePath = path.join(
+      rootDir,
+      hashResourceLockKey(key),
+      'owner.json',
+    );
+    const actualWriteFile = fs.writeFile.bind(fs);
+    const writeFileSpy = vi
+      .spyOn(fs, 'writeFile')
+      .mockImplementation(async (file, data, options) => {
+        if (
+          typeof file === 'string' &&
+          file.startsWith(ownerFilePath) &&
+          file !== ownerFilePath
+        ) {
+          await new Promise((resolve) => setTimeout(resolve, 25));
+        }
+
+        return await actualWriteFile(file, data, options);
+      });
+
+    try {
+      const lease = await manager.acquire(key);
+      const initialOwner = JSON.parse(
+        await fs.readFile(ownerFilePath, 'utf8'),
+      ) as ResourceLockOwner;
+
+      await new Promise((resolve) => setTimeout(resolve, 80));
+
+      for (let index = 0; index < 5; index += 1) {
+        const owner = JSON.parse(
+          await fs.readFile(ownerFilePath, 'utf8'),
+        ) as ResourceLockOwner;
+        expect(owner.ticketId).toBe(initialOwner.ticketId);
+        await new Promise((resolve) => setTimeout(resolve, 10));
+      }
+
+      await lease.release();
+    } finally {
+      writeFileSpy.mockRestore();
+    }
+  });
+});
+
+type ResourceLockOwner = {
+  ticketId: string;
+};

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/errors.ts

@@ -27,6 +27,28 @@ 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 class MetroPortRangeExhaustedError extends HarnessError {
+  constructor(
+    public readonly initialPort: number,
+    public readonly attempts: number
+  ) {
+    const finalPort = initialPort + attempts - 1;
+    super(
+      `Harness could not find an available Metro port in the range ${initialPort}-${finalPort}.`
+    );
+    this.name = 'MetroPortRangeExhaustedError';
+  }
+}
+
 export type NativeCrashPhase = 'startup' | 'execution';
 
 export type NativeCrashDetails = AppCrashDetails & {
@@ -51,10 +73,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('');