react-native-ble-nitro 1.0.0-alpha.1

package/src/__tests__/compatibility/deviceWrapper.test.ts

@@ -0,0 +1,563 @@
+/**
+ * deviceWrapper.test.ts
+ * React Native BLE Nitro - Device Wrapper Tests
+ * Copyright © 2025 Zyke (https://zyke.co)
+ */
+
+import { DeviceWrapper, ServiceWrapper, CharacteristicWrapper, DescriptorWrapper } from '../../compatibility/deviceWrapper';
+import { ConnectionPriority, CharacteristicSubscriptionType } from '../../specs/types';
+
+// Mock Nitro Device
+const createMockNitroDevice = () => ({
+  id: 'test-device-id',
+  deviceName: 'Test Device',
+  rssi: -50,
+  mtu: 247,
+  manufacturerData: 'AQIDBA==', // [1, 2, 3, 4] in base64
+  serviceData: [
+    { uuid: '180f', data: 'ZA==' }, // Battery service with value 100
+    { uuid: '1234', data: 'dGVzdA==' } // Custom service with "test"
+  ],
+  serviceUUIDs: ['180f', '1234-5678-9abc-def0-123456789abc'],
+  localName: 'Local Test Device',
+  txPowerLevel: 4,
+  solicitedServiceUUIDs: ['abcd'],
+  isConnectable: true,
+  overflowServiceUUIDs: ['efgh'],
+  rawScanRecord: 'AQIDBAU=',
+  
+  // Mock methods
+  requestConnectionPriority: jest.fn().mockResolvedValue({}),
+  readRSSI: jest.fn().mockResolvedValue({}),
+  requestMTU: jest.fn().mockResolvedValue({}),
+  connect: jest.fn().mockResolvedValue({}),
+  cancelConnection: jest.fn().mockResolvedValue({}),
+  isConnected: jest.fn().mockResolvedValue(true),
+  onDisconnected: jest.fn().mockReturnValue({ remove: jest.fn() }),
+  discoverAllServicesAndCharacteristics: jest.fn().mockResolvedValue({}),
+  services: jest.fn().mockResolvedValue([]),
+  characteristicsForService: jest.fn().mockResolvedValue([]),
+  readCharacteristicForService: jest.fn().mockResolvedValue({}),
+  writeCharacteristicWithResponseForService: jest.fn().mockResolvedValue({}),
+  writeCharacteristicWithoutResponseForService: jest.fn().mockResolvedValue({}),
+  monitorCharacteristicForService: jest.fn().mockReturnValue({ remove: jest.fn() }),
+  descriptorsForService: jest.fn().mockResolvedValue([]),
+  readDescriptorForService: jest.fn().mockResolvedValue({}),
+  writeDescriptorForService: jest.fn().mockResolvedValue({})
+});
+
+describe('DeviceWrapper', () => {
+  let mockNitroDevice: ReturnType<typeof createMockNitroDevice>;
+  let deviceWrapper: DeviceWrapper;
+
+  beforeEach(() => {
+    mockNitroDevice = createMockNitroDevice();
+    deviceWrapper = new DeviceWrapper(mockNitroDevice);
+    jest.clearAllMocks();
+  });
+
+  describe('Property Mapping', () => {
+    it('should map device identification properties correctly', () => {
+      expect(deviceWrapper.id).toBe('test-device-id');
+      expect(deviceWrapper.name).toBe('Test Device'); // Maps from deviceName
+      expect(deviceWrapper.rssi).toBe(-50);
+      expect(deviceWrapper.mtu).toBe(247);
+    });
+
+    it('should handle null device name', () => {
+      mockNitroDevice.deviceName = null;
+      const wrapper = new DeviceWrapper(mockNitroDevice);
+      expect(wrapper.name).toBeNull();
+    });
+
+    it('should map advertisement data properties', () => {
+      expect(deviceWrapper.manufacturerData).toBe('AQIDBA==');
+      expect(deviceWrapper.rawScanRecord).toBe('AQIDBAU=');
+      expect(deviceWrapper.localName).toBe('Local Test Device');
+      expect(deviceWrapper.txPowerLevel).toBe(4);
+      expect(deviceWrapper.isConnectable).toBe(true);
+    });
+
+    it('should map service-related properties', () => {
+      expect(deviceWrapper.serviceUUIDs).toEqual(['180f', '1234-5678-9abc-def0-123456789abc']);
+      expect(deviceWrapper.solicitedServiceUUIDs).toEqual(['abcd']);
+      expect(deviceWrapper.overflowServiceUUIDs).toEqual(['efgh']);
+    });
+
+    it('should convert service data array to map format', () => {
+      const serviceData = deviceWrapper.serviceData;
+      expect(serviceData).toEqual({
+        '180f': 'ZA==',
+        '1234': 'dGVzdA=='
+      });
+    });
+
+    it('should handle null service data', () => {
+      mockNitroDevice.serviceData = null;
+      const wrapper = new DeviceWrapper(mockNitroDevice);
+      expect(wrapper.serviceData).toBeNull();
+    });
+  });
+
+  describe('Connection Management', () => {
+    it('should request connection priority', async () => {
+      mockNitroDevice.requestConnectionPriority.mockResolvedValue(mockNitroDevice);
+      
+      const result = await deviceWrapper.requestConnectionPriority(
+        ConnectionPriority.High,
+        'transaction-123'
+      );
+
+      expect(result).toBeInstanceOf(DeviceWrapper);
+      expect(mockNitroDevice.requestConnectionPriority).toHaveBeenCalledWith(
+        ConnectionPriority.High,
+        'transaction-123'
+      );
+    });
+
+    it('should read RSSI', async () => {
+      const updatedDevice = { ...mockNitroDevice, rssi: -45 };
+      mockNitroDevice.readRSSI.mockResolvedValue(updatedDevice);
+
+      const result = await deviceWrapper.readRSSI('transaction-456');
+
+      expect(result).toBeInstanceOf(DeviceWrapper);
+      expect(mockNitroDevice.readRSSI).toHaveBeenCalledWith('transaction-456');
+    });
+
+    it('should request MTU change', async () => {
+      const updatedDevice = { ...mockNitroDevice, mtu: 512 };
+      mockNitroDevice.requestMTU.mockResolvedValue(updatedDevice);
+
+      const result = await deviceWrapper.requestMTU(512, 'mtu-transaction');
+
+      expect(result).toBeInstanceOf(DeviceWrapper);
+      expect(mockNitroDevice.requestMTU).toHaveBeenCalledWith(512, 'mtu-transaction');
+    });
+
+    it('should connect with default options', async () => {
+      mockNitroDevice.connect.mockResolvedValue(mockNitroDevice);
+
+      const result = await deviceWrapper.connect();
+
+      expect(result).toBeInstanceOf(DeviceWrapper);
+      expect(mockNitroDevice.connect).toHaveBeenCalledWith({
+        autoConnect: false,
+        requestMTU: 23,
+        timeout: 0
+      });
+    });
+
+    it('should connect with custom options', async () => {
+      mockNitroDevice.connect.mockResolvedValue(mockNitroDevice);
+
+      const result = await deviceWrapper.connect({
+        autoConnect: true,
+        requestMTU: 247,
+        timeout: 5000
+      });
+
+      expect(result).toBeInstanceOf(DeviceWrapper);
+      expect(mockNitroDevice.connect).toHaveBeenCalledWith({
+        autoConnect: true,
+        requestMTU: 247,
+        timeout: 5000
+      });
+    });
+
+    it('should cancel connection', async () => {
+      mockNitroDevice.cancelConnection.mockResolvedValue(mockNitroDevice);
+
+      const result = await deviceWrapper.cancelConnection();
+
+      expect(result).toBeInstanceOf(DeviceWrapper);
+      expect(mockNitroDevice.cancelConnection).toHaveBeenCalled();
+    });
+
+    it('should check connection status', async () => {
+      mockNitroDevice.isConnected.mockResolvedValue(true);
+
+      const result = await deviceWrapper.isConnected();
+
+      expect(result).toBe(true);
+      expect(mockNitroDevice.isConnected).toHaveBeenCalled();
+    });
+
+    it('should handle disconnection listener', () => {
+      const listener = jest.fn();
+      const mockSubscription = { remove: jest.fn() };
+      mockNitroDevice.onDisconnected.mockReturnValue(mockSubscription);
+
+      const subscription = deviceWrapper.onDisconnected(listener);
+
+      expect(subscription).toBe(mockSubscription);
+      expect(mockNitroDevice.onDisconnected).toHaveBeenCalled();
+
+      // Verify the listener wrapper is called correctly
+      const callArgs = mockNitroDevice.onDisconnected.mock.calls[0][0];
+      const mockError = new Error('Disconnected');
+      const mockDevice = { ...mockNitroDevice };
+
+      callArgs(mockError, mockDevice);
+      expect(listener).toHaveBeenCalledWith(mockError, expect.any(DeviceWrapper));
+    });
+  });
+
+  describe('Service Discovery', () => {
+    it('should discover all services and characteristics', async () => {
+      mockNitroDevice.discoverAllServicesAndCharacteristics.mockResolvedValue(mockNitroDevice);
+
+      const result = await deviceWrapper.discoverAllServicesAndCharacteristics('discovery-tx');
+
+      expect(result).toBeInstanceOf(DeviceWrapper);
+      expect(mockNitroDevice.discoverAllServicesAndCharacteristics).toHaveBeenCalledWith('discovery-tx');
+    });
+
+    it('should get services list', async () => {
+      const mockServices = [
+        { id: 1, uuid: '180f', deviceID: 'test-device-id', isPrimary: true }
+      ];
+      mockNitroDevice.services.mockResolvedValue(mockServices);
+
+      const result = await deviceWrapper.services();
+
+      expect(result).toHaveLength(1);
+      expect(result[0]).toBeInstanceOf(ServiceWrapper);
+      expect(mockNitroDevice.services).toHaveBeenCalled();
+    });
+  });
+
+  describe('Characteristic Operations', () => {
+    const serviceUUID = '180f';
+    const characteristicUUID = '2a19';
+
+    it('should get characteristics for service', async () => {
+      const mockCharacteristics = [
+        {
+          id: 1,
+          uuid: characteristicUUID,
+          serviceID: 1,
+          serviceUUID,
+          deviceID: 'test-device-id',
+          isReadable: true,
+          isWritableWithResponse: false,
+          isWritableWithoutResponse: false,
+          isNotifiable: true,
+          isNotifying: false,
+          isIndicatable: false,
+          value: null
+        }
+      ];
+      mockNitroDevice.characteristicsForService.mockResolvedValue(mockCharacteristics);
+
+      const result = await deviceWrapper.characteristicsForService(serviceUUID);
+
+      expect(result).toHaveLength(1);
+      expect(result[0]).toBeInstanceOf(CharacteristicWrapper);
+      expect(mockNitroDevice.characteristicsForService).toHaveBeenCalledWith(serviceUUID);
+    });
+
+    it('should read characteristic', async () => {
+      const mockCharacteristic = {
+        id: 1,
+        uuid: characteristicUUID,
+        value: 'dGVzdA=='
+      };
+      mockNitroDevice.readCharacteristicForService.mockResolvedValue(mockCharacteristic);
+
+      const result = await deviceWrapper.readCharacteristicForService(
+        serviceUUID,
+        characteristicUUID,
+        'read-tx'
+      );
+
+      expect(result).toBeInstanceOf(CharacteristicWrapper);
+      expect(mockNitroDevice.readCharacteristicForService).toHaveBeenCalledWith(
+        serviceUUID,
+        characteristicUUID,
+        'read-tx'
+      );
+    });
+
+    it('should write characteristic with response', async () => {
+      const value = 'dGVzdCB2YWx1ZQ==';
+      const mockCharacteristic = {
+        id: 1,
+        uuid: characteristicUUID,
+        value
+      };
+      mockNitroDevice.writeCharacteristicWithResponseForService.mockResolvedValue(mockCharacteristic);
+
+      const result = await deviceWrapper.writeCharacteristicWithResponseForService(
+        serviceUUID,
+        characteristicUUID,
+        value,
+        'write-tx'
+      );
+
+      expect(result).toBeInstanceOf(CharacteristicWrapper);
+      expect(mockNitroDevice.writeCharacteristicWithResponseForService).toHaveBeenCalledWith(
+        serviceUUID,
+        characteristicUUID,
+        value,
+        'write-tx'
+      );
+    });
+
+    it('should write characteristic without response', async () => {
+      const value = 'dGVzdA==';
+      const mockCharacteristic = {
+        id: 1,
+        uuid: characteristicUUID,
+        value
+      };
+      mockNitroDevice.writeCharacteristicWithoutResponseForService.mockResolvedValue(mockCharacteristic);
+
+      const result = await deviceWrapper.writeCharacteristicWithoutResponseForService(
+        serviceUUID,
+        characteristicUUID,
+        value
+      );
+
+      expect(result).toBeInstanceOf(CharacteristicWrapper);
+      expect(mockNitroDevice.writeCharacteristicWithoutResponseForService).toHaveBeenCalledWith(
+        serviceUUID,
+        characteristicUUID,
+        value,
+        undefined
+      );
+    });
+
+    it('should monitor characteristic for changes', () => {
+      const listener = jest.fn();
+      const mockSubscription = { remove: jest.fn() };
+      mockNitroDevice.monitorCharacteristicForService.mockReturnValue(mockSubscription);
+
+      const result = deviceWrapper.monitorCharacteristicForService(
+        serviceUUID,
+        characteristicUUID,
+        listener,
+        'monitor-tx',
+        'notification'
+      );
+
+      expect(result).toBe(mockSubscription);
+      expect(mockNitroDevice.monitorCharacteristicForService).toHaveBeenCalledWith(
+        serviceUUID,
+        characteristicUUID,
+        expect.any(Function),
+        'monitor-tx',
+        CharacteristicSubscriptionType.Notification
+      );
+
+      // Test the listener wrapper
+      const callArgs = mockNitroDevice.monitorCharacteristicForService.mock.calls[0][2];
+      const mockError = null;
+      const mockCharacteristic = { id: 1, uuid: characteristicUUID };
+
+      callArgs(mockError, mockCharacteristic);
+      expect(listener).toHaveBeenCalledWith(mockError, expect.any(CharacteristicWrapper));
+    });
+
+    it('should monitor characteristic without subscription type', () => {
+      const listener = jest.fn();
+      const mockSubscription = { remove: jest.fn() };
+      mockNitroDevice.monitorCharacteristicForService.mockReturnValue(mockSubscription);
+
+      deviceWrapper.monitorCharacteristicForService(
+        serviceUUID,
+        characteristicUUID,
+        listener
+      );
+
+      expect(mockNitroDevice.monitorCharacteristicForService).toHaveBeenCalledWith(
+        serviceUUID,
+        characteristicUUID,
+        expect.any(Function),
+        undefined,
+        undefined
+      );
+    });
+  });
+
+  describe('Descriptor Operations', () => {
+    const serviceUUID = '180f';
+    const characteristicUUID = '2a19';
+    const descriptorUUID = '2902';
+
+    it('should get descriptors for characteristic', async () => {
+      const mockDescriptors = [
+        {
+          id: 1,
+          uuid: descriptorUUID,
+          characteristicID: 1,
+          characteristicUUID,
+          serviceID: 1,
+          serviceUUID,
+          deviceID: 'test-device-id',
+          value: null
+        }
+      ];
+      mockNitroDevice.descriptorsForService.mockResolvedValue(mockDescriptors);
+
+      const result = await deviceWrapper.descriptorsForService(serviceUUID, characteristicUUID);
+
+      expect(result).toHaveLength(1);
+      expect(result[0]).toBeInstanceOf(DescriptorWrapper);
+      expect(mockNitroDevice.descriptorsForService).toHaveBeenCalledWith(
+        serviceUUID,
+        characteristicUUID
+      );
+    });
+
+    it('should read descriptor', async () => {
+      const mockDescriptor = {
+        id: 1,
+        uuid: descriptorUUID,
+        value: 'AQA=' // [1, 0] in base64
+      };
+      mockNitroDevice.readDescriptorForService.mockResolvedValue(mockDescriptor);
+
+      const result = await deviceWrapper.readDescriptorForService(
+        serviceUUID,
+        characteristicUUID,
+        descriptorUUID,
+        'descriptor-read-tx'
+      );
+
+      expect(result).toBeInstanceOf(DescriptorWrapper);
+      expect(mockNitroDevice.readDescriptorForService).toHaveBeenCalledWith(
+        serviceUUID,
+        characteristicUUID,
+        descriptorUUID,
+        'descriptor-read-tx'
+      );
+    });
+
+    it('should write descriptor', async () => {
+      const value = 'AQA=';
+      const mockDescriptor = {
+        id: 1,
+        uuid: descriptorUUID,
+        value
+      };
+      mockNitroDevice.writeDescriptorForService.mockResolvedValue(mockDescriptor);
+
+      const result = await deviceWrapper.writeDescriptorForService(
+        serviceUUID,
+        characteristicUUID,
+        descriptorUUID,
+        value,
+        'descriptor-write-tx'
+      );
+
+      expect(result).toBeInstanceOf(DescriptorWrapper);
+      expect(mockNitroDevice.writeDescriptorForService).toHaveBeenCalledWith(
+        serviceUUID,
+        characteristicUUID,
+        descriptorUUID,
+        value,
+        'descriptor-write-tx'
+      );
+    });
+  });
+});
+
+describe('ServiceWrapper', () => {
+  let mockService: any;
+  let mockNitroDevice: any;
+  let serviceWrapper: ServiceWrapper;
+
+  beforeEach(() => {
+    mockService = {
+      id: 1,
+      uuid: '180f',
+      deviceID: 'test-device',
+      isPrimary: true
+    };
+
+    mockNitroDevice = createMockNitroDevice();
+    serviceWrapper = new ServiceWrapper(mockService, mockNitroDevice);
+  });
+
+  it('should expose service properties', () => {
+    expect(serviceWrapper.id).toBe(1);
+    expect(serviceWrapper.uuid).toBe('180f');
+    expect(serviceWrapper.deviceID).toBe('test-device');
+    expect(serviceWrapper.isPrimary).toBe(true);
+  });
+
+  it('should delegate characteristics method to device', async () => {
+    mockNitroDevice.characteristicsForService.mockResolvedValue([]);
+
+    await serviceWrapper.characteristics();
+
+    expect(mockNitroDevice.characteristicsForService).toHaveBeenCalledWith('180f');
+  });
+
+  it('should delegate read characteristic method to device', async () => {
+    const characteristicUUID = '2a19';
+    mockNitroDevice.readCharacteristicForService.mockResolvedValue({});
+
+    await serviceWrapper.readCharacteristic(characteristicUUID, 'tx-123');
+
+    expect(mockNitroDevice.readCharacteristicForService).toHaveBeenCalledWith(
+      '180f',
+      characteristicUUID,
+      'tx-123'
+    );
+  });
+});
+
+describe('CharacteristicWrapper', () => {
+  let mockCharacteristic: any;
+  let mockNitroDevice: any;
+  let characteristicWrapper: CharacteristicWrapper;
+
+  beforeEach(() => {
+    mockCharacteristic = {
+      id: 1,
+      uuid: '2a19',
+      serviceID: 1,
+      serviceUUID: '180f',
+      deviceID: 'test-device',
+      isReadable: true,
+      isWritableWithResponse: true,
+      isWritableWithoutResponse: false,
+      isNotifiable: true,
+      isNotifying: false,
+      isIndicatable: false,
+      value: 'dGVzdA=='
+    };
+
+    mockNitroDevice = createMockNitroDevice();
+    characteristicWrapper = new CharacteristicWrapper(mockCharacteristic, mockNitroDevice);
+  });
+
+  it('should expose characteristic properties', () => {
+    expect(characteristicWrapper.id).toBe(1);
+    expect(characteristicWrapper.uuid).toBe('2a19');
+    expect(characteristicWrapper.serviceID).toBe(1);
+    expect(characteristicWrapper.serviceUUID).toBe('180f');
+    expect(characteristicWrapper.deviceID).toBe('test-device');
+    expect(characteristicWrapper.isReadable).toBe(true);
+    expect(characteristicWrapper.isWritableWithResponse).toBe(true);
+    expect(characteristicWrapper.isWritableWithoutResponse).toBe(false);
+    expect(characteristicWrapper.isNotifiable).toBe(true);
+    expect(characteristicWrapper.isNotifying).toBe(false);
+    expect(characteristicWrapper.isIndicatable).toBe(false);
+    expect(characteristicWrapper.value).toBe('dGVzdA==');
+  });
+
+  it('should delegate read method to device', async () => {
+    mockNitroDevice.readCharacteristicForService.mockResolvedValue(mockCharacteristic);
+
+    await characteristicWrapper.read('read-tx');
+
+    expect(mockNitroDevice.readCharacteristicForService).toHaveBeenCalledWith(
+      '180f',
+      '2a19',
+      'read-tx'
+    );
+  });
+});