@react-native-harness/jest 1.4.0 → 1.4.1

package/src/__tests__/crash-monitor.test.ts

@@ -1,323 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import path from 'node:path';
-import type {
-  AppSession,
-  AppSessionEvent,
-  AppSessionListener,
-  AppSessionLog,
-  AppSessionState,
-} from '@react-native-harness/platforms';
-import {
-  createCrashMonitor,
-  CrashWatchCancelledError,
-} from '../crash-monitor.js';
-import { NativeCrashError, RuntimeDisconnectError } from '../errors.js';
-
-const noop = () => undefined;
-const waitForClassification = () =>
-  new Promise((resolve) => setTimeout(resolve, 1600));
-
-const createAppSessionMock = (
-  initialState: AppSessionState = { status: 'running' },
-  logs: AppSessionLog[] = [],
-  getCrashDetails?: AppSession['getCrashDetails']
-) => {
-  let state = initialState;
-  let listener: AppSessionListener | null = null;
-
-  const session: AppSession = {
-    dispose: vi.fn(async () => undefined),
-    getState: vi.fn(async () => state),
-    getLogs: vi.fn(() => logs),
-    addListener: vi.fn((l: AppSessionListener) => {
-      listener = l;
-    }),
-    removeListener: vi.fn((l: AppSessionListener) => {
-      if (listener === l) listener = null;
-    }),
-  };
-
-  if (getCrashDetails) {
-    session.getCrashDetails = getCrashDetails;
-  }
-
-  return {
-    session,
-    setState: (nextState: AppSessionState) => {
-      state = nextState;
-    },
-    emit: (event: AppSessionEvent) => listener?.(event),
-  };
-};
-
-describe('createCrashMonitor', () => {
-  it('starts not alive and becomes alive when an app session is attached', () => {
-    const cm = createCrashMonitor();
-    const { session } = createAppSessionMock();
-
-    expect(cm.isAlive()).toBe(false);
-
-    cm.setAppSession(session);
-
-    expect(cm.isAlive()).toBe(true);
-  });
-
-  it('rejects a watch with NativeCrashError when the app session exits', async () => {
-    const { session, emit } = createAppSessionMock({
-      status: 'exited',
-      occurredAt: Date.now(),
-      reason: 'observed-exit',
-    });
-    const cm = createCrashMonitor({ appSession: session });
-    const watch = cm.watch('/test/example.ts', 'execution');
-    watch.promise.catch(noop);
-
-    emit({ type: 'app_exited' });
-
-    const error = await watch.promise.catch((err: NativeCrashError) => err);
-    expect(error).toBeInstanceOf(NativeCrashError);
-    expect(error.testFilePath).toBe('/test/example.ts');
-    expect(error.details.phase).toBe('execution');
-    expect(cm.isAlive()).toBe(false);
-  });
-
-  it('classifies bridge disconnect plus exited app as NativeCrashError', async () => {
-    const { session, setState } = createAppSessionMock();
-    const cm = createCrashMonitor({ appSession: session });
-    const watch = cm.watch('test.ts', 'execution');
-    watch.promise.catch(noop);
-
-    cm.handleBridgeDisconnect();
-    setState({
-      status: 'exited',
-      occurredAt: Date.now(),
-      reason: 'process-gone',
-    });
-
-    await expect(watch.promise).rejects.toBeInstanceOf(NativeCrashError);
-  });
-
-  it('classifies bridge disconnect plus running app as RuntimeDisconnectError', async () => {
-    const { session } = createAppSessionMock({ status: 'running' });
-    const cm = createCrashMonitor({ appSession: session });
-    const watch = cm.watch('test.ts', 'execution');
-    watch.promise.catch(noop);
-
-    cm.handleBridgeDisconnect();
-
-    await expect(watch.promise).rejects.toBeInstanceOf(RuntimeDisconnectError);
-  });
-
-  it('attaches matching session log evidence to native crash details', async () => {
-    const occurredAt = Date.now();
-    const logs = [
-      { line: 'ordinary app log', occurredAt },
-      { line: 'MyApp[123] fatal error: boom', occurredAt },
-    ];
-    const { session, setState } = createAppSessionMock(
-      { status: 'running' },
-      logs
-    );
-    const cm = createCrashMonitor({ appSession: session });
-    const watch = cm.watch('test.ts', 'execution');
-    watch.promise.catch(noop);
-
-    cm.handleBridgeDisconnect();
-    setState({ status: 'exited', occurredAt, reason: 'process-gone' });
-
-    const error = await watch.promise.catch((err: NativeCrashError) => err);
-    expect(error).toBeInstanceOf(NativeCrashError);
-    expect(error.details.rawLines).toEqual(['MyApp[123] fatal error: boom']);
-  });
-
-  it('asks the app session to extract native crash details for the current test', async () => {
-    const occurredAt = Date.now();
-    const getCrashDetails = vi.fn(async () => ({
-      artifactType: 'logcat' as const,
-      artifactPath: '/tmp/.harness/crash-reports/crash-logcat.txt',
-      processName: 'com.harnessplayground',
-      pid: 7777,
-    }));
-    const { session, setState } = createAppSessionMock(
-      { status: 'running' },
-      [],
-      getCrashDetails
-    );
-    const cm = createCrashMonitor({ appSession: session });
-    const watch = cm.watch('/test/example.ts', 'execution');
-    watch.promise.catch(noop);
-
-    cm.handleBridgeDisconnect();
-    setState({
-      status: 'exited',
-      occurredAt,
-      pid: 7777,
-      reason: 'process-gone',
-    });
-
-    const error = await watch.promise.catch((err: NativeCrashError) => err);
-
-    expect(getCrashDetails).toHaveBeenCalledWith({
-      occurredAt: expect.any(Number),
-      pid: 7777,
-      processName: undefined,
-      testFilePath: '/test/example.ts',
-    });
-    expect(error.details.artifactPath).toBe(
-      '/tmp/.harness/crash-reports/crash-logcat.txt'
-    );
-    expect(error.message).toContain(
-      `Harness extracted the crash log: ${path.relative(
-        process.cwd(),
-        '/tmp/.harness/crash-reports/crash-logcat.txt'
-      )}`
-    );
-  });
-
-  it('falls back to log details when native crash extraction fails', async () => {
-    const occurredAt = Date.now();
-    const getCrashDetails = vi.fn(async () => {
-      throw new Error('copy failed');
-    });
-    const { session, setState } = createAppSessionMock(
-      { status: 'running' },
-      [{ line: 'MyApp[123] fatal error: boom', occurredAt }],
-      getCrashDetails
-    );
-    const cm = createCrashMonitor({ appSession: session });
-    const watch = cm.watch('/test/example.ts', 'execution');
-    watch.promise.catch(noop);
-
-    cm.handleBridgeDisconnect();
-    setState({ status: 'exited', occurredAt, reason: 'process-gone' });
-
-    const error = await watch.promise.catch((err: NativeCrashError) => err);
-
-    expect(error.details.rawLines).toEqual(['MyApp[123] fatal error: boom']);
-    expect(error.message).toContain("Harness couldn't extract the crash log.");
-  });
-
-  it('settles the promise with CrashWatchCancelledError on cancel()', async () => {
-    const cm = createCrashMonitor();
-    const watch = cm.watch('test.ts', 'execution');
-
-    watch.cancel();
-
-    await expect(watch.promise).rejects.toBeInstanceOf(
-      CrashWatchCancelledError
-    );
-  });
-
-  it('ignores session events while stopped', async () => {
-    const { session, emit } = createAppSessionMock({
-      status: 'exited',
-      occurredAt: Date.now(),
-    });
-    const cm = createCrashMonitor({ appSession: session });
-    await cm.stop();
-
-    const watch = cm.watch('test.ts', 'execution');
-    const settled = vi.fn();
-    watch.promise.then(settled, settled);
-
-    emit({ type: 'app_exited' });
-    await waitForClassification();
-
-    expect(settled).not.toHaveBeenCalled();
-    watch.cancel();
-  });
-
-  it('removes the app session listener on dispose', async () => {
-    const { session } = createAppSessionMock();
-    const cm = createCrashMonitor({ appSession: session });
-
-    await cm.dispose();
-
-    expect(session.removeListener).toHaveBeenCalledOnce();
-    expect(cm.isAlive()).toBe(false);
-  });
-
-  describe('expectDisconnect', () => {
-    it('suppresses handleBridgeDisconnect while the window is open', async () => {
-      const { session } = createAppSessionMock({ status: 'running' });
-      const cm = createCrashMonitor({ appSession: session });
-      const watch = cm.watch('test.ts', 'execution');
-      watch.promise.catch(noop);
-
-      const closeWindow = cm.expectDisconnect();
-      cm.handleBridgeDisconnect();
-      await waitForClassification();
-
-      const settled = vi.fn();
-      watch.promise.then(settled, settled);
-      await Promise.resolve();
-      expect(settled).not.toHaveBeenCalled();
-
-      closeWindow();
-      watch.cancel();
-    });
-
-    it('resumes classifying disconnects once the window closes', async () => {
-      const { session } = createAppSessionMock({ status: 'running' });
-      const cm = createCrashMonitor({ appSession: session });
-      const watch = cm.watch('test.ts', 'execution');
-      watch.promise.catch(noop);
-
-      const closeWindow = cm.expectDisconnect();
-      closeWindow();
-
-      cm.handleBridgeDisconnect();
-
-      await expect(watch.promise).rejects.toBeInstanceOf(RuntimeDisconnectError);
-    });
-
-    it('keeps the window open until every opener has closed it (nested windows)', async () => {
-      const { session } = createAppSessionMock({ status: 'running' });
-      const cm = createCrashMonitor({ appSession: session });
-      const watch = cm.watch('test.ts', 'execution');
-      watch.promise.catch(noop);
-
-      const closeFirst = cm.expectDisconnect();
-      const closeSecond = cm.expectDisconnect();
-      closeFirst();
-
-      cm.handleBridgeDisconnect();
-      await waitForClassification();
-
-      const settled = vi.fn();
-      watch.promise.then(settled, settled);
-      await Promise.resolve();
-      expect(settled).not.toHaveBeenCalled();
-
-      closeSecond();
-      watch.cancel();
-    });
-
-    it('ignores a redundant close() call', async () => {
-      const { session } = createAppSessionMock({ status: 'running' });
-      const cm = createCrashMonitor({ appSession: session });
-      const watch = cm.watch('test.ts', 'execution');
-      watch.promise.catch(noop);
-
-      const closeWindow = cm.expectDisconnect();
-      closeWindow();
-      closeWindow();
-
-      cm.handleBridgeDisconnect();
-
-      await expect(watch.promise).rejects.toBeInstanceOf(RuntimeDisconnectError);
-    });
-
-    it('clears the expected-disconnect window on dispose', async () => {
-      const { session } = createAppSessionMock({ status: 'running' });
-      const cm = createCrashMonitor({ appSession: session });
-      cm.expectDisconnect();
-
-      await cm.dispose();
-
-      // A disconnect after dispose should not throw or hang; monitoring is
-      // fully torn down regardless of the window state.
-      expect(() => cm.handleBridgeDisconnect()).not.toThrow();
-    });
-  });
-});

