@react-native-harness/bridge 1.0.0-alpha.20 → 1.0.0-alpha.22

package/src/server.ts

@@ -2,23 +2,37 @@ import { WebSocketServer, type WebSocket } from 'ws';
 import { type BirpcGroup, createBirpcGroup } from 'birpc';
 import { logger } from '@react-native-harness/tools';
 import { EventEmitter } from 'node:events';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { BinaryStore, parseBinaryFrame } from './binary-transfer.js';
 import type {
   BridgeServerFunctions,
   BridgeClientFunctions,
   DeviceDescriptor,
   BridgeEvents,
+  ImageSnapshotOptions,
+  HarnessContext,
+  BinaryDataReference,
+  FileReference,
 } from './shared.js';
 import { deserialize, serialize } from './serializer.js';
 import { DeviceNotRespondingError } from './errors.js';
+import { matchImageSnapshot } from './image-snapshot.js';
+
+export { DeviceNotRespondingError } from './errors.js';
 
 export type BridgeServerOptions = {
   port: number;
   timeout?: number;
+  context: HarnessContext;
 };
 
 export type BridgeServerEvents = {
   ready: (device: DeviceDescriptor) => void;
   event: (event: BridgeEvents) => void;
+  disconnect: () => void;
 };
 
 export type BridgeServer = {
@@ -42,6 +56,7 @@ export type BridgeServer = {
 export const getBridgeServer = async ({
   port,
   timeout,
+  context,
 }: BridgeServerOptions): Promise<BridgeServer> => {
   const wss = await new Promise<WebSocketServer>((resolve) => {
     const server = new WebSocketServer({ port, host: '0.0.0.0' }, () => {
@@ -50,19 +65,65 @@ export const getBridgeServer = async ({
   });
   const emitter = new EventEmitter();
   const clients = new Set<WebSocket>();
+  const binaryStore = new BinaryStore();
+
+  const baseFunctions: BridgeServerFunctions = {
+    reportReady: (device) => {
+      emitter.emit('ready', device);
+    },
+    emitEvent: (_, data) => {
+      emitter.emit('event', data);
+    },
+    'device.screenshot.receive': async (
+      reference: BinaryDataReference,
+      metadata: { width: number; height: number }
+    ) => {
+      const data = binaryStore.get(reference.transferId);
+      if (!data) {
+        throw new Error(
+          `Binary data for transfer ${reference.transferId} not found or expired`
+        );
+      }
+
+      // Clean up from store
+      binaryStore.delete(reference.transferId);
+
+      // Write to temp file
+      const tempFile = path.join(
+        os.tmpdir(),
+        `harness-screenshot-${randomUUID()}.png`
+      );
+      await fs.writeFile(tempFile, data);
+
+      return {
+        path: tempFile,
+        width: metadata.width,
+        height: metadata.height,
+      };
+    },
+    'test.matchImageSnapshot': async (
+      screenshot: FileReference,
+      testPath: string,
+      options: ImageSnapshotOptions
+    ) => {
+      return await matchImageSnapshot(
+        screenshot,
+        testPath,
+        options,
+        context.platform.name
+      );
+    },
+  };
 
   const group = createBirpcGroup<BridgeClientFunctions, BridgeServerFunctions>(
-    {
-      reportReady: (device) => {
-        emitter.emit('ready', device);
-      },
-      emitEvent: (_, data) => {
-        emitter.emit('event', data);
-      },
-    } satisfies BridgeServerFunctions,
+    baseFunctions,
     [],
     {
       timeout,
+      onFunctionError: (error, functionName, args) => {
+        console.error('Function error', error, functionName, args);
+        throw error;
+      },
       onTimeoutError(functionName, args) {
         throw new DeviceNotRespondingError(functionName, args);
       },
@@ -76,16 +137,30 @@ export const getBridgeServer = async ({
 
       // TODO: Remove channel when connection is closed.
       clients.delete(ws);
+      emitter.emit('disconnect');
     });
 
     group.updateChannels((channels) => {
       channels.push({
         post: (data) => ws.send(data),
         on: (handler) => {
-          ws.on('message', (event: Buffer | ArrayBuffer | Buffer[]) => {
-            const message = event.toString();
-            handler(message);
-          });
+          ws.on(
+            'message',
+            (event: Buffer | ArrayBuffer | Buffer[], isBinary: boolean) => {
+              if (isBinary) {
+                const uint8Array = new Uint8Array(event as any);
+                try {
+                  const { transferId, data } = parseBinaryFrame(uint8Array);
+                  binaryStore.add(transferId, data);
+                  return;
+                } catch (error) {
+                  logger.warn('Failed to parse binary frame', error);
+                }
+              }
+              const message = event.toString();
+              handler(message);
+            }
+          );
         },
         serialize,
         deserialize,
@@ -96,6 +171,7 @@ export const getBridgeServer = async ({
   const dispose = () => {
     wss.close();
     emitter.removeAllListeners();
+    binaryStore.dispose();
   };
 
   return {

package/src/shared.ts

@@ -4,6 +4,73 @@ import type {
 } from './shared/test-runner.js';
 import type { TestCollectorEvents } from './shared/test-collector.js';
 import type { BundlerEvents } from './shared/bundler.js';
+import type { HarnessPlatform } from '@react-native-harness/platforms';
+
+export type FileReference = {
+  path: string;
+};
+
+export type ImageSnapshotOptions = {
+  /**
+   * The name of the snapshot. This is required and must be unique within the test.
+   */
+  name: string;
+  /**
+   * Comparison algorithm to use.
+   * @default 'pixelmatch'
+   */
+  comparisonMethod?: 'pixelmatch' | 'ssim';
+  /**
+   * Matching threshold for pixelmatch, ranges from 0 to 1. Smaller values make the comparison more sensitive.
+   * @default 0.1
+   */
+  threshold?: number;
+  /**
+   * Threshold for test failure.
+   */
+  failureThreshold?: number;
+  /**
+   * Type of failure threshold.
+   * @default 'pixel'
+   */
+  failureThresholdType?: 'pixel' | 'percent';
+  /**
+   * Minimum similarity score for SSIM comparison (0-1).
+   * @default 0.95
+   */
+  ssimThreshold?: number;
+  /**
+   * Regions to ignore during comparison.
+   */
+  ignoreRegions?: Array<{
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+  }>;
+  /**
+   * If true, disables detecting and ignoring anti-aliased pixels.
+   * @default false
+   */
+  includeAA?: boolean;
+  /**
+   * Blending factor of unchanged pixels in the diff output.
+   * Ranges from 0 for pure white to 1 for original brightness
+   * @default 0.1
+   */
+  alpha?: number;
+  /**
+   * The color of differing pixels in the diff output.
+   * @default [255, 0, 0]
+   */
+  diffColor?: [number, number, number];
+  /**
+   * An alternative color to use for dark on light differences to differentiate between "added" and "removed" parts.
+   * If not provided, all differing pixels use the color specified by `diffColor`.
+   * @default null
+   */
+  diffColorAlt?: [number, number, number];
+};
 
 export type {
   TestCollectorEvents,
@@ -36,7 +103,6 @@ export type {
   SetupFileBundlingFailedEvent,
   BundlerEvents,
 } from './shared/bundler.js';
-export { DeviceNotRespondingError } from './errors.js';
 
 export type DeviceDescriptor = {
   platform: 'ios' | 'android' | 'vega';
@@ -60,19 +126,43 @@ export type TestExecutionOptions = {
   testNamePattern?: string;
   setupFiles?: string[];
   setupFilesAfterEnv?: string[];
+  runner: string;
 };
 
 export type BridgeClientFunctions = {
   runTests: (
     path: string,
-    options?: TestExecutionOptions
+    options: TestExecutionOptions
   ) => Promise<TestSuiteResult>;
 };
 
+export type BinaryDataReference = {
+  type: 'binary';
+  transferId: number;
+  size: number;
+  mimeType: 'image/png';
+};
+
+export type ScreenshotData = BinaryDataReference;
+
 export type BridgeServerFunctions = {
   reportReady: (device: DeviceDescriptor) => void;
   emitEvent: <TEvent extends BridgeEvents>(
     event: TEvent['type'],
     data: TEvent
   ) => void;
+  'device.screenshot.receive': (
+    reference: BinaryDataReference,
+    metadata: { width: number; height: number }
+  ) => Promise<FileReference>;
+  'test.matchImageSnapshot': (
+    screenshot: FileReference,
+    testPath: string,
+    options: ImageSnapshotOptions,
+    runner: string
+  ) => Promise<{ pass: boolean; message: string }>;
+};
+
+export type HarnessContext = {
+  platform: HarnessPlatform;
 };

package/tsconfig.json

@@ -6,6 +6,9 @@
     {
       "path": "../tools"
     },
+    {
+      "path": "../platforms"
+    },
     {
       "path": "./tsconfig.lib.json"
     }

package/tsconfig.lib.json

@@ -14,6 +14,9 @@
   "references": [
     {
       "path": "../tools/tsconfig.lib.json"
+    },
+    {
+      "path": "../platforms/tsconfig.lib.json"
     }
   ]
 }