@react-native-harness/jest 1.4.0-rc.1 → 1.4.1

package/src/__tests__/harness-session.test.ts

@@ -1,93 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import type { AppConnection } from '@react-native-harness/bridge/server';
-import {
-  waitForBridgeDisconnectOrTimeout,
-  waitForStartupCrash,
-} from '../harness-session.js';
-import type { CrashMonitor } from '../crash-monitor.js';
-
-const createConnection = (): AppConnection => ({
-  device: {
-    platform: 'ios',
-    manufacturer: 'Apple',
-    model: 'iPhone',
-    osVersion: '18.0',
-  },
-  runTests: vi.fn(),
-});
-
-const createBridge = (connection: AppConnection | null) => {
-  let currentConnection = connection;
-  let disconnectedListener: (() => void) | null = null;
-
-  return {
-    get connection() {
-      return currentConnection;
-    },
-    on: vi.fn((event: 'disconnected', listener: () => void) => {
-      if (event === 'disconnected') {
-        disconnectedListener = listener;
-      }
-    }),
-    off: vi.fn((event: 'disconnected', listener: () => void) => {
-      if (event === 'disconnected' && disconnectedListener === listener) {
-        disconnectedListener = null;
-      }
-    }),
-    disconnect: () => {
-      currentConnection = null;
-      disconnectedListener?.();
-    },
-  };
-};
-
-describe('waitForBridgeDisconnectOrTimeout', () => {
-  it('returns true when the bridge disconnects before the timeout', async () => {
-    const connection = createConnection();
-    const bridge = createBridge(connection);
-
-    const waitPromise = waitForBridgeDisconnectOrTimeout({
-      bridge,
-      connection,
-      timeoutMs: 50,
-    });
-
-    bridge.disconnect();
-
-    await expect(waitPromise).resolves.toBe(true);
-  });
-
-  it('returns false when the bridge stays connected through the timeout', async () => {
-    const connection = createConnection();
-    const bridge = createBridge(connection);
-
-    await expect(
-      waitForBridgeDisconnectOrTimeout({
-        bridge,
-        connection,
-        timeoutMs: 10,
-      }),
-    ).resolves.toBe(false);
-  });
-});
-
-describe('waitForStartupCrash', () => {
-  it('does not install a startup crash watch when native crash detection is disabled', async () => {
-    const watch = vi.fn();
-    const crashMonitor = {
-      watch,
-    } as unknown as CrashMonitor;
-    const controller = new AbortController();
-    const waitPromise = waitForStartupCrash({
-      crashMonitor,
-      detectNativeCrashes: false,
-      testFilePath: '/test.harness.ts',
-      signal: controller.signal,
-    });
-
-    controller.abort(new DOMException('Aborted', 'AbortError'));
-
-    await expect(waitPromise).rejects.toThrow('Aborted');
-    expect(watch).not.toHaveBeenCalled();
-  });
-});

package/src/__tests__/hook-queue.test.ts

@@ -1,77 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { createHookQueue } from '../hook-queue.js';
-
-describe('createHookQueue', () => {
-  it('executes scheduled work in FIFO order', async () => {
-    const queue = createHookQueue();
-    const order: number[] = [];
-
-    queue.schedule(async () => { order.push(1); });
-    queue.schedule(async () => { order.push(2); });
-    queue.schedule(async () => { order.push(3); });
-
-    await queue.drain();
-
-    expect(order).toEqual([1, 2, 3]);
-  });
-
-  it('drain awaits async work before resolving', async () => {
-    const queue = createHookQueue();
-    let resolved = false;
-
-    queue.schedule(async () => {
-      await new Promise<void>((r) => setTimeout(r, 20));
-      resolved = true;
-    });
-
-    expect(resolved).toBe(false);
-    await queue.drain();
-    expect(resolved).toBe(true);
-  });
-
-  it('drain resolves immediately when nothing is scheduled', async () => {
-    const queue = createHookQueue();
-    await expect(queue.drain()).resolves.toBeUndefined();
-  });
-
-  it('captures the first error and re-throws it on drain', async () => {
-    const queue = createHookQueue();
-    const err = new Error('hook failed');
-
-    queue.schedule(async () => { throw err; });
-
-    await expect(queue.drain()).rejects.toBe(err);
-  });
-
-  it('continues executing subsequent hooks after one throws', async () => {
-    const queue = createHookQueue();
-    const ran: string[] = [];
-
-    queue.schedule(async () => { throw new Error('first'); });
-    queue.schedule(async () => { ran.push('second'); });
-    queue.schedule(async () => { ran.push('third'); });
-
-    await expect(queue.drain()).rejects.toThrow('first');
-
-    expect(ran).toEqual(['second', 'third']);
-  });
-
-  it('error is cleared after drain re-throws it', async () => {
-    const queue = createHookQueue();
-
-    queue.schedule(async () => { throw new Error('once'); });
-    await expect(queue.drain()).rejects.toThrow('once');
-
-    // Second drain should see no accumulated error.
-    await expect(queue.drain()).resolves.toBeUndefined();
-  });
-
-  it('surfaces only the first error when multiple hooks throw', async () => {
-    const queue = createHookQueue();
-
-    queue.schedule(async () => { throw new Error('first'); });
-    queue.schedule(async () => { throw new Error('second'); });
-
-    await expect(queue.drain()).rejects.toThrow('first');
-  });
-});

