@react-native-harness/jest 1.4.0 → 1.5.0

package/src/__tests__/format-harness-error.test.ts

@@ -1,32 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { formatHarnessErrorMessage } from '../format-harness-error.js';
-
-describe('formatHarnessErrorMessage', () => {
-  it('formats pending promise diagnostics for timeout errors', () => {
-    const message = formatHarnessErrorMessage(
-      {
-        name: 'TestCaseTimeoutError',
-        message: 'Test timed out after 50ms: suite hangs',
-        diagnostics: {
-          pendingPromises: {
-            total: 2,
-            items: [
-              {
-                id: 7,
-                createdAt: 110,
-                stack: 'Error: Promise created\n    at hangs (example.ts:10:5)',
-              },
-            ],
-          },
-        },
-      },
-      { testStartedAt: 100 },
-    );
-
-    expect(message).toContain('Test timed out after 50ms: suite hangs');
-    expect(message).toContain('Pending promises at timeout: 2');
-    expect(message).toContain('Showing 1 of 2 pending promises.');
-    expect(message).toContain('Promise #7, created 10ms after test start:');
-    expect(message).toContain('  Error: Promise created');
-  });
-});

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

@@ -1,91 +0,0 @@
-import type { HarnessPlatform } from '@react-native-harness/platforms';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { maybeLogMetroCacheReused } from '../harness-session.js';
-
-const { createHarnessCache, isWarm, logMetroCacheReused } = vi.hoisted(() => {
-  const isWarm = vi.fn();
-
-  return {
-    isWarm,
-    createHarnessCache: vi.fn((options: { projectRoot: string }) => ({
-      paths: {
-        root: `${options.projectRoot}/.harness/cache`,
-        metroTransform: `${options.projectRoot}/.harness/cache/metro`,
-        metroFileMap: `${options.projectRoot}/.harness/cache/metro-file-map`,
-      },
-      isWarm,
-      ensureDomainDirectories: vi.fn(),
-    })),
-    logMetroCacheReused: vi.fn(),
-  };
-});
-
-vi.mock('@react-native-harness/cache', () => ({
-  createHarnessCache,
-}));
-
-vi.mock('../logs.js', async (importOriginal) => ({
-  ...(await importOriginal<typeof import('../logs.js')>()),
-  logMetroCacheReused,
-}));
-
-const platform = { name: 'test-runner' } as HarnessPlatform;
-
-describe('maybeLogMetroCacheReused', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it('logs the reuse message when caching is enabled and the cache is warm', () => {
-    isWarm.mockReturnValue(true);
-
-    maybeLogMetroCacheReused({
-      config: { cache: { metro: true } },
-      projectRoot: '/tmp/app',
-      platform,
-    });
-
-    expect(createHarnessCache).toHaveBeenCalledWith({
-      projectRoot: '/tmp/app',
-    });
-    expect(isWarm).toHaveBeenCalledWith('metro');
-    expect(logMetroCacheReused).toHaveBeenCalledWith(platform);
-  });
-
-  it('logs the reuse message with a warm cache when caching is on by default', () => {
-    isWarm.mockReturnValue(true);
-
-    maybeLogMetroCacheReused({
-      config: {},
-      projectRoot: '/tmp/app',
-      platform,
-    });
-
-    expect(logMetroCacheReused).toHaveBeenCalledWith(platform);
-  });
-
-  it('does not log when caching is enabled but the cache is cold', () => {
-    isWarm.mockReturnValue(false);
-
-    maybeLogMetroCacheReused({
-      config: { cache: { metro: true } },
-      projectRoot: '/tmp/app',
-      platform,
-    });
-
-    expect(logMetroCacheReused).not.toHaveBeenCalled();
-  });
-
-  it('does not log when caching is disabled, regardless of cache state', () => {
-    isWarm.mockReturnValue(true);
-
-    maybeLogMetroCacheReused({
-      config: { cache: { metro: false } },
-      projectRoot: '/tmp/app',
-      platform,
-    });
-
-    expect(createHarnessCache).not.toHaveBeenCalled();
-    expect(logMetroCacheReused).not.toHaveBeenCalled();
-  });
-});

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

