merge origin/main

Author: V3RON

.nx/version-plans/improve-bridge-resilience.md

@@ -0,0 +1,5 @@
+---
+__default__: patch
+---
+
+Harness now handles app bridge reloads, reconnects, disconnects, and dropped sockets more reliably during test runs. For Harness users, this means fewer stuck runs waiting on a dead RPC channel and clearer failures when the app reloads, crashes, or loses its bridge connection mid-test.

packages/bridge/eslint.config.mjs

@@ -8,7 +8,11 @@ export default [
       '@nx/dependency-checks': [
         'error',
         {
-          ignoredFiles: ['{projectRoot}/eslint.config.{js,cjs,mjs,ts,cts,mts}'],
+          ignoredDependencies: ['vite', 'vitest'],
+          ignoredFiles: [
+            '{projectRoot}/eslint.config.{js,cjs,mjs,ts,cts,mts}',
+            '{projectRoot}/src/**/__tests__/**',
+          ],
         },
       ],
     },

packages/bridge/package.json

@@ -29,7 +29,6 @@
   "dependencies": {
     "@react-native-harness/platforms": "workspace:*",
     "@react-native-harness/tools": "workspace:*",
-    "birpc": "^2.4.0",
     "pixelmatch": "^7.1.0",
     "pngjs": "^7.0.0",
     "ssim.js": "^3.5.0",
@@ -39,7 +38,9 @@
   "devDependencies": {
     "@types/pixelmatch": "^5.2.6",
     "@types/pngjs": "^6.0.5",
-    "@types/ws": "^8.18.1"
+    "@types/ws": "^8.18.1",
+    "vite": "^7.2.2",
+    "vitest": "^3.2.4"
   },
   "license": "MIT"
 }

packages/bridge/src/__tests__/client.test.ts

@@ -0,0 +1,99 @@
+import { describe, expect, it, vi } from 'vitest';
+import { connectToHarness } from '../client.js';
+import type {
+  BridgeTransport,
+  BridgeTransportCloseEvent,
+  BridgeTransportMessage,
+  BridgeTransportState,
+} from '../transport.js';
+
+const createMockTransport = (initialState: BridgeTransportState = 'connecting') => {
+  let state = initialState;
+  const openListeners = new Set<() => void>();
+  const messageListeners = new Set<(message: BridgeTransportMessage) => void>();
+  const closeListeners = new Set<(event: BridgeTransportCloseEvent) => void>();
+  const errorListeners = new Set<(error: Error) => void>();
+  const sent: BridgeTransportMessage[] = [];
+
+  const transport: BridgeTransport = {
+    get state() {
+      return state;
+    },
+    send: (message) => {
+      sent.push(message);
+    },
+    close: (code = 1000, reason = '') => {
+      state = 'closed';
+      for (const listener of closeListeners) {
+        listener({ code, reason });
+      }
+    },
+    onOpen: (listener) => {
+      openListeners.add(listener);
+      return () => openListeners.delete(listener);
+    },
+    onMessage: (listener) => {
+      messageListeners.add(listener);
+      return () => messageListeners.delete(listener);
+    },
+    onClose: (listener) => {
+      closeListeners.add(listener);
+      return () => closeListeners.delete(listener);
+    },
+    onError: (listener) => {
+      errorListeners.add(listener);
+      return () => errorListeners.delete(listener);
+    },
+  };
+
+  return {
+    transport,
+    sent,
+    open: () => {
+      state = 'open';
+      for (const listener of openListeners) {
+        listener();
+      }
+    },
+    receive: (message: BridgeTransportMessage) => {
+      for (const listener of messageListeners) {
+        listener(message);
+      }
+    },
+    fail: (error: Error) => {
+      for (const listener of errorListeners) {
+        listener(error);
+      }
+    },
+  };
+};
+
+describe('connectToHarness transport injection', () => {
+  it('uses the injected transport instead of constructing a WebSocket', async () => {
+    const mockTransport = createMockTransport();
+    const handlePromise = connectToHarness(
+      'ws://unused',
+      { runTests: vi.fn() },
+      { transport: mockTransport.transport },
+    );
+
+    mockTransport.open();
+
+    const handle = await handlePromise;
+    handle.reportReady({
+      platform: 'ios',
+      manufacturer: 'Apple',
+      model: 'Injected',
+      osVersion: '18.0',
+    });
+
+    expect(mockTransport.sent).toHaveLength(1);
+    expect(mockTransport.sent[0]).toBeTypeOf('string');
+    expect(JSON.parse(mockTransport.sent[0] as string)).toMatchObject({
+      type: 'ready',
+      device: { model: 'Injected' },
+    });
+
+    handle.disconnect();
+  });
+});