package/src/__tests__/environment-reset.test.ts

@@ -1,308 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import {
-  createProcessResetStrategy,
-  createRuntimeResetStrategy,
-  resolveResetStrategyKind,
-  withEscalation,
-  type EnvironmentResetStrategy,
-} from '../environment-reset.js';
-
-describe('resolveResetStrategyKind', () => {
-  it('normalizes true to the process strategy', () => {
-    expect(resolveResetStrategyKind(true)).toBe('process');
-  });
-
-  it('normalizes false to null (no reset)', () => {
-    expect(resolveResetStrategyKind(false)).toBeNull();
-  });
-
-  it('passes through the process string value', () => {
-    expect(resolveResetStrategyKind('process')).toBe('process');
-  });
-
-  it('passes through the runtime string value', () => {
-    expect(resolveResetStrategyKind('runtime')).toBe('runtime');
-  });
-});
-
-describe('createProcessResetStrategy', () => {
-  it('has kind "process" and delegates to the injected restart function', async () => {
-    const restart = vi.fn(async () => undefined);
-    const strategy = createProcessResetStrategy({ restart });
-
-    expect(strategy.kind).toBe('process');
-    await strategy.reset({ testFilePath: '/tests/example.harness.ts' });
-
-    expect(restart).toHaveBeenCalledWith('/tests/example.harness.ts');
-  });
-
-  it('propagates restart failures', async () => {
-    const restart = vi.fn(async () => {
-      throw new Error('restart failed');
-    });
-    const strategy = createProcessResetStrategy({ restart });
-
-    await expect(
-      strategy.reset({ testFilePath: '/tests/example.harness.ts' })
-    ).rejects.toThrow('restart failed');
-  });
-});
-
-describe('createRuntimeResetStrategy', () => {
-  const testFilePath = '/tests/example.harness.ts';
-
-  it('has kind "runtime" and resets via the connection then waits for reconnect', async () => {
-    const callOrder: string[] = [];
-    const closeWindow = vi.fn();
-    const connection = {
-      resetEnvironment: vi.fn(async () => {
-        callOrder.push('resetEnvironment');
-      }),
-    };
-    const waitForReconnect = vi.fn(async () => {
-      callOrder.push('waitForReconnect-started');
-    });
-
-    const strategy = createRuntimeResetStrategy({
-      getConnection: () => connection,
-      expectDisconnect: () => {
-        callOrder.push('expectDisconnect');
-        return closeWindow;
-      },
-      waitForReconnect,
-      isDisconnectError: () => false,
-      timeoutMs: 1000,
-    });
-
-    expect(strategy.kind).toBe('runtime');
-    await strategy.reset({ testFilePath });
-
-    expect(callOrder).toEqual([
-      'expectDisconnect',
-      'waitForReconnect-started',
-      'resetEnvironment',
-    ]);
-    expect(waitForReconnect).toHaveBeenCalledWith(expect.any(AbortSignal));
-    expect(closeWindow).toHaveBeenCalledOnce();
-  });
-
-  it('starts waiting for reconnect before firing the RPC', async () => {
-    const callOrder: string[] = [];
-    const connection = {
-      resetEnvironment: vi.fn(async () => {
-        callOrder.push('resetEnvironment');
-      }),
-    };
-    const waitForReconnect = vi.fn(() => {
-      callOrder.push('waitForReconnect-called');
-      return Promise.resolve();
-    });
-
-    const strategy = createRuntimeResetStrategy({
-      getConnection: () => connection,
-      expectDisconnect: () => () => undefined,
-      waitForReconnect,
-      isDisconnectError: () => false,
-      timeoutMs: 1000,
-    });
-
-    await strategy.reset({ testFilePath });
-
-    expect(callOrder).toEqual(['waitForReconnect-called', 'resetEnvironment']);
-  });
-
-  it('throws when there is no active app connection', async () => {
-    const expectDisconnect = vi.fn();
-    const strategy = createRuntimeResetStrategy({
-      getConnection: () => null,
-      expectDisconnect,
-      waitForReconnect: vi.fn(async () => undefined),
-      isDisconnectError: () => false,
-      timeoutMs: 1000,
-    });
-
-    await expect(strategy.reset({ testFilePath })).rejects.toThrow(
-      'No active app connection'
-    );
-    expect(expectDisconnect).not.toHaveBeenCalled();
-  });
-
-  it('closes the expected-disconnect window even when the RPC call fails', async () => {
-    const closeWindow = vi.fn();
-    const connection = {
-      resetEnvironment: vi.fn(async () => {
-        throw new Error('rpc failed');
-      }),
-    };
-
-    const strategy = createRuntimeResetStrategy({
-      getConnection: () => connection,
-      expectDisconnect: () => closeWindow,
-      waitForReconnect: vi.fn(async () => undefined),
-      isDisconnectError: () => false,
-      timeoutMs: 1000,
-    });
-
-    await expect(strategy.reset({ testFilePath })).rejects.toThrow('rpc failed');
-    expect(closeWindow).toHaveBeenCalledOnce();
-  });
-
-  it('closes the expected-disconnect window even when reconnect times out', async () => {
-    const closeWindow = vi.fn();
-    const connection = { resetEnvironment: vi.fn(async () => undefined) };
-
-    const strategy = createRuntimeResetStrategy({
-      getConnection: () => connection,
-      expectDisconnect: () => closeWindow,
-      waitForReconnect: vi.fn(async () => {
-        throw new Error('reconnect timed out');
-      }),
-      isDisconnectError: () => false,
-      timeoutMs: 1000,
-    });
-
-    await expect(strategy.reset({ testFilePath })).rejects.toThrow(
-      'reconnect timed out'
-    );
-    expect(closeWindow).toHaveBeenCalledOnce();
-  });
-
-  it('treats a disconnect-flavored RPC rejection as reload-in-flight and succeeds', async () => {
-    const disconnectError = new Error('app bridge disconnected');
-    const connection = {
-      resetEnvironment: vi.fn(async () => {
-        throw disconnectError;
-      }),
-    };
-    const waitForReconnect = vi.fn(async () => undefined);
-
-    const strategy = createRuntimeResetStrategy({
-      getConnection: () => connection,
-      expectDisconnect: () => () => undefined,
-      waitForReconnect,
-      isDisconnectError: (error) => error === disconnectError,
-      timeoutMs: 1000,
-    });
-
-    await expect(strategy.reset({ testFilePath })).resolves.toBeUndefined();
-    expect(waitForReconnect).toHaveBeenCalledOnce();
-  });
-
-  it('still throws on a non-disconnect RPC rejection', async () => {
-    const connection = {
-      resetEnvironment: vi.fn(async () => {
-        throw new Error('rpc failed');
-      }),
-    };
-
-    const strategy = createRuntimeResetStrategy({
-      getConnection: () => connection,
-      expectDisconnect: () => () => undefined,
-      waitForReconnect: vi.fn(async () => undefined),
-      isDisconnectError: (error) =>
-        error instanceof Error && error.message === 'app bridge disconnected',
-      timeoutMs: 1000,
-    });
-
-    await expect(strategy.reset({ testFilePath })).rejects.toThrow('rpc failed');
-  });
-
-  it('does not leave an unhandled rejection when the RPC fails before the reconnect wait settles', async () => {
-    let rejectReconnect!: (error: Error) => void;
-    const waitForReconnect = vi.fn(
-      () =>
-        new Promise<void>((_, reject) => {
-          rejectReconnect = reject;
-        })
-    );
-    const connection = {
-      resetEnvironment: vi.fn(async () => {
-        throw new Error('rpc failed');
-      }),
-    };
-
-    const unhandled: unknown[] = [];
-    const onUnhandledRejection = (reason: unknown) => {
-      unhandled.push(reason);
-    };
-    process.on('unhandledRejection', onUnhandledRejection);
-
-    try {
-      const strategy = createRuntimeResetStrategy({
-        getConnection: () => connection,
-        expectDisconnect: () => () => undefined,
-        waitForReconnect,
-        isDisconnectError: () => false,
-        timeoutMs: 1000,
-      });
-
-      await expect(strategy.reset({ testFilePath })).rejects.toThrow('rpc failed');
-
-      // Simulate the reconnect timeout firing after the strategy already
-      // threw; the strategy must have attached a rejection handler.
-      rejectReconnect(new Error('reconnect timed out'));
-      await new Promise((resolve) => setImmediate(resolve));
-
-      expect(unhandled).toEqual([]);
-    } finally {
-      process.off('unhandledRejection', onUnhandledRejection);
-    }
-  });
-});
-
-describe('withEscalation', () => {
-  const testFilePath = '/tests/example.harness.ts';
-
-  const makeStrategy = (
-    kind: EnvironmentResetStrategy['kind'],
-    reset: EnvironmentResetStrategy['reset']
-  ): EnvironmentResetStrategy => ({ kind, reset });
-
-  it('reports the primary strategy kind', () => {
-    const primary = makeStrategy('runtime', async () => undefined);
-    const fallback = makeStrategy('process', async () => undefined);
-
-    expect(withEscalation(primary, fallback).kind).toBe('runtime');
-  });
-
-  it('does not call the fallback when the primary succeeds', async () => {
-    const fallbackReset = vi.fn(async () => undefined);
-    const primary = makeStrategy('runtime', async () => undefined);
-    const fallback = makeStrategy('process', fallbackReset);
-    const onEscalate = vi.fn();
-
-    await withEscalation(primary, fallback, { onEscalate }).reset({ testFilePath });
-
-    expect(fallbackReset).not.toHaveBeenCalled();
-    expect(onEscalate).not.toHaveBeenCalled();
-  });
-
-  it('escalates to the fallback when the primary fails', async () => {
-    const primaryError = new Error('runtime reset failed');
-    const fallbackReset = vi.fn(async () => undefined);
-    const primary = makeStrategy('runtime', async () => {
-      throw primaryError;
-    });
-    const fallback = makeStrategy('process', fallbackReset);
-    const onEscalate = vi.fn();
-
-    await withEscalation(primary, fallback, { onEscalate }).reset({ testFilePath });
-
-    expect(fallbackReset).toHaveBeenCalledWith({ testFilePath });
-    expect(onEscalate).toHaveBeenCalledWith(primaryError);
-  });
-
-  it('propagates the fallback error when both strategies fail', async () => {
-    const fallbackError = new Error('process reset also failed');
-    const primary = makeStrategy('runtime', async () => {
-      throw new Error('runtime reset failed');
-    });
-    const fallback = makeStrategy('process', async () => {
-      throw fallbackError;
-    });
-
-    await expect(
-      withEscalation(primary, fallback).reset({ testFilePath })
-    ).rejects.toBe(fallbackError);
-  });
-});