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

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

@@ -1,10 +1,15 @@
-import { describe, expect, it, vi } from 'vitest';
+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: {
@@ -14,6 +19,7 @@ const createConnection = (): AppConnection => ({
     osVersion: '18.0',
   },
   runTests: vi.fn(),
+  resetEnvironment: vi.fn(),
 });
 
 const createBridge = (connection: AppConnection | null) => {
@@ -71,6 +77,65 @@ describe('waitForBridgeDisconnectOrTimeout', () => {
   });
 });
 
+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();
@@ -90,4 +155,149 @@ describe('waitForStartupCrash', () => {
     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__/index.test.ts

@@ -3,7 +3,7 @@ import type { Config, Test, TestEvents, TestRunnerOptions, TestWatcher } from 'j
 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 { createDiagnostics, HarnessError } from '@react-native-harness/tools';
 import JestHarness from '../index.js';
 
 const resolveUndefined = async () => undefined;
@@ -15,6 +15,7 @@ const resolveUndefined = async () => undefined;
 const mockSession: HarnessSession = {
   config: { metroPort: 8081 } as HarnessSession['config'],
   context: {} as HarnessSession['context'],
+  diagnostics: createDiagnostics({ enabled: false }),
   onTestRunnerEvent: vi.fn(() => () => undefined),
   ensureAppReady: vi.fn(resolveUndefined),
   runTestFile: vi.fn(async (): Promise<TestSuiteResult> => ({
@@ -25,6 +26,7 @@ const mockSession: HarnessSession = {
     duration: 0,
   })),
   restartApp: vi.fn(resolveUndefined),
+  resetEnvironment: vi.fn(resolveUndefined),
   resetCrashState: vi.fn(),
   flushClientLogs: vi.fn(() => []),
   callHook: vi.fn(resolveUndefined),

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

@@ -22,11 +22,13 @@ const createConfig = (overrides: Partial<HarnessConfig> = {}): HarnessConfig =>
     disableViewFlattening: false,
     entryPoint: 'index.js',
     forwardClientLogs: false,
+    diagnostics: false,
     maxAppRestarts: 2,
     metroPort: 8081,
     platformReadyTimeout: 300_000,
     resetEnvironmentBetweenTestFiles: true,
     runners: [],
+    testTimeout: 5_000,
     unstable__enableMetroCache: false,
     unstable__skipAlreadyIncludedModules: false,
     ...overrides,

package/src/__tests__/run.test.ts

@@ -0,0 +1,74 @@
+import { describe, expect, it, vi } from 'vitest';
+import type { Config as JestConfig } from 'jest-runner';
+import type { TestSuiteResult } from '@react-native-harness/bridge';
+import type { HarnessSession } from '../harness-session.js';
+import { runHarnessTestFile } from '../run.js';
+
+vi.mock('jest-message-util', () => ({
+  formatResultsErrors: vi.fn(() => ''),
+}));
+
+const createHarnessResult = (): TestSuiteResult => ({
+  name: 'root',
+  tests: [],
+  suites: [],
+  status: 'passed',
+  duration: 0,
+});
+
+const createSession = (testTimeout: number): HarnessSession =>
+  ({
+    config: { testTimeout },
+    context: {
+      platform: {
+        runner: './runner.js',
+      },
+    },
+    runTestFile: vi.fn(async () => createHarnessResult()),
+  }) as unknown as HarnessSession;
+
+const createGlobalConfig = (
+  overrides: Partial<JestConfig.GlobalConfig> = {},
+): JestConfig.GlobalConfig =>
+  ({
+    rootDir: '/project',
+    ...overrides,
+  }) as JestConfig.GlobalConfig;
+
+const createProjectConfig = (
+  overrides: Partial<JestConfig.ProjectConfig> = {},
+): JestConfig.ProjectConfig => overrides as JestConfig.ProjectConfig;
+
+describe('runHarnessTestFile', () => {
+  it('uses Harness config testTimeout when Jest config does not set one', async () => {
+    const session = createSession(15000);
+
+    await runHarnessTestFile({
+      testPath: '/project/example.harness.ts',
+      session,
+      globalConfig: createGlobalConfig(),
+      projectConfig: createProjectConfig(),
+    });
+
+    expect(session.runTestFile).toHaveBeenCalledWith(
+      'example.harness.ts',
+      expect.objectContaining({ testTimeout: 15000 }),
+    );
+  });
+
+  it('keeps Harness config testTimeout above Jest config testTimeout', async () => {
+    const session = createSession(15000);
+
+    await runHarnessTestFile({
+      testPath: '/project/example.harness.ts',
+      session,
+      globalConfig: createGlobalConfig({ testTimeout: 20000 } as never),
+      projectConfig: createProjectConfig({ testTimeout: 30000 } as never),
+    });
+
+    expect(session.runTestFile).toHaveBeenCalledWith(
+      'example.harness.ts',
+      expect.objectContaining({ testTimeout: 15000 }),
+    );
+  });
+});

package/src/crash-monitor.ts

@@ -40,6 +40,13 @@ export type CrashMonitor = {
   reset: () => void;
   setAppSession: (session: AppSession | null) => void;
   handleBridgeDisconnect: () => void;
+  /**
+   * Opens a window during which handleBridgeDisconnect() is suppressed,
+   * for use around operations (like a runtime reset) that intentionally
+   * disconnect the bridge without the app process dying. Returns a closer
+   * that ends the window; safe to call multiple times or nest.
+   */
+  expectDisconnect: () => () => void;
   dispose: () => Promise<void>;
 };
 
@@ -131,6 +138,7 @@ export const createCrashMonitor = ({
 
   let currentTestFilePath = '';
   let currentPhase: NativeCrashPhase = 'startup';
+  let expectedDisconnectDepth = 0;
   const watchers = new Set<(err: HarnessRuntimeFailure) => void>();
 
   const notifyFailure = (err: HarnessRuntimeFailure) => {
@@ -273,6 +281,19 @@ export const createCrashMonitor = ({
     return { promise, cancel };
   };
 
+  const expectDisconnect = (): (() => void) => {
+    expectedDisconnectDepth += 1;
+    let closed = false;
+
+    return () => {
+      if (closed) {
+        return;
+      }
+      closed = true;
+      expectedDisconnectDepth = Math.max(0, expectedDisconnectDepth - 1);
+    };
+  };
+
   return {
     watch,
     isAlive: () => alive,
@@ -289,15 +310,22 @@ export const createCrashMonitor = ({
       watchers.clear();
       isResolvingCrash = false;
       currentTestFilePath = '';
+      expectedDisconnectDepth = 0;
       clearPendingTimer();
     },
     setAppSession,
     handleBridgeDisconnect: () => {
+      if (expectedDisconnectDepth > 0) {
+        crashLogger.debug('ignoring expected bridge disconnect');
+        return;
+      }
       startCrashResolution('bridge-disconnect');
     },
+    expectDisconnect,
     dispose: async () => {
       disposed = true;
       monitoring = false;
+      expectedDisconnectDepth = 0;
       watchers.clear();
       isResolvingCrash = false;
       clearPendingTimer();