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

package/dist/__tests__/bridge.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=bridge.test.d.ts.map

package/dist/__tests__/bridge.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bridge.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/bridge.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/bridge.test.js

@@ -0,0 +1,142 @@
+/**
+ * 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 { createHarnessBridge } from '@react-native-harness/bridge/server';
+import { connectToHarness } from '@react-native-harness/bridge/client';
+const makeContext = () => ({
+    platform: {
+        name: 'ios',
+        platformId: 'ios',
+        runner: '/dev/null',
+        config: {},
+    },
+});
+// ---------------------------------------------------------------------------
+// Test setup
+// ---------------------------------------------------------------------------
+let bridge;
+let bridgePort;
+beforeEach(async () => {
+    bridge = await createHarnessBridge({ port: 0, context: makeContext() });
+    bridgePort = bridge.ws.address().port;
+});
+afterEach(async () => {
+    bridge.dispose();
+    // Allow the server to close cleanly.
+    await new Promise((r) => setTimeout(r, 10));
+});
+const connect = (callbacks = { runTests: vi.fn() }) => connectToHarness(`ws://127.0.0.1:${bridgePort}`, callbacks);
+const device = {
+    platform: 'ios',
+    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', duration: 10 }],
+                suites: [],
+                status: 'passed',
+                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/dist/__tests__/client-log-handler.test.js

@@ -1,10 +1,5 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { formatClientLogMessage, formatClientLogLine, handleClientLogEvent, createClientLogListener, } from '../client-log-handler.js';
-// Mock the log function
-vi.mock('../logs.js', () => ({
-    log: vi.fn(),
-}));
-import { log } from '../logs.js';
+import { createClientLogCollector, formatClientLogMessage, formatClientLogEntry, } from '../client-log-handler.js';
 describe('client-log-handler', () => {
     beforeEach(() => {
         vi.clearAllMocks();
@@ -75,7 +70,11 @@ describe('client-log-handler', () => {
                 expect(result).toContain('3.14159');
             });
             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');
             });
             it('should handle %j JSON substitution', () => {
@@ -93,21 +92,29 @@ describe('client-log-handler', () => {
                 expect(result).toBe('Task is 100% complete');
             });
             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 = {
                 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', () => {
             const event = {
@@ -115,8 +122,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', () => {
             const event = {
@@ -124,8 +135,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', () => {
             const event = {
@@ -133,8 +148,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', () => {
             const event = {
@@ -142,8 +161,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', () => {
             const event = {
@@ -151,8 +174,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', () => {
             const event = {
@@ -160,103 +187,120 @@ 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 = {
                 type: 'client_log',
                 level: 'log',
                 data: ['Test message'],
             };
-            const result = handleClientLogEvent(event);
-            expect(result).toBe(true);
-            expect(log).toHaveBeenCalledTimes(1);
-            expect(log).toHaveBeenCalledWith(expect.stringContaining('Test message'));
+            collector.handleEvent(event);
+            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' };
-            const result = handleClientLogEvent(event);
-            expect(result).toBe(false);
-            expect(log).not.toHaveBeenCalled();
+            collector.handleEvent(event);
+            expect(collector.flush()).toEqual([]);
         });
-        it('should handle error level logs', () => {
+        it('collects error level logs', () => {
+            const collector = createClientLogCollector();
             const event = {
                 type: 'client_log',
                 level: 'error',
                 data: ['Something went wrong'],
             };
-            handleClientLogEvent(event);
-            expect(log).toHaveBeenCalledWith(expect.stringContaining('Something went wrong'));
+            collector.handleEvent(event);
+            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 = {
                 type: 'client_log',
                 level: 'warn',
                 data: ['Deprecation warning'],
             };
-            handleClientLogEvent(event);
-            expect(log).toHaveBeenCalledWith(expect.stringContaining('Deprecation warning'));
-        });
-    });
-    describe('createClientLogListener', () => {
-        it('should create a listener function', () => {
-            const listener = createClientLogListener();
-            expect(typeof listener).toBe('function');
+            collector.handleEvent(event);
+            expect(collector.flush()).toEqual([
+                {
+                    message: 'Deprecation warning',
+                    origin: '',
+                    type: 'warn',
+                },
+            ]);
         });
-        it('should handle client_log events when called', () => {
-            const listener = createClientLogListener();
-            const event = {
+        it('flush clears the buffer', () => {
+            const collector = createClientLogCollector();
+            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' };
-            listener(event);
-            expect(log).not.toHaveBeenCalled();
+            collector.handleEvent(event);
+            expect(collector.flush()).toEqual([]);
         });
-    });
-    describe('group events', () => {
-        it('should handle group events without logging', () => {
+        it('ignores group events', () => {
+            const collector = createClientLogCollector();
             const event = {
                 type: 'client_log',
                 level: 'group',
                 data: ['Group label'],
             };
-            const result = handleClientLogEvent(event);
-            expect(result).toBe(true);
-            expect(log).not.toHaveBeenCalled();
+            collector.handleEvent(event);
+            expect(collector.flush()).toEqual([]);
         });
-        it('should handle groupCollapsed events without logging', () => {
+        it('ignores groupCollapsed events', () => {
+            const collector = createClientLogCollector();
             const event = {
                 type: 'client_log',
                 level: 'groupCollapsed',
                 data: ['Collapsed'],
             };
-            const result = handleClientLogEvent(event);
-            expect(result).toBe(true);
-            expect(log).not.toHaveBeenCalled();
+            collector.handleEvent(event);
+            expect(collector.flush()).toEqual([]);
         });
-        it('should handle groupEnd events without logging', () => {
+        it('ignores groupEnd events', () => {
+            const collector = createClientLogCollector();
             const event = {
                 type: 'client_log',
                 level: 'groupEnd',
                 data: [],
             };
-            const result = handleClientLogEvent(event);
-            expect(result).toBe(true);
-            expect(log).not.toHaveBeenCalled();
+            collector.handleEvent(event);
+            expect(collector.flush()).toEqual([]);
         });
     });
 });

package/dist/__tests__/crash-monitor.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=crash-monitor.test.d.ts.map

package/dist/__tests__/crash-monitor.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crash-monitor.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/crash-monitor.test.ts"],"names":[],"mappings":""}