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

package/src/__tests__/client-log-handler.test.ts

@@ -1,364 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import {
-  createClientLogCollector,
-  formatClientLogMessage,
-  formatClientLogEntry,
-  type ClientLogEvent,
-} from '../client-log-handler.js';
-
-describe('client-log-handler', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  describe('formatClientLogMessage', () => {
-    it('should format a single string', () => {
-      const result = formatClientLogMessage(['Hello, world!']);
-      expect(result).toBe('Hello, world!');
-    });
-
-    it('should join multiple strings with spaces', () => {
-      const result = formatClientLogMessage(['Hello', 'world', '!']);
-      expect(result).toBe('Hello world !');
-    });
-
-    it('should format objects', () => {
-      const result = formatClientLogMessage([{ key: 'value' }]);
-      // util.format uses inspect-style output for objects
-      expect(result).toContain('key');
-      expect(result).toContain('value');
-    });
-
-    it('should format arrays', () => {
-      const result = formatClientLogMessage([[1, 2, 3]]);
-      expect(result).toContain('1');
-      expect(result).toContain('2');
-      expect(result).toContain('3');
-    });
-
-    it('should handle mixed types', () => {
-      const result = formatClientLogMessage([
-        'Message:',
-        { count: 42 },
-        'items',
-      ]);
-      expect(result).toContain('Message:');
-      expect(result).toContain('count');
-      expect(result).toContain('42');
-      expect(result).toContain('items');
-    });
-
-    it('should format numbers', () => {
-      const result = formatClientLogMessage([123, 456]);
-      expect(result).toBe('123 456');
-    });
-
-    it('should format booleans', () => {
-      const result = formatClientLogMessage([true, false]);
-      expect(result).toBe('true false');
-    });
-
-    it('should format null and undefined', () => {
-      const result = formatClientLogMessage([null, undefined]);
-      expect(result).toBe('null undefined');
-    });
-
-    it('should handle empty array', () => {
-      const result = formatClientLogMessage([]);
-      expect(result).toBe('');
-    });
-
-    describe('printf-style format specifiers', () => {
-      it('should handle %s string substitution', () => {
-        const result = formatClientLogMessage(['%s world', 'hello']);
-        expect(result).toBe('hello world');
-      });
-
-      it('should handle %d integer substitution', () => {
-        const result = formatClientLogMessage(['Count: %d', 42]);
-        expect(result).toBe('Count: 42');
-      });
-
-      it('should handle %i integer substitution', () => {
-        const result = formatClientLogMessage(['Value: %i', 123]);
-        expect(result).toBe('Value: 123');
-      });
-
-      it('should handle %f float substitution', () => {
-        const result = formatClientLogMessage(['Pi: %f', 3.14159]);
-        expect(result).toContain('3.14159');
-      });
-
-      it('should handle multiple substitutions', () => {
-        const result = formatClientLogMessage([
-          'Hello %s, you have %d messages',
-          'Alice',
-          5,
-        ]);
-        expect(result).toBe('Hello Alice, you have 5 messages');
-      });
-
-      it('should handle %j JSON substitution', () => {
-        const result = formatClientLogMessage(['Data: %j', { key: 'value' }]);
-        expect(result).toBe('Data: {"key":"value"}');
-      });
-
-      it('should handle %o object substitution', () => {
-        const result = formatClientLogMessage(['Object: %o', { a: 1 }]);
-        // %o produces inspect-style output, just check it contains the key
-        expect(result).toContain('a');
-      });
-
-      it('should handle %% as literal percent when substituting', () => {
-        // %% is only converted to % when there are substitutions
-        const result = formatClientLogMessage(['%s is 100%% complete', 'Task']);
-        expect(result).toBe('Task is 100% complete');
-      });
-
-      it('should append extra arguments after substitution', () => {
-        const result = formatClientLogMessage([
-          'Hello %s',
-          'world',
-          'extra',
-          'args',
-        ]);
-        expect(result).toBe('Hello world extra args');
-      });
-    });
-  });
-
-  describe('formatClientLogEntry', () => {
-    it('should format log level event', () => {
-      const event: ClientLogEvent = {
-        type: 'client_log',
-        level: 'log',
-        data: ['Test message'],
-      };
-      const result = formatClientLogEntry(event);
-      expect(result).toEqual({
-        message: 'Test message',
-        origin: '',
-        type: 'log',
-      });
-    });
-
-    it('should format error level event', () => {
-      const event: ClientLogEvent = {
-        type: 'client_log',
-        level: 'error',
-        data: ['Error occurred'],
-      };
-      const result = formatClientLogEntry(event);
-      expect(result).toEqual({
-        message: 'Error occurred',
-        origin: '',
-        type: 'error',
-      });
-    });
-
-    it('should format warn level event', () => {
-      const event: ClientLogEvent = {
-        type: 'client_log',
-        level: 'warn',
-        data: ['Warning message'],
-      };
-      const result = formatClientLogEntry(event);
-      expect(result).toEqual({
-        message: 'Warning message',
-        origin: '',
-        type: 'warn',
-      });
-    });
-
-    it('should format info level event', () => {
-      const event: ClientLogEvent = {
-        type: 'client_log',
-        level: 'info',
-        data: ['Info message'],
-      };
-      const result = formatClientLogEntry(event);
-      expect(result).toEqual({
-        message: 'Info message',
-        origin: '',
-        type: 'info',
-      });
-    });
-
-    it('should format debug level event', () => {
-      const event: ClientLogEvent = {
-        type: 'client_log',
-        level: 'debug',
-        data: ['Debug message'],
-      };
-      const result = formatClientLogEntry(event);
-      expect(result).toEqual({
-        message: 'Debug message',
-        origin: '',
-        type: 'debug',
-      });
-    });
-
-    it('should format trace level event', () => {
-      const event: ClientLogEvent = {
-        type: 'client_log',
-        level: 'trace',
-        data: ['Trace message'],
-      };
-      const result = formatClientLogEntry(event);
-      expect(result).toEqual({
-        message: 'Trace message',
-        origin: '',
-        type: 'log',
-      });
-    });
-
-    it('should handle multiple data items', () => {
-      const event: ClientLogEvent = {
-        type: 'client_log',
-        level: 'log',
-        data: ['User:', { id: 1, name: 'Test' }],
-      };
-      const result = formatClientLogEntry(event);
-      expect(result?.message).toContain('User:');
-      expect(result?.message).toContain('id');
-      expect(result?.message).toContain('Test');
-    });
-  });
-
-  describe('createClientLogCollector', () => {
-    it('collects client_log events and flushes them', () => {
-      const collector = createClientLogCollector();
-      const event: ClientLogEvent = {
-        type: 'client_log',
-        level: 'log',
-        data: ['Test message'],
-      };
-
-      collector.handleEvent(event);
-
-      expect(collector.flush()).toEqual([
-        {
-          message: 'Test message',
-          origin: '',
-          type: 'log',
-        },
-      ]);
-    });
-
-    it('returns an empty array for non-client_log events', () => {
-      const collector = createClientLogCollector();
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      const event = { type: 'bundle_build_started' } as any;
-
-      collector.handleEvent(event);
-
-      expect(collector.flush()).toEqual([]);
-    });
-
-    it('collects error level logs', () => {
-      const collector = createClientLogCollector();
-      const event: ClientLogEvent = {
-        type: 'client_log',
-        level: 'error',
-        data: ['Something went wrong'],
-      };
-
-      collector.handleEvent(event);
-
-      expect(collector.flush()).toEqual([
-        {
-          message: 'Something went wrong',
-          origin: '',
-          type: 'error',
-        },
-      ]);
-    });
-
-    it('collects warn level logs', () => {
-      const collector = createClientLogCollector();
-      const event: ClientLogEvent = {
-        type: 'client_log',
-        level: 'warn',
-        data: ['Deprecation warning'],
-      };
-
-      collector.handleEvent(event);
-
-      expect(collector.flush()).toEqual([
-        {
-          message: 'Deprecation warning',
-          origin: '',
-          type: 'warn',
-        },
-      ]);
-    });
-
-    it('flush clears the buffer', () => {
-      const collector = createClientLogCollector();
-
-      collector.handleEvent({
-        type: 'client_log',
-        level: 'info',
-        data: ['Listener test'],
-      });
-
-      expect(collector.flush()).toEqual([
-        {
-          message: 'Listener test',
-          origin: '',
-          type: 'info',
-        },
-      ]);
-      expect(collector.flush()).toEqual([]);
-    });
-
-    it('ignores non-client_log events', () => {
-      const collector = createClientLogCollector();
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      const event = { type: 'initialize_done' } as any;
-
-      collector.handleEvent(event);
-
-      expect(collector.flush()).toEqual([]);
-    });
-
-    it('ignores group events', () => {
-      const collector = createClientLogCollector();
-      const event: ClientLogEvent = {
-        type: 'client_log',
-        level: 'group',
-        data: ['Group label'],
-      };
-
-      collector.handleEvent(event);
-
-      expect(collector.flush()).toEqual([]);
-    });
-
-    it('ignores groupCollapsed events', () => {
-      const collector = createClientLogCollector();
-      const event: ClientLogEvent = {
-        type: 'client_log',
-        level: 'groupCollapsed',
-        data: ['Collapsed'],
-      };
-
-      collector.handleEvent(event);
-
-      expect(collector.flush()).toEqual([]);
-    });
-
-    it('ignores groupEnd events', () => {
-      const collector = createClientLogCollector();
-      const event: ClientLogEvent = {
-        type: 'client_log',
-        level: 'groupEnd',
-        data: [],
-      };
-
-      collector.handleEvent(event);
-
-      expect(collector.flush()).toEqual([]);
-    });
-  });
-});

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

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