package/src/__tests__/index.test.ts

@@ -1,219 +0,0 @@
-import { describe, expect, it, vi, beforeEach } from 'vitest';
-import type { Config, Test, TestEvents, TestRunnerOptions, TestWatcher } from 'jest-runner';
-import type { TestSuiteResult } from '@react-native-harness/bridge';
-import type { HarnessSession } from '../harness-session.js';
-import type { executeRun as ExecuteRun } from '../execute-run.js';
-import { HarnessError } from '@react-native-harness/tools';
-import JestHarness from '../index.js';
-
-const resolveUndefined = async () => undefined;
-
-// ---------------------------------------------------------------------------
-// Module mocks
-// ---------------------------------------------------------------------------
-
-const mockSession: HarnessSession = {
-  config: { metroPort: 8081 } as HarnessSession['config'],
-  context: {} as HarnessSession['context'],
-  onTestRunnerEvent: vi.fn(() => () => undefined),
-  ensureAppReady: vi.fn(resolveUndefined),
-  runTestFile: vi.fn(async (): Promise<TestSuiteResult> => ({
-    name: '',
-    tests: [],
-    suites: [],
-    status: 'passed',
-    duration: 0,
-  })),
-  restartApp: vi.fn(resolveUndefined),
-  resetCrashState: vi.fn(),
-  flushClientLogs: vi.fn(() => []),
-  callHook: vi.fn(resolveUndefined),
-  setRunState: vi.fn(),
-  dispose: vi.fn(resolveUndefined),
-};
-
-const mockCreateHarnessSession = vi.hoisted(() => vi.fn(async () => mockSession));
-const mockExecuteRun = vi.hoisted(() => vi.fn(async () => undefined));
-
-vi.mock('../harness-session.js', () => ({
-  createHarnessSession: mockCreateHarnessSession,
-}));
-
-vi.mock('../execute-run.js', () => ({
-  executeRun: mockExecuteRun,
-}));
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-const makeOptions = (): TestRunnerOptions => ({ serial: true });
-const makeWatcher = (): TestWatcher => ({ isInterrupted: () => false } as TestWatcher);
-const makeTest = (): Test => ({
-  path: '/test/example.ts',
-  context: { config: {} as Config.ProjectConfig },
-} as Test);
-
-const makeGlobalConfig = (overrides: Partial<Config.GlobalConfig> = {}): Config.GlobalConfig =>
-  ({ rootDir: '/project', watch: false, watchAll: false, collectCoverage: false, ...overrides } as Config.GlobalConfig);
-
-type ExecuteRunMock = typeof ExecuteRun;
-type TypedExecuteRunMock = typeof mockExecuteRun & {
-  mockImplementationOnce: (implementation: ExecuteRunMock) => typeof mockExecuteRun;
-  mockResolvedValue: (value: Awaited<ReturnType<ExecuteRunMock>>) => typeof mockExecuteRun;
-};
-type ExecuteRunParams = Parameters<ExecuteRunMock>;
-
-const typedMockExecuteRun = mockExecuteRun as TypedExecuteRunMock;
-
-const makeTestCaseStartPayload = (): TestEvents['test-case-start'] => [
-  '/test/example.ts',
-  {
-    ancestorTitles: [],
-    fullName: 'suite case',
-    mode: undefined,
-    title: 'case',
-    startedAt: 1,
-  },
-];
-
-const makeTestCaseResultPayload = (): TestEvents['test-case-result'] => [
-  '/test/example.ts',
-  {
-    ancestorTitles: [],
-    duration: 1,
-    failureDetails: [],
-    failureMessages: [],
-    fullName: 'suite case',
-    numPassingAsserts: 1,
-    startedAt: 1,
-    status: 'passed',
-    title: 'case',
-  },
-];
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-beforeEach(() => {
-  vi.clearAllMocks();
-  (mockSession.dispose as ReturnType<typeof vi.fn>).mockResolvedValue(undefined);
-  typedMockExecuteRun.mockResolvedValue(undefined);
-  mockCreateHarnessSession.mockResolvedValue(mockSession);
-});
-
-describe('JestHarness', () => {
-  describe('session lifecycle', () => {
-    it('creates a session on the first run', async () => {
-      const runner = new JestHarness(makeGlobalConfig());
-
-      await runner.runTests([makeTest()], makeWatcher(), makeOptions());
-
-      expect(mockCreateHarnessSession).toHaveBeenCalledOnce();
-    });
-
-    it('reuses the session across runs in watch mode', async () => {
-      const runner = new JestHarness(makeGlobalConfig({ watch: true }));
-
-      await runner.runTests([makeTest()], makeWatcher(), makeOptions());
-      await runner.runTests([makeTest()], makeWatcher(), makeOptions());
-
-      expect(mockCreateHarnessSession).toHaveBeenCalledOnce();
-      expect(mockSession.dispose).not.toHaveBeenCalled();
-    });
-
-    it('disposes the session after each run in normal mode', async () => {
-      const runner = new JestHarness(makeGlobalConfig());
-
-      await runner.runTests([makeTest()], makeWatcher(), makeOptions());
-
-      expect(mockSession.dispose).toHaveBeenCalledOnce();
-    });
-
-    it('creates a fresh session for each run in normal mode', async () => {
-      const runner = new JestHarness(makeGlobalConfig());
-
-      await runner.runTests([makeTest()], makeWatcher(), makeOptions());
-      await runner.runTests([makeTest()], makeWatcher(), makeOptions());
-
-      expect(mockCreateHarnessSession).toHaveBeenCalledTimes(2);
-    });
-
-    it('emits registered Jest events', async () => {
-      const runner = new JestHarness(makeGlobalConfig());
-      const listener = vi.fn();
-      const eventPayload = makeTestCaseStartPayload();
-
-      runner.on('test-case-start', listener);
-      typedMockExecuteRun.mockImplementationOnce(async (
-        _session: ExecuteRunParams[0],
-        _tests: ExecuteRunParams[1],
-        _watcher: ExecuteRunParams[2],
-        emitEvent: ExecuteRunParams[3],
-      ) => {
-        await emitEvent('test-case-start', ...eventPayload);
-      });
-
-      await runner.runTests([makeTest()], makeWatcher(), makeOptions());
-
-      expect(listener).toHaveBeenCalledWith(eventPayload);
-    });
-
-    it('stops emitting after listener unsubscribe', async () => {
-      const runner = new JestHarness(makeGlobalConfig());
-      const listener = vi.fn();
-      const unsubscribe = runner.on('test-case-result', listener);
-      const eventPayload = makeTestCaseResultPayload();
-
-      unsubscribe();
-      typedMockExecuteRun.mockImplementationOnce(async (
-        _session: ExecuteRunParams[0],
-        _tests: ExecuteRunParams[1],
-        _watcher: ExecuteRunParams[2],
-        emitEvent: ExecuteRunParams[3],
-      ) => {
-        await emitEvent('test-case-result', ...eventPayload);
-      });
-
-      await runner.runTests([makeTest()], makeWatcher(), makeOptions());
-
-      expect(listener).not.toHaveBeenCalled();
-    });
-  });
-
-  describe('error handling', () => {
-    it('converts HarnessError into a formatted string before throwing', async () => {
-      class TestHarnessError extends HarnessError {
-        constructor() { super('something went wrong'); this.name = 'TestHarnessError'; }
-      }
-
-      mockCreateHarnessSession.mockRejectedValue(new TestHarnessError());
-
-      const runner = new JestHarness(makeGlobalConfig());
-
-      await expect(
-        runner.runTests([makeTest()], makeWatcher(), makeOptions()),
-      ).rejects.toBeTypeOf('string');
-    });
-
-    it('propagates non-HarnessError exceptions as-is', async () => {
-      const cause = new TypeError('unexpected');
-      mockCreateHarnessSession.mockRejectedValue(cause);
-
-      const runner = new JestHarness(makeGlobalConfig());
-
-      await expect(
-        runner.runTests([makeTest()], makeWatcher(), makeOptions()),
-      ).rejects.toBe(cause);
-    });
-
-    it('throws when called without serial flag', async () => {
-      const runner = new JestHarness(makeGlobalConfig());
-
-      await expect(
-        runner.runTests([makeTest()], makeWatcher(), { serial: false }),
-      ).rejects.toThrow('Parallel test running is not supported');
-    });
-  });
-});

