@hardwarebridge/client 1.0.0

package/src/__tests__/hardware-bridge-client.test.ts

@@ -0,0 +1,248 @@
+import { HardwareBridgeClient } from '../core/hardware-bridge-client';
+import { ConnectionConfig, ClientOptions } from '../types';
+
+// Mock WebSocket
+class MockWebSocket {
+  static CONNECTING = 0;
+  static OPEN = 1;
+  static CLOSING = 2;
+  static CLOSED = 3;
+
+  readyState = MockWebSocket.CLOSED;
+  onopen: (() => void) | null = null;
+  onclose: (() => void) | null = null;
+  onmessage: ((event: { data: string }) => void) | null = null;
+  onerror: ((error: Error) => void) | null = null;
+
+  constructor(_url: string, _protocols?: string | string[]) {
+    setTimeout(() => {
+      this.readyState = MockWebSocket.OPEN;
+      if (this.onopen) this.onopen();
+    }, 10);
+  }
+
+  send(_data: string): void {
+    // Mock send
+  }
+
+  close(): void {
+    this.readyState = MockWebSocket.CLOSED;
+    if (this.onclose) this.onclose();
+  }
+}
+
+// Store original WebSocket
+const OriginalWebSocket = global.WebSocket;
+
+describe('HardwareBridgeClient', () => {
+  beforeAll(() => {
+    // @ts-expect-error - Mock WebSocket globally
+    global.WebSocket = MockWebSocket;
+  });
+
+  afterAll(() => {
+    global.WebSocket = OriginalWebSocket;
+  });
+
+  describe('constructor', () => {
+    it('should create client with default options', () => {
+      const config: ConnectionConfig = {
+        url: 'ws://localhost:9876',
+      };
+      const client = new HardwareBridgeClient(config);
+      expect(client).toBeInstanceOf(HardwareBridgeClient);
+    });
+
+    it('should create client with custom options', () => {
+      const config: ConnectionConfig = {
+        url: 'ws://localhost:9876',
+      };
+      const options: ClientOptions = {
+        autoReconnect: false,
+        timeout: 5000,
+        debug: true,
+      };
+      const client = new HardwareBridgeClient(config, options);
+      expect(client).toBeInstanceOf(HardwareBridgeClient);
+    });
+
+    it('should accept secure WebSocket URL', () => {
+      const config: ConnectionConfig = {
+        url: 'wss://localhost:9876',
+      };
+      const client = new HardwareBridgeClient(config);
+      expect(client).toBeInstanceOf(HardwareBridgeClient);
+    });
+  });
+
+  describe('connection state', () => {
+    it('should report not connected initially', () => {
+      const client = new HardwareBridgeClient({ url: 'ws://localhost:9876' });
+      expect(client.isConnected).toBe(false);
+    });
+
+    it('should report not connecting initially', () => {
+      const client = new HardwareBridgeClient({ url: 'ws://localhost:9876' });
+      expect(client.isConnecting).toBe(false);
+    });
+
+    it('should return connection status string', () => {
+      const client = new HardwareBridgeClient({ url: 'ws://localhost:9876' });
+      const status = client.getConnectionStatus();
+      expect(typeof status).toBe('string');
+    });
+  });
+
+  describe('dispose', () => {
+    it('should dispose client without error', () => {
+      const client = new HardwareBridgeClient({ url: 'ws://localhost:9876' });
+      expect(() => client.dispose()).not.toThrow();
+    });
+  });
+
+  describe('connection management', () => {
+    it('should have connect method', () => {
+      const client = new HardwareBridgeClient({ url: 'ws://localhost:9876' });
+      expect(typeof client.connect).toBe('function');
+    });
+
+    it('should have disconnect method', () => {
+      const client = new HardwareBridgeClient({ url: 'ws://localhost:9876' });
+      expect(typeof client.disconnect).toBe('function');
+    });
+
+    it('should have onConnectionStateChange method', () => {
+      const client = new HardwareBridgeClient({ url: 'ws://localhost:9876' });
+      expect(typeof client.onConnectionStateChange).toBe('function');
+    });
+  });
+
+  describe('device operations', () => {
+    it('should have enumerateDevices method', () => {
+      const client = new HardwareBridgeClient({ url: 'ws://localhost:9876' });
+      expect(typeof client.enumerateDevices).toBe('function');
+    });
+
+    it('should have getDevice method', () => {
+      const client = new HardwareBridgeClient({ url: 'ws://localhost:9876' });
+      expect(typeof client.getDevice).toBe('function');
+    });
+
+    it('should have watchDevices method', () => {
+      const client = new HardwareBridgeClient({ url: 'ws://localhost:9876' });
+      expect(typeof client.watchDevices).toBe('function');
+    });
+
+    it('should have unwatchDevices method', () => {
+      const client = new HardwareBridgeClient({ url: 'ws://localhost:9876' });
+      expect(typeof client.unwatchDevices).toBe('function');
+    });
+  });
+
+  describe('printer operations', () => {
+    it('should have print method', () => {
+      const client = new HardwareBridgeClient({ url: 'ws://localhost:9876' });
+      expect(typeof client.print).toBe('function');
+    });
+
+    it('should have getPrinterStatus method', () => {
+      const client = new HardwareBridgeClient({ url: 'ws://localhost:9876' });
+      expect(typeof client.getPrinterStatus).toBe('function');
+    });
+
+    it('should have getPrinterCapabilities method', () => {
+      const client = new HardwareBridgeClient({ url: 'ws://localhost:9876' });
+      expect(typeof client.getPrinterCapabilities).toBe('function');
+    });
+  });
+
+  describe('serial port operations', () => {
+    it('should have openSerialPort method', () => {
+      const client = new HardwareBridgeClient({ url: 'ws://localhost:9876' });
+      expect(typeof client.openSerialPort).toBe('function');
+    });
+
+    it('should have closeSerialPort method', () => {
+      const client = new HardwareBridgeClient({ url: 'ws://localhost:9876' });
+      expect(typeof client.closeSerialPort).toBe('function');
+    });
+
+    it('should have sendSerialData method', () => {
+      const client = new HardwareBridgeClient({ url: 'ws://localhost:9876' });
+      expect(typeof client.sendSerialData).toBe('function');
+    });
+
+    it('should have receiveSerialData method', () => {
+      const client = new HardwareBridgeClient({ url: 'ws://localhost:9876' });
+      expect(typeof client.receiveSerialData).toBe('function');
+    });
+
+    it('should have getSerialPortStatus method', () => {
+      const client = new HardwareBridgeClient({ url: 'ws://localhost:9876' });
+      expect(typeof client.getSerialPortStatus).toBe('function');
+    });
+  });
+
+  describe('USB HID operations', () => {
+    it('should have openUsbDevice method', () => {
+      const client = new HardwareBridgeClient({ url: 'ws://localhost:9876' });
+      expect(typeof client.openUsbDevice).toBe('function');
+    });
+
+    it('should have closeUsbDevice method', () => {
+      const client = new HardwareBridgeClient({ url: 'ws://localhost:9876' });
+      expect(typeof client.closeUsbDevice).toBe('function');
+    });
+
+    it('should have sendUsbReport method', () => {
+      const client = new HardwareBridgeClient({ url: 'ws://localhost:9876' });
+      expect(typeof client.sendUsbReport).toBe('function');
+    });
+
+    it('should have receiveUsbReport method', () => {
+      const client = new HardwareBridgeClient({ url: 'ws://localhost:9876' });
+      expect(typeof client.receiveUsbReport).toBe('function');
+    });
+
+    it('should have getUsbDeviceStatus method', () => {
+      const client = new HardwareBridgeClient({ url: 'ws://localhost:9876' });
+      expect(typeof client.getUsbDeviceStatus).toBe('function');
+    });
+  });
+
+  describe('queue operations', () => {
+    it('should have getQueueStatus method', () => {
+      const client = new HardwareBridgeClient({ url: 'ws://localhost:9876' });
+      expect(typeof client.getQueueStatus).toBe('function');
+    });
+
+    it('should have getQueueJobs method', () => {
+      const client = new HardwareBridgeClient({ url: 'ws://localhost:9876' });
+      expect(typeof client.getQueueJobs).toBe('function');
+    });
+
+    it('should have cancelQueueJob method', () => {
+      const client = new HardwareBridgeClient({ url: 'ws://localhost:9876' });
+      expect(typeof client.cancelQueueJob).toBe('function');
+    });
+  });
+
+  describe('system operations', () => {
+    it('should have getSystemInfo method', () => {
+      const client = new HardwareBridgeClient({ url: 'ws://localhost:9876' });
+      expect(typeof client.getSystemInfo).toBe('function');
+    });
+
+    it('should have getSystemHealth method', () => {
+      const client = new HardwareBridgeClient({ url: 'ws://localhost:9876' });
+      expect(typeof client.getSystemHealth).toBe('function');
+    });
+  });
+
+  describe('utility methods', () => {
+    it('should have waitForConnection method', () => {
+      const client = new HardwareBridgeClient({ url: 'ws://localhost:9876' });
+      expect(typeof client.waitForConnection).toBe('function');
+    });
+  });
+});

