@react-native-harness/jest 1.3.0 → 1.4.0

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

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1,91 @@
+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

@@ -0,0 +1,303 @@
+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__/index.test.ts

@@ -1,8 +1,9 @@
 import { describe, expect, it, vi, beforeEach } from 'vitest';
-import type { Config, Test, TestRunnerOptions, TestWatcher } from 'jest-runner';
+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 { HarnessError } from '@react-native-harness/tools';
+import type { executeRun as ExecuteRun } from '../execute-run.js';
+import { createDiagnostics, HarnessError } from '@react-native-harness/tools';
 import JestHarness from '../index.js';
 
 const resolveUndefined = async () => undefined;
@@ -14,6 +15,8 @@ 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> => ({
     name: '',
@@ -23,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),
@@ -55,6 +59,41 @@ const makeTest = (): 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
 // ---------------------------------------------------------------------------
@@ -62,7 +101,7 @@ const makeGlobalConfig = (overrides: Partial<Config.GlobalConfig> = {}): Config.
 beforeEach(() => {
   vi.clearAllMocks();
   (mockSession.dispose as ReturnType<typeof vi.fn>).mockResolvedValue(undefined);
-  mockExecuteRun.mockResolvedValue(undefined);
+  typedMockExecuteRun.mockResolvedValue(undefined);
   mockCreateHarnessSession.mockResolvedValue(mockSession);
 });
 
@@ -71,7 +110,7 @@ describe('JestHarness', () => {
     it('creates a session on the first run', async () => {
       const runner = new JestHarness(makeGlobalConfig());
 
-      await runner.runTests([makeTest()], makeWatcher(), vi.fn(), vi.fn(), vi.fn(), makeOptions());
+      await runner.runTests([makeTest()], makeWatcher(), makeOptions());
 
       expect(mockCreateHarnessSession).toHaveBeenCalledOnce();
     });
@@ -79,8 +118,8 @@ describe('JestHarness', () => {
     it('reuses the session across runs in watch mode', async () => {
       const runner = new JestHarness(makeGlobalConfig({ watch: true }));
 
-      await runner.runTests([makeTest()], makeWatcher(), vi.fn(), vi.fn(), vi.fn(), makeOptions());
-      await runner.runTests([makeTest()], makeWatcher(), vi.fn(), vi.fn(), vi.fn(), makeOptions());
+      await runner.runTests([makeTest()], makeWatcher(), makeOptions());
+      await runner.runTests([makeTest()], makeWatcher(), makeOptions());
 
       expect(mockCreateHarnessSession).toHaveBeenCalledOnce();
       expect(mockSession.dispose).not.toHaveBeenCalled();
@@ -89,7 +128,7 @@ describe('JestHarness', () => {
     it('disposes the session after each run in normal mode', async () => {
       const runner = new JestHarness(makeGlobalConfig());
 
-      await runner.runTests([makeTest()], makeWatcher(), vi.fn(), vi.fn(), vi.fn(), makeOptions());
+      await runner.runTests([makeTest()], makeWatcher(), makeOptions());
 
       expect(mockSession.dispose).toHaveBeenCalledOnce();
     });
@@ -97,11 +136,52 @@ describe('JestHarness', () => {
     it('creates a fresh session for each run in normal mode', async () => {
       const runner = new JestHarness(makeGlobalConfig());
 
-      await runner.runTests([makeTest()], makeWatcher(), vi.fn(), vi.fn(), vi.fn(), makeOptions());
-      await runner.runTests([makeTest()], makeWatcher(), vi.fn(), vi.fn(), vi.fn(), makeOptions());
+      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', () => {
@@ -115,7 +195,7 @@ describe('JestHarness', () => {
       const runner = new JestHarness(makeGlobalConfig());
 
       await expect(
-        runner.runTests([makeTest()], makeWatcher(), vi.fn(), vi.fn(), vi.fn(), makeOptions()),
+        runner.runTests([makeTest()], makeWatcher(), makeOptions()),
       ).rejects.toBeTypeOf('string');
     });
 
@@ -126,7 +206,7 @@ describe('JestHarness', () => {
       const runner = new JestHarness(makeGlobalConfig());
 
       await expect(
-        runner.runTests([makeTest()], makeWatcher(), vi.fn(), vi.fn(), vi.fn(), makeOptions()),
+        runner.runTests([makeTest()], makeWatcher(), makeOptions()),
       ).rejects.toBe(cause);
     });
 
@@ -134,7 +214,7 @@ describe('JestHarness', () => {
       const runner = new JestHarness(makeGlobalConfig());
 
       await expect(
-        runner.runTests([makeTest()], makeWatcher(), vi.fn(), vi.fn(), vi.fn(), { serial: false }),
+        runner.runTests([makeTest()], makeWatcher(), { serial: false }),
       ).rejects.toThrow('Parallel test running is not supported');
     });
   });

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 }),
+    );
+  });
+});