packages/bridge/src/__tests__/heartbeat.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, it, vi } from 'vitest';
+import { createHeartbeat } from '../heartbeat.js';
+
+describe('bridge heartbeat', () => {
+  it('sends pings and times out stale sessions', () => {
+    vi.useFakeTimers();
+
+    const sendPing = vi.fn();
+    const onTimeout = vi.fn();
+    createHeartbeat({
+      sendPing,
+      onTimeout,
+      intervalMs: 5,
+      timeoutMs: 10,
+    });
+
+    vi.advanceTimersByTime(5);
+    expect(sendPing).toHaveBeenCalledWith(1);
+
+    vi.advanceTimersByTime(10);
+    expect(onTimeout).toHaveBeenCalledTimes(1);
+
+    vi.useRealTimers();
+  });
+
+  it('clears the timeout when the matching pong arrives', () => {
+    vi.useFakeTimers();
+
+    const sendPing = vi.fn();
+    const onTimeout = vi.fn();
+    const heartbeat = createHeartbeat({
+      sendPing,
+      onTimeout,
+      intervalMs: 5,
+      timeoutMs: 10,
+    });
+
+    vi.advanceTimersByTime(5);
+    heartbeat.notifyPong(1);
+    vi.advanceTimersByTime(10);
+
+    expect(onTimeout).not.toHaveBeenCalled();
+
+    heartbeat.dispose();
+    vi.useRealTimers();
+  });
+});

packages/bridge/src/__tests__/protocol.test.ts

@@ -0,0 +1,51 @@
+import { describe, expect, it } from 'vitest';
+import {
+  deserializeBridgeError,
+  parseBridgeMessage,
+  serializeBridgeError,
+  serializeBridgeMessage,
+} from '../protocol.js';
+
+describe('bridge protocol', () => {
+  it('round-trips invoke messages', () => {
+    const raw = serializeBridgeMessage({
+      type: 'invoke',
+      id: 1,
+      method: 'runTests',
+      args: ['example.ts', { runner: '/runner.js' }],
+    });
+
+    expect(parseBridgeMessage(raw)).toEqual({
+      type: 'invoke',
+      id: 1,
+      method: 'runTests',
+      args: ['example.ts', { runner: '/runner.js' }],
+    });
+  });
+
+  it('serializes and restores errors with metadata', () => {
+    const cause = new Error('inner');
+    const error = new TypeError('boom', { cause });
+    error.stack = 'stack trace';
+
+    const restored = deserializeBridgeError(serializeBridgeError(error));
+
+    expect(restored.name).toBe('TypeError');
+    expect(restored.message).toBe('boom');
+    expect(restored.stack).toBe('stack trace');
+    expect(restored.cause).toBe(cause);
+  });
+
+  it('serializes non-Error thrown values explicitly', () => {
+    expect(serializeBridgeError('boom')).toEqual({
+      name: 'NonErrorThrown',
+      message: 'boom',
+    });
+  });
+
+  it('rejects malformed messages', () => {
+    expect(() => parseBridgeMessage('{"type":"invoke","id":"1"}')).toThrow(
+      'Invalid bridge message: id must be a number',
+    );
+  });
+});