package/src/__tests__/types.test.ts

@@ -0,0 +1,153 @@
+import {
+  ConnectionConfig,
+  ClientOptions,
+  DeviceInfo,
+  PrintFormat,
+  SerialPortConfig,
+  QueueStatus,
+  SystemHealth,
+} from '../types';
+
+describe('Types', () => {
+  describe('ConnectionConfig', () => {
+    it('should accept valid connection config', () => {
+      const config: ConnectionConfig = {
+        url: 'ws://localhost:9876',
+      };
+      expect(config.url).toBe('ws://localhost:9876');
+    });
+
+    it('should accept connection config with all options', () => {
+      const config: ConnectionConfig = {
+        url: 'wss://localhost:9876',
+        protocols: ['jsonrpc-2.0'],
+        timeout: 30000,
+        reconnectInterval: 5000,
+        maxReconnectAttempts: 10,
+      };
+      expect(config.url).toBe('wss://localhost:9876');
+      expect(config.protocols).toEqual(['jsonrpc-2.0']);
+      expect(config.timeout).toBe(30000);
+    });
+  });
+
+  describe('ClientOptions', () => {
+    it('should accept valid client options', () => {
+      const options: ClientOptions = {
+        autoReconnect: true,
+        reconnectInterval: 5000,
+        maxReconnectAttempts: 10,
+        timeout: 30000,
+        debug: false,
+      };
+      expect(options.autoReconnect).toBe(true);
+      expect(options.timeout).toBe(30000);
+    });
+
+    it('should accept partial client options', () => {
+      const options: ClientOptions = {
+        debug: true,
+      };
+      expect(options.debug).toBe(true);
+      expect(options.autoReconnect).toBeUndefined();
+    });
+  });
+
+  describe('DeviceInfo', () => {
+    it('should accept valid device info', () => {
+      const device: DeviceInfo = {
+        id: 'printer_1',
+        name: 'Test Printer',
+        type: 'printer',
+        status: 'available',
+        manufacturer: 'Test Corp',
+        model: 'Model X',
+        serialNumber: 'SN12345',
+        properties: {},
+        lastSeen: new Date(),
+        isConnected: true,
+      };
+      expect(device.id).toBe('printer_1');
+      expect(device.type).toBe('printer');
+      expect(device.isConnected).toBe(true);
+    });
+  });
+
+  describe('PrintFormat', () => {
+    it('should accept valid print formats', () => {
+      const formats: PrintFormat[] = ['raw', 'escpos', 'zpl', 'epl'];
+      expect(formats).toHaveLength(4);
+      expect(formats).toContain('escpos');
+      expect(formats).toContain('zpl');
+    });
+  });
+
+  describe('SerialPortConfig', () => {
+    it('should accept valid serial port config', () => {
+      const config: SerialPortConfig = {
+        baudRate: 9600,
+        dataBits: 8,
+        stopBits: '1',
+        parity: 'None',
+        flowControl: 'None',
+      };
+      expect(config.baudRate).toBe(9600);
+      expect(config.dataBits).toBe(8);
+    });
+
+    it('should accept different configurations', () => {
+      const config1: SerialPortConfig = {
+        baudRate: 115200,
+        dataBits: 8,
+        stopBits: '1',
+        parity: 'None',
+        flowControl: 'None',
+      };
+
+      const config2: SerialPortConfig = {
+        baudRate: 9600,
+        dataBits: 7,
+        stopBits: '2',
+        parity: 'Even',
+        flowControl: 'XOnXOff',
+      };
+
+      expect(config1.baudRate).toBe(115200);
+      expect(config2.parity).toBe('Even');
+    });
+  });
+
+  describe('QueueStatus', () => {
+    it('should accept valid queue status', () => {
+      const status: QueueStatus = {
+        totalJobs: 100,
+        pendingJobs: 5,
+        processingJobs: 2,
+        completedJobs: 90,
+        failedJobs: 3,
+        lastProcessed: new Date(),
+        averageProcessingTime: 150,
+      };
+      expect(status.totalJobs).toBe(100);
+      expect(status.pendingJobs).toBe(5);
+    });
+  });
+
+  describe('SystemHealth', () => {
+    it('should accept valid system health', () => {
+      const health: SystemHealth = {
+        status: 'healthy',
+        timestamp: new Date(),
+        totalDevices: 5,
+        connectedDevices: 3,
+        activeConnections: 2,
+        jobsInQueue: 10,
+        cpuUsage: 25.5,
+        memoryUsage: 512,
+        deviceHealth: {},
+      };
+      expect(health.status).toBe('healthy');
+      expect(health.connectedDevices).toBe(3);
+    });
+  });
+});

