@react-native-harness/jest 1.2.0-rc.1 → 1.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@react-native-harness/jest",
-  "version": "1.2.0-rc.1",
+  "version": "1.3.0",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -37,15 +37,14 @@
     "chalk": "^4.1.2",
     "jest-message-util": "^30.2.0",
     "jest-util": "^30.2.0",
-    "p-limit": "^7.1.1",
     "tslib": "^2.3.0",
     "yargs": "^17.7.2",
-    "@react-native-harness/bundler-metro": "1.2.0-rc.1",
-    "@react-native-harness/config": "1.2.0-rc.1",
-    "@react-native-harness/platforms": "1.2.0-rc.1",
-    "@react-native-harness/tools": "1.2.0-rc.1",
-    "@react-native-harness/bridge": "1.2.0-rc.1",
-    "@react-native-harness/plugins": "1.2.0-rc.1"
+    "@react-native-harness/bridge": "1.3.0",
+    "@react-native-harness/config": "1.3.0",
+    "@react-native-harness/plugins": "1.3.0",
+    "@react-native-harness/tools": "1.3.0",
+    "@react-native-harness/bundler-metro": "1.3.0",
+    "@react-native-harness/platforms": "1.3.0"
   },
   "devDependencies": {
     "@types/yargs": "^17.0.32",

package/src/__tests__/bridge.test.ts

@@ -0,0 +1,184 @@
+/**
+ * Integration test pairing createHarnessBridge (CLI side) with
+ * connectToHarness (app side). Tests the full connection lifecycle and
+ * RPC round-trip without knowing birpc internals.
+ */
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import type { HarnessBridge } from '@react-native-harness/bridge/server';
+import { createHarnessBridge } from '@react-native-harness/bridge/server';
+import { connectToHarness } from '@react-native-harness/bridge/client';
+import type { HarnessContext } from '@react-native-harness/bridge';
+
+const makeContext = (): HarnessContext => ({
+  platform: {
+    name: 'ios',
+    platformId: 'ios',
+    runner: '/dev/null',
+    config: {},
+  },
+});
+
+// ---------------------------------------------------------------------------
+// Test setup
+// ---------------------------------------------------------------------------
+
+let bridge: HarnessBridge;
+let bridgePort: number;
+
+beforeEach(async () => {
+  bridge = await createHarnessBridge({ port: 0, context: makeContext() });
+  bridgePort = (bridge.ws.address() as { port: number }).port;
+});
+
+afterEach(async () => {
+  bridge.dispose();
+  // Allow the server to close cleanly.
+  await new Promise((r) => setTimeout(r, 10));
+});
+
+const connect = (callbacks: Parameters<typeof connectToHarness>[1] = { runTests: vi.fn() }) =>
+  connectToHarness(`ws://127.0.0.1:${bridgePort}`, callbacks);
+
+const device = {
+  platform: 'ios' as const,
+  manufacturer: 'Apple',
+  model: 'iPhone 17 Pro Simulator',
+  osVersion: '18.0',
+};
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('bridge: createHarnessBridge + connectToHarness', () => {
+  describe('connection lifecycle', () => {
+    it('nextConnection() resolves once the app reports ready', async () => {
+      const connectionPromise = bridge.nextConnection();
+
+      const handle = await connect();
+      handle.reportReady(device);
+
+      const conn = await connectionPromise;
+      expect(conn.device).toEqual(device);
+      handle.disconnect();
+    });
+
+    it('bridge.connection is set after reportReady and cleared on disconnect', async () => {
+      const connectionPromise = bridge.nextConnection();
+      const handle = await connect();
+      handle.reportReady(device);
+
+      await connectionPromise;
+      expect(bridge.connection).not.toBeNull();
+
+      handle.disconnect();
+      // Allow close event to propagate.
+      await new Promise((r) => setTimeout(r, 20));
+      expect(bridge.connection).toBeNull();
+    });
+
+    it('nextConnection() returns immediately if app already connected', async () => {
+      // App connects before nextConnection() is called.
+      const handle = await connect();
+      handle.reportReady(device);
+
+      // Yield so the server processes the reportReady before we ask.
+      await new Promise((r) => setTimeout(r, 10));
+
+      const conn = await bridge.nextConnection();
+      expect(conn.device.platform).toBe('ios');
+      handle.disconnect();
+    });
+
+    it('emits connected / disconnected events', async () => {
+      const onConnected = vi.fn();
+      const onDisconnected = vi.fn();
+      bridge.on('connected', onConnected);
+      bridge.on('disconnected', onDisconnected);
+
+      const handle = await connect();
+      handle.reportReady(device);
+      await new Promise((r) => setTimeout(r, 10));
+
+      expect(onConnected).toHaveBeenCalledOnce();
+
+      handle.disconnect();
+      await new Promise((r) => setTimeout(r, 20));
+
+      expect(onDisconnected).toHaveBeenCalledOnce();
+    });
+
+    it('nextConnection() rejects when signal is already aborted', async () => {
+      const controller = new AbortController();
+      controller.abort();
+
+      await expect(bridge.nextConnection(controller.signal)).rejects.toMatchObject({
+        name: 'AbortError',
+      });
+    });
+
+    it('nextConnection() rejects when signal is aborted while waiting', async () => {
+      const controller = new AbortController();
+      const promise = bridge.nextConnection(controller.signal);
+
+      controller.abort();
+
+      await expect(promise).rejects.toMatchObject({ name: 'AbortError' });
+    });
+  });
+
+  describe('runTests round-trip', () => {
+    it('CLI conn.runTests() invokes the app-side runTests callback', async () => {
+      const suiteResult = {
+        name: 'suite',
+        tests: [{ name: 'passes', status: 'passed' as const, duration: 10 }],
+        suites: [],
+        status: 'passed' as const,
+        duration: 30,
+      };
+      const runTestsCb = vi.fn(async () => suiteResult);
+
+      const connectionPromise = bridge.nextConnection();
+      const handle = await connect({ runTests: runTestsCb });
+      handle.reportReady(device);
+
+      const conn = await connectionPromise;
+      const result = await conn.runTests('example.ts', {
+        runner: '/runner.js',
+      });
+
+      expect(runTestsCb).toHaveBeenCalledWith('example.ts', expect.objectContaining({ runner: '/runner.js' }));
+      expect(result.tests[0].name).toBe('passes');
+      handle.disconnect();
+    });
+  });
+
+  describe('bridge events', () => {
+    it('emitEvent on app side fires the event listener on bridge', async () => {
+      const onEvent = vi.fn();
+      bridge.on('event', onEvent);
+
+      const connectionPromise = bridge.nextConnection();
+      const handle = await connect();
+      handle.reportReady(device);
+      await connectionPromise;
+
+      handle.emitEvent({ type: 'collection-started', file: 'example.ts' });
+      await new Promise((r) => setTimeout(r, 10));
+
+      expect(onEvent).toHaveBeenCalledWith(
+        expect.objectContaining({ type: 'collection-started', file: 'example.ts' }),
+      );
+      handle.disconnect();
+    });
+  });
+
+  describe('dispose', () => {
+    it('rejects pending nextConnection() waiters', async () => {
+      const pending = bridge.nextConnection();
+      bridge.dispose();
+
+      await expect(pending).rejects.toThrow('Bridge disposed');
+    });
+  });
+});

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

@@ -1,19 +1,11 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import {
+  createClientLogCollector,
   formatClientLogMessage,
-  formatClientLogLine,
-  handleClientLogEvent,
-  createClientLogListener,
+  formatClientLogEntry,
   type ClientLogEvent,
 } from '../client-log-handler.js';
 
-// Mock the log function
-vi.mock('../logs.js', () => ({
-  log: vi.fn(),
-}));
-
-import { log } from '../logs.js';
-
 describe('client-log-handler', () => {
   beforeEach(() => {
     vi.clearAllMocks();
@@ -98,7 +90,11 @@ describe('client-log-handler', () => {
       });
 
       it('should handle multiple substitutions', () => {
-        const result = formatClientLogMessage(['Hello %s, you have %d messages', 'Alice', 5]);
+        const result = formatClientLogMessage([
+          'Hello %s, you have %d messages',
+          'Alice',
+          5,
+        ]);
         expect(result).toBe('Hello Alice, you have 5 messages');
       });
 
@@ -120,22 +116,30 @@ describe('client-log-handler', () => {
       });
 
       it('should append extra arguments after substitution', () => {
-        const result = formatClientLogMessage(['Hello %s', 'world', 'extra', 'args']);
+        const result = formatClientLogMessage([
+          'Hello %s',
+          'world',
+          'extra',
+          'args',
+        ]);
         expect(result).toBe('Hello world extra args');
       });
     });
   });
 
-  describe('formatClientLogLine', () => {
+  describe('formatClientLogEntry', () => {
     it('should format log level event', () => {
       const event: ClientLogEvent = {
         type: 'client_log',
         level: 'log',
         data: ['Test message'],
       };
-      const result = formatClientLogLine(event);
-      // The result will contain ANSI codes for styling, so we check it contains the message
-      expect(result).toContain('Test message');
+      const result = formatClientLogEntry(event);
+      expect(result).toEqual({
+        message: 'Test message',
+        origin: '',
+        type: 'log',
+      });
     });
 
     it('should format error level event', () => {
@@ -144,8 +148,12 @@ describe('client-log-handler', () => {
         level: 'error',
         data: ['Error occurred'],
       };
-      const result = formatClientLogLine(event);
-      expect(result).toContain('Error occurred');
+      const result = formatClientLogEntry(event);
+      expect(result).toEqual({
+        message: 'Error occurred',
+        origin: '',
+        type: 'error',
+      });
     });
 
     it('should format warn level event', () => {
@@ -154,8 +162,12 @@ describe('client-log-handler', () => {
         level: 'warn',
         data: ['Warning message'],
       };
-      const result = formatClientLogLine(event);
-      expect(result).toContain('Warning message');
+      const result = formatClientLogEntry(event);
+      expect(result).toEqual({
+        message: 'Warning message',
+        origin: '',
+        type: 'warn',
+      });
     });
 
     it('should format info level event', () => {
@@ -164,8 +176,12 @@ describe('client-log-handler', () => {
         level: 'info',
         data: ['Info message'],
       };
-      const result = formatClientLogLine(event);
-      expect(result).toContain('Info message');
+      const result = formatClientLogEntry(event);
+      expect(result).toEqual({
+        message: 'Info message',
+        origin: '',
+        type: 'info',
+      });
     });
 
     it('should format debug level event', () => {
@@ -174,8 +190,12 @@ describe('client-log-handler', () => {
         level: 'debug',
         data: ['Debug message'],
       };
-      const result = formatClientLogLine(event);
-      expect(result).toContain('Debug message');
+      const result = formatClientLogEntry(event);
+      expect(result).toEqual({
+        message: 'Debug message',
+        origin: '',
+        type: 'debug',
+      });
     });
 
     it('should format trace level event', () => {
@@ -184,8 +204,12 @@ describe('client-log-handler', () => {
         level: 'trace',
         data: ['Trace message'],
       };
-      const result = formatClientLogLine(event);
-      expect(result).toContain('Trace message');
+      const result = formatClientLogEntry(event);
+      expect(result).toEqual({
+        message: 'Trace message',
+        origin: '',
+        type: 'log',
+      });
     });
 
     it('should handle multiple data items', () => {
@@ -194,135 +218,147 @@ describe('client-log-handler', () => {
         level: 'log',
         data: ['User:', { id: 1, name: 'Test' }],
       };
-      const result = formatClientLogLine(event);
-      expect(result).toContain('User:');
-      expect(result).toContain('id');
-      expect(result).toContain('Test');
+      const result = formatClientLogEntry(event);
+      expect(result?.message).toContain('User:');
+      expect(result?.message).toContain('id');
+      expect(result?.message).toContain('Test');
     });
   });
 
-  describe('handleClientLogEvent', () => {
-    it('should handle client_log events and call log', () => {
+  describe('createClientLogCollector', () => {
+    it('collects client_log events and flushes them', () => {
+      const collector = createClientLogCollector();
       const event: ClientLogEvent = {
         type: 'client_log',
         level: 'log',
         data: ['Test message'],
       };
 
-      const result = handleClientLogEvent(event);
+      collector.handleEvent(event);
 
-      expect(result).toBe(true);
-      expect(log).toHaveBeenCalledTimes(1);
-      expect(log).toHaveBeenCalledWith(expect.stringContaining('Test message'));
+      expect(collector.flush()).toEqual([
+        {
+          message: 'Test message',
+          origin: '',
+          type: 'log',
+        },
+      ]);
     });
 
-    it('should return false for non-client_log events', () => {
+    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;
 
-      const result = handleClientLogEvent(event);
+      collector.handleEvent(event);
 
-      expect(result).toBe(false);
-      expect(log).not.toHaveBeenCalled();
+      expect(collector.flush()).toEqual([]);
     });
 
-    it('should handle error level logs', () => {
+    it('collects error level logs', () => {
+      const collector = createClientLogCollector();
       const event: ClientLogEvent = {
         type: 'client_log',
         level: 'error',
         data: ['Something went wrong'],
       };
 
-      handleClientLogEvent(event);
+      collector.handleEvent(event);
 
-      expect(log).toHaveBeenCalledWith(
-        expect.stringContaining('Something went wrong')
-      );
+      expect(collector.flush()).toEqual([
+        {
+          message: 'Something went wrong',
+          origin: '',
+          type: 'error',
+        },
+      ]);
     });
 
-    it('should handle warn level logs', () => {
+    it('collects warn level logs', () => {
+      const collector = createClientLogCollector();
       const event: ClientLogEvent = {
         type: 'client_log',
         level: 'warn',
         data: ['Deprecation warning'],
       };
 
-      handleClientLogEvent(event);
+      collector.handleEvent(event);
 
-      expect(log).toHaveBeenCalledWith(
-        expect.stringContaining('Deprecation warning')
-      );
+      expect(collector.flush()).toEqual([
+        {
+          message: 'Deprecation warning',
+          origin: '',
+          type: 'warn',
+        },
+      ]);
     });
-  });
 
-  describe('createClientLogListener', () => {
-    it('should create a listener function', () => {
-      const listener = createClientLogListener();
-      expect(typeof listener).toBe('function');
-    });
+    it('flush clears the buffer', () => {
+      const collector = createClientLogCollector();
 
-    it('should handle client_log events when called', () => {
-      const listener = createClientLogListener();
-      const event: ClientLogEvent = {
+      collector.handleEvent({
         type: 'client_log',
         level: 'info',
         data: ['Listener test'],
-      };
-
-      listener(event);
+      });
 
-      expect(log).toHaveBeenCalledWith(expect.stringContaining('Listener test'));
+      expect(collector.flush()).toEqual([
+        {
+          message: 'Listener test',
+          origin: '',
+          type: 'info',
+        },
+      ]);
+      expect(collector.flush()).toEqual([]);
     });
 
-    it('should ignore non-client_log events', () => {
-      const listener = createClientLogListener();
+    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;
 
-      listener(event);
+      collector.handleEvent(event);
 
-      expect(log).not.toHaveBeenCalled();
+      expect(collector.flush()).toEqual([]);
     });
-  });
 
-  describe('group events', () => {
-    it('should handle group events without logging', () => {
+    it('ignores group events', () => {
+      const collector = createClientLogCollector();
       const event: ClientLogEvent = {
         type: 'client_log',
         level: 'group',
         data: ['Group label'],
       };
 
-      const result = handleClientLogEvent(event);
+      collector.handleEvent(event);
 
-      expect(result).toBe(true);
-      expect(log).not.toHaveBeenCalled();
+      expect(collector.flush()).toEqual([]);
     });
 
-    it('should handle groupCollapsed events without logging', () => {
+    it('ignores groupCollapsed events', () => {
+      const collector = createClientLogCollector();
       const event: ClientLogEvent = {
         type: 'client_log',
         level: 'groupCollapsed',
         data: ['Collapsed'],
       };
 
-      const result = handleClientLogEvent(event);
+      collector.handleEvent(event);
 
-      expect(result).toBe(true);
-      expect(log).not.toHaveBeenCalled();
+      expect(collector.flush()).toEqual([]);
     });
 
-    it('should handle groupEnd events without logging', () => {
+    it('ignores groupEnd events', () => {
+      const collector = createClientLogCollector();
       const event: ClientLogEvent = {
         type: 'client_log',
         level: 'groupEnd',
         data: [],
       };
 
-      const result = handleClientLogEvent(event);
+      collector.handleEvent(event);
 
-      expect(result).toBe(true);
-      expect(log).not.toHaveBeenCalled();
+      expect(collector.flush()).toEqual([]);
     });
   });
 });