@@ -1,303 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import type { AppConnection } from '@react-native-harness/bridge/server';
-import {
-  getSignalExitCodeForRunState,
-  waitForBridgeDisconnectOrTimeout,
-  waitForNextConnected,
-  waitForStartupCrash,
-  withPlatformReadyTimeout,
-  type HarnessRunState,
-} from '../harness-session.js';
-import type { CrashMonitor } from '../crash-monitor.js';
-import { PlatformReadyTimeoutError } from '../errors.js';
-
-const createConnection = (): AppConnection => ({
-  device: {
-    platform: 'ios',
-    manufacturer: 'Apple',
-    model: 'iPhone',
-    osVersion: '18.0',
-  },
-  runTests: vi.fn(),
-  resetEnvironment: 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('waitForNextConnected', () => {
-  const createConnectableBridge = () => {
-    let listener: (() => void) | null = null;
-    const bridge: Pick<
-      import('@react-native-harness/bridge/server').HarnessBridge,
-      'on' | 'off'
-    > = {
-      on: vi.fn((event, l) => {
-        if (event === 'connected') listener = l as () => void;
-      }),
-      off: vi.fn((event, l) => {
-        if (event === 'connected' && listener === l) listener = null;
-      }),
-    };
-    return { bridge, emitConnected: () => listener?.() };
-  };
-
-  it('resolves when the bridge emits a connected event', async () => {
-    const { bridge, emitConnected } = createConnectableBridge();
-    const controller = new AbortController();
-
-    const waitPromise = waitForNextConnected({ bridge, signal: controller.signal });
-    emitConnected();
-
-    await expect(waitPromise).resolves.toBeUndefined();
-  });
-
-  it('rejects when the signal aborts before a connected event', async () => {
-    const { bridge } = createConnectableBridge();
-    const controller = new AbortController();
-
-    const waitPromise = waitForNextConnected({ bridge, signal: controller.signal });
-    controller.abort(new DOMException('Aborted', 'AbortError'));
-
-    await expect(waitPromise).rejects.toThrow('Aborted');
-  });
-
-  it('rejects immediately when the signal is already aborted', async () => {
-    const { bridge } = createConnectableBridge();
-    const controller = new AbortController();
-    controller.abort(new DOMException('Aborted', 'AbortError'));
-
-    await expect(
-      waitForNextConnected({ bridge, signal: controller.signal }),
-    ).rejects.toThrow('Aborted');
-  });
-
-  it('unsubscribes the connected listener once settled', async () => {
-    const { bridge, emitConnected } = createConnectableBridge();
-    const controller = new AbortController();
-
-    const waitPromise = waitForNextConnected({ bridge, signal: controller.signal });
-    emitConnected();
-    await waitPromise;
-
-    expect(bridge.off).toHaveBeenCalledOnce();
-  });
-});
-
-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();
-  });
-
-  it('removes its abort listener on the session signal once the crash watch wins', async () => {
-    let rejectWatch!: (error: unknown) => void;
-    const cancel = vi.fn();
-    const watch = vi.fn(() => ({
-      promise: new Promise<never>((_, reject) => {
-        rejectWatch = reject;
-      }),
-      cancel,
-    }));
-    const crashMonitor = { watch } as unknown as CrashMonitor;
-    const controller = new AbortController();
-    const addSpy = vi.spyOn(controller.signal, 'addEventListener');
-    const removeSpy = vi.spyOn(controller.signal, 'removeEventListener');
-
-    const waitPromise = waitForStartupCrash({
-      crashMonitor,
-      detectNativeCrashes: true,
-      testFilePath: '/test.harness.ts',
-      signal: controller.signal,
-    });
-
-    // The crash watch wins the race, not the session signal.
-    rejectWatch(new Error('native crash detected'));
-
-    await expect(waitPromise).rejects.toThrow('native crash detected');
-    expect(cancel).toHaveBeenCalledTimes(1);
-
-    // Regression: forgetting to cancel the losing waitForAbort() left its
-    // listener attached to this session-lifetime signal for the rest of
-    // the session — one leaked listener per test file.
-    expect(addSpy).toHaveBeenCalledTimes(1);
-    expect(removeSpy).toHaveBeenCalledTimes(1);
-  });
-});
-
-describe('withPlatformReadyTimeout', () => {
-  afterEach(() => {
-    vi.useRealTimers();
-  });
-
-  it('passes the real session signal to work, unmodified by the timeout', async () => {
-    const controller = new AbortController();
-    const work = vi.fn(async (signal: AbortSignal) => {
-      expect(signal).toBe(controller.signal);
-      return 'ready';
-    });
-
-    await expect(
-      withPlatformReadyTimeout({
-        timeout: 1_000,
-        signal: controller.signal,
-        work,
-      }),
-    ).resolves.toBe('ready');
-    expect(work).toHaveBeenCalledTimes(1);
-  });
-
-  it('throws PlatformReadyTimeoutError on timeout without aborting the session signal', async () => {
-    vi.useFakeTimers();
-    const controller = new AbortController();
-    // Never resolves within the test; simulates a hung platform init.
-    const work = () => new Promise<void>(() => undefined);
-
-    const resultPromise = withPlatformReadyTimeout({
-      timeout: 1_000,
-      signal: controller.signal,
-      work,
-    });
-
-    await vi.advanceTimersByTimeAsync(1_000);
-
-    await expect(resultPromise).rejects.toBeInstanceOf(PlatformReadyTimeoutError);
-    expect(controller.signal.aborted).toBe(false);
-  });
-
-  it('propagates a genuine abort from the session signal as-is', async () => {
-    const controller = new AbortController();
-    const abortReason = new DOMException('Aborted', 'AbortError');
-    const work = (signal: AbortSignal) =>
-      new Promise<never>((_, reject) => {
-        signal.addEventListener('abort', () => reject(signal.reason));
-      });
-
-    const resultPromise = withPlatformReadyTimeout({
-      timeout: 1_000,
-      signal: controller.signal,
-      work,
-    });
-
-    controller.abort(abortReason);
-
-    await expect(resultPromise).rejects.toBe(abortReason);
-  });
-});
-
-describe('getSignalExitCodeForRunState', () => {
-  const createRunState = (
-    overrides: Partial<HarnessRunState> = {}
-  ): HarnessRunState => ({
-    completed: true,
-    coverageEnabled: false,
-    runId: 'run-1',
-    startTime: 0,
-    status: 'passed',
-    summary: {
-      failed: 0,
-      passed: 1,
-      skipped: 0,
-      todo: 0,
-    },
-    testFiles: ['test.harness.ts'],
-    watchMode: false,
-    ...overrides,
-  });
-
-  it('preserves a successful exit after a completed passing run', () => {
-    expect(getSignalExitCodeForRunState(createRunState())).toBe(0);
-  });
-
-  it('fails when the run has not completed yet', () => {
-    expect(
-      getSignalExitCodeForRunState(createRunState({ completed: false }))
-    ).toBe(1);
-  });
-
-  it('fails when the completed run has failures', () => {
-    expect(
-      getSignalExitCodeForRunState(
-        createRunState({
-          status: 'failed',
-          summary: {
-            failed: 1,
-            passed: 0,
-            skipped: 0,
-            todo: 0,
-          },
-        })
-      )
-    ).toBe(1);
-  });
-
-  it('fails when no run state is available', () => {
-    expect(getSignalExitCodeForRunState(null)).toBe(1);
-  });
-});

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