package/src/__tests__/metro-port.test.ts

@@ -1,61 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import type { Config as HarnessConfig } from '@react-native-harness/config';
-import type { HarnessPlatform } from '@react-native-harness/platforms';
-import { resolveHarnessMetroPort } from '../metro-port.js';
-
-const mocks = vi.hoisted(() => ({
-  isPortAvailable: vi.fn(async () => true),
-}));
-
-vi.mock('@react-native-harness/bundler-metro', () => ({
-  isPortAvailable: mocks.isPortAvailable,
-}));
-
-const createConfig = (overrides: Partial<HarnessConfig> = {}): HarnessConfig =>
-  ({
-    appRegistryComponentName: 'App',
-    bridgeTimeout: 60_000,
-    bundleStartTimeout: 60_000,
-    crashDetectionInterval: 500,
-    defaultRunner: 'ios-device',
-    detectNativeCrashes: true,
-    disableViewFlattening: false,
-    entryPoint: 'index.js',
-    forwardClientLogs: false,
-    maxAppRestarts: 2,
-    metroPort: 8081,
-    platformReadyTimeout: 300_000,
-    resetEnvironmentBetweenTestFiles: true,
-    runners: [],
-    unstable__enableMetroCache: false,
-    unstable__skipAlreadyIncludedModules: false,
-    ...overrides,
-  } as HarnessConfig);
-
-describe('resolveHarnessMetroPort', () => {
-  it('skips fallback allocation for iOS physical device runners', async () => {
-    const acquire = vi.fn();
-    const config = createConfig();
-    const platform: HarnessPlatform = {
-      config: {},
-      name: 'ios-device',
-      platformId: 'ios',
-      runner: 'unused',
-    };
-
-    const result = await resolveHarnessMetroPort({
-      config,
-      platform,
-      resourceLockManager: {
-        acquire,
-      },
-      signal: new AbortController().signal,
-    });
-
-    expect(result.config).toBe(config);
-    expect(result.metroPortLease).toBeNull();
-    expect(result.didFallback).toBe(false);
-    expect(acquire).not.toHaveBeenCalled();
-    expect(mocks.isPortAvailable).not.toHaveBeenCalled();
-  });
-});

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

@@ -1,179 +0,0 @@
-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 } 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',
-    });
-
-    // The aborted waiter must have cleaned up its ticket. Verify by releasing
-    // the first lock and confirming a fresh acquire completes immediately.
-    await firstLease.release();
-    const cleanupLease = await manager.acquire(key);
-    await cleanupLease.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 key = 'web:browser:chromium';
-
-    // Simulate a live process holding the lock.
-    const manager1 = createResourceLockManager({
-      rootDir,
-      pollIntervalMs: 5,
-      heartbeatIntervalMs: 20,
-    });
-    const staleLease = await manager1.acquire(key);
-
-    // A second manager whose isProcessActive always returns false will consider
-    // any owner — including the live one above — immediately stale and reclaim it.
-    const manager2 = createResourceLockManager({
-      rootDir,
-      pollIntervalMs: 5,
-      heartbeatIntervalMs: 20,
-      staleLockTimeoutMs: 50,
-      isProcessActive: () => false,
-    });
-
-    const lease = await manager2.acquire(key);
-    await lease.release();
-
-    // manager1 was evicted; its release is best-effort.
-    await staleLease.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 actualWriteFile = fs.writeFile.bind(fs);
-    const writeFileSpy = vi
-      .spyOn(fs, 'writeFile')
-      .mockImplementation(async (file, data, options) => {
-        // Delay atomic temp-file writes to simulate overlapping heartbeat flushes.
-        if (typeof file === 'string' && file.startsWith(rootDir) && file.endsWith('.tmp')) {
-          await new Promise((resolve) => setTimeout(resolve, 25));
-        }
-
-        return await actualWriteFile(file, data, options);
-      });
-
-    try {
-      const lease = await manager.acquire(key);
-
-      // Discover the owner file after acquire creates the key directory.
-      const [keyDirName] = await fs.readdir(rootDir);
-      const ownerFilePath = path.join(rootDir, keyDirName, 'owner.json');
-
-      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;
-};