package/src/__tests__/websocket-client.test.ts

@@ -0,0 +1,198 @@
+import { WebSocketClient } from '../core/websocket-client';
+import { ConnectionConfig, ClientOptions } from '../types';
+
+// Mock WebSocket
+class MockWebSocket {
+  static CONNECTING = 0;
+  static OPEN = 1;
+  static CLOSING = 2;
+  static CLOSED = 3;
+
+  url: string;
+  readyState = MockWebSocket.CLOSED;
+  onopen: (() => void) | null = null;
+  onclose: ((event: { code: number; reason: string }) => void) | null = null;
+  onmessage: ((event: { data: string }) => void) | null = null;
+  onerror: ((error: Error) => void) | null = null;
+
+  private messageQueue: string[] = [];
+
+  constructor(url: string, _protocols?: string | string[]) {
+    this.url = url;
+    // Simulate async connection
+    setTimeout(() => {
+      this.readyState = MockWebSocket.OPEN;
+      if (this.onopen) this.onopen();
+    }, 10);
+  }
+
+  send(data: string): void {
+    this.messageQueue.push(data);
+  }
+
+  close(code?: number, reason?: string): void {
+    this.readyState = MockWebSocket.CLOSED;
+    if (this.onclose) this.onclose({ code: code || 1000, reason: reason || '' });
+  }
+
+  // Helper to simulate receiving a message
+  simulateMessage(data: string): void {
+    if (this.onmessage) {
+      this.onmessage({ data });
+    }
+  }
+
+  // Helper to get sent messages
+  getSentMessages(): string[] {
+    return [...this.messageQueue];
+  }
+}
+
+// Store original WebSocket
+const OriginalWebSocket = global.WebSocket;
+
+describe('WebSocketClient', () => {
+  beforeAll(() => {
+    // @ts-expect-error - Mock WebSocket globally
+    global.WebSocket = MockWebSocket;
+  });
+
+  afterAll(() => {
+    global.WebSocket = OriginalWebSocket;
+  });
+
+  describe('constructor', () => {
+    it('should create WebSocketClient with config', () => {
+      const config: ConnectionConfig = {
+        url: 'ws://localhost:9876',
+      };
+      const client = new WebSocketClient(config);
+      expect(client).toBeInstanceOf(WebSocketClient);
+    });
+
+    it('should create WebSocketClient with options', () => {
+      const config: ConnectionConfig = {
+        url: 'ws://localhost:9876',
+      };
+      const options: ClientOptions = {
+        autoReconnect: true,
+        reconnectInterval: 1000,
+        maxReconnectAttempts: 5,
+        timeout: 10000,
+        debug: true,
+      };
+      const client = new WebSocketClient(config, options);
+      expect(client).toBeInstanceOf(WebSocketClient);
+    });
+  });
+
+  describe('connection state', () => {
+    it('should report not connected initially', () => {
+      const client = new WebSocketClient({ url: 'ws://localhost:9876' });
+      expect(client.isConnected).toBe(false);
+    });
+
+    it('should report not connecting initially', () => {
+      const client = new WebSocketClient({ url: 'ws://localhost:9876' });
+      expect(client.isConnecting).toBe(false);
+    });
+
+    it('should return disconnected status initially', () => {
+      const client = new WebSocketClient({ url: 'ws://localhost:9876' });
+      expect(client.getConnectionStatus()).toBe('disconnected');
+    });
+  });
+
+  describe('connect', () => {
+    it('should connect successfully', async () => {
+      const client = new WebSocketClient({ url: 'ws://localhost:9876' });
+      await client.connect();
+      expect(client.isConnected).toBe(true);
+    });
+
+    it('should report connecting status during connection', () => {
+      const client = new WebSocketClient({ url: 'ws://localhost:9876' });
+      client.connect();
+      expect(client.isConnecting).toBe(true);
+    });
+
+    it('should report connected status after connection', async () => {
+      const client = new WebSocketClient({ url: 'ws://localhost:9876' });
+      await client.connect();
+      expect(client.getConnectionStatus()).toBe('connected');
+    });
+  });
+
+  describe('disconnect', () => {
+    it('should disconnect successfully', async () => {
+      const client = new WebSocketClient({ url: 'ws://localhost:9876' });
+      await client.connect();
+      client.disconnect();
+      expect(client.isConnected).toBe(false);
+    });
+
+    it('should handle disconnect when not connected', () => {
+      const client = new WebSocketClient({ url: 'ws://localhost:9876' });
+      expect(() => client.disconnect()).not.toThrow();
+    });
+  });
+
+  describe('onConnectionStateChange', () => {
+    it('should register connection state listener', () => {
+      const client = new WebSocketClient({ url: 'ws://localhost:9876' });
+      const listener = jest.fn();
+      client.onConnectionStateChange(listener);
+      expect(typeof client.onConnectionStateChange).toBe('function');
+    });
+
+    it('should call listener on connect', async () => {
+      const client = new WebSocketClient({ url: 'ws://localhost:9876' });
+      const listener = jest.fn();
+      client.onConnectionStateChange(listener);
+      await client.connect();
+      expect(listener).toHaveBeenCalled();
+    });
+  });
+
+  describe('onDeviceEvent', () => {
+    it('should register device event listener', () => {
+      const client = new WebSocketClient({ url: 'ws://localhost:9876' });
+      const listener = jest.fn();
+      client.onDeviceEvent(listener);
+      expect(typeof client.onDeviceEvent).toBe('function');
+    });
+  });
+
+  describe('dispose', () => {
+    it('should dispose client', () => {
+      const client = new WebSocketClient({ url: 'ws://localhost:9876' });
+      expect(() => client.dispose()).not.toThrow();
+    });
+
+    it('should disconnect on dispose', async () => {
+      const client = new WebSocketClient({ url: 'ws://localhost:9876' });
+      await client.connect();
+      client.dispose();
+      expect(client.isConnected).toBe(false);
+    });
+  });
+
+  describe('sendRequest', () => {
+    it('should have sendRequest method', () => {
+      const client = new WebSocketClient({ url: 'ws://localhost:9876' });
+      expect(typeof client.sendRequest).toBe('function');
+    });
+
+    it('should reject when not connected', async () => {
+      const client = new WebSocketClient({ url: 'ws://localhost:9876' });
+      await expect(client.sendRequest('test.method')).rejects.toThrow();
+    });
+  });
+
+  describe('sendNotification', () => {
+    it('should have sendNotification method', () => {
+      const client = new WebSocketClient({ url: 'ws://localhost:9876' });
+      expect(typeof client.sendNotification).toBe('function');
+    });
+  });
+});