react-native-ble-nitro 1.0.0-beta.8 → 1.0.0

package/src/__tests__/BleManager.test.ts

@@ -1,327 +0,0 @@
-/**
- * BleManager.test.ts
- * React Native BLE Nitro - Unit Tests
- * Copyright © 2025 Zyke (https://zyke.co)
- */
-
-import { BleManager } from '../index';
-import { State, LogLevel } from '../specs/types';
-
-// Create a mock Nitro manager
-const mockNitroManager = {
-  destroy: jest.fn().mockResolvedValue(undefined),
-  setLogLevel: jest.fn().mockResolvedValue(LogLevel.Info),
-  logLevel: jest.fn().mockResolvedValue(LogLevel.Info),
-  state: jest.fn().mockResolvedValue(State.PoweredOn),
-  onStateChange: jest.fn().mockReturnValue({ remove: jest.fn() }),
-  startDeviceScan: jest.fn().mockResolvedValue(undefined),
-  stopDeviceScan: jest.fn().mockResolvedValue(undefined),
-  connectToDevice: jest.fn().mockResolvedValue({
-    id: 'test-device',
-    name: 'Test Device',
-    deviceName: 'Test Device',
-    rssi: -50,
-    mtu: 23
-  }),
-  cancelDeviceConnection: jest.fn().mockResolvedValue({
-    id: 'test-device',
-    name: 'Test Device',
-    deviceName: 'Test Device'
-  }),
-  isDeviceConnected: jest.fn().mockResolvedValue(true),
-  discoverAllServicesAndCharacteristicsForDevice: jest.fn().mockResolvedValue({
-    id: 'test-device',
-    name: 'Test Device',
-    deviceName: 'Test Device'
-  }),
-  servicesForDevice: jest.fn().mockResolvedValue([
-    {
-      id: 1,
-      uuid: '12345678-1234-5678-9abc-123456789abc',
-      deviceID: 'test-device',
-      isPrimary: true
-    }
-  ]),
-  characteristicsForDevice: jest.fn().mockResolvedValue([
-    {
-      id: 1,
-      uuid: '87654321-4321-8765-cba9-987654321cba',
-      serviceID: 1,
-      serviceUUID: '12345678-1234-5678-9abc-123456789abc',
-      deviceID: 'test-device',
-      isReadable: true,
-      isWritableWithResponse: true,
-      isWritableWithoutResponse: false,
-      isNotifiable: true,
-      isNotifying: false,
-      isIndicatable: false,
-      value: null
-    }
-  ]),
-  readCharacteristicForDevice: jest.fn().mockResolvedValue({
-    id: 1,
-    uuid: '87654321-4321-8765-cba9-987654321cba',
-    value: 'dGVzdCB2YWx1ZQ==' // "test value" in base64
-  }),
-  writeCharacteristicWithResponseForDevice: jest.fn().mockResolvedValue({
-    id: 1,
-    uuid: '87654321-4321-8765-cba9-987654321cba',
-    value: 'dGVzdCB2YWx1ZQ=='
-  }),
-  monitorCharacteristicForDevice: jest.fn().mockReturnValue({ remove: jest.fn() }),
-};
-
-// Mock the Nitro module
-jest.mock('react-native-nitro-modules', () => ({
-  NitroModules: {
-    createHybridObject: jest.fn(() => mockNitroManager),
-  },
-}));
-
-// Mock the BleManagerFactory
-jest.mock('../BleManagerFactory', () => ({
-  createBleManager: jest.fn(() => mockNitroManager),
-}));
-
-describe('BleManager', () => {
-  let manager: BleManager;
-
-  beforeEach(() => {
-    manager = new BleManager();
-    jest.clearAllMocks();
-  });
-
-  afterEach(async () => {
-    await manager.destroy();
-  });
-
-  describe('Initialization', () => {
-    it('should create a BleManager instance', () => {
-      expect(manager).toBeInstanceOf(BleManager);
-    });
-
-    it('should set log level', async () => {
-      const result = await manager.setLogLevel(LogLevel.Info);
-      expect(result).toBe('Info'); // BleManagerCompat returns PlxLogLevel for compatibility
-    });
-
-    it('should get current log level', async () => {
-      await manager.setLogLevel(LogLevel.Debug);
-      const level = await manager.logLevel();
-      expect(level).toBe('Info'); // BleManagerCompat returns PlxLogLevel for compatibility
-    });
-  });
-
-  describe('State Management', () => {
-    it('should get current state', async () => {
-      const state = await manager.state();
-      expect(state).toBe('PoweredOn'); // BleManagerCompat converts State.PoweredOn -> PlxState 'PoweredOn'
-    });
-
-    it('should listen to state changes', async () => {
-      const listener = jest.fn();
-      const subscription = manager.onStateChange(listener, true);
-
-      expect(subscription).toHaveProperty('remove');
-      expect(typeof subscription.remove).toBe('function');
-    });
-  });
-
-  describe('Device Scanning', () => {
-    it('should start device scan', async () => {
-      const listener = jest.fn();
-      await manager.startDeviceScan(null, null, listener);
-      
-      // Verify that the native method was called
-      expect(mockNitroManager.startDeviceScan).toHaveBeenCalledWith(
-        null,
-        null,
-        expect.any(Function)
-      );
-    });
-
-    it('should stop device scan', async () => {
-      await manager.stopDeviceScan();
-      
-      expect(mockNitroManager.stopDeviceScan).toHaveBeenCalled();
-    });
-
-    it('should filter UUIDs when scanning', async () => {
-      const uuids = ['12345678-1234-5678-9abc-123456789abc'];
-      const listener = jest.fn();
-      
-      await manager.startDeviceScan(uuids, null, listener);
-      
-      expect(mockNitroManager.startDeviceScan).toHaveBeenCalledWith(
-        uuids,
-        null,
-        expect.any(Function)
-      );
-    });
-  });
-
-  describe('Device Connection', () => {
-    const deviceId = 'test-device';
-
-    it('should connect to device', async () => {
-      const device = await manager.connectToDevice(deviceId);
-      
-      expect(device.id).toBe(deviceId);
-      expect(device.name).toBe('Test Device');
-      expect(mockNitroManager.connectToDevice).toHaveBeenCalledWith(
-        deviceId,
-        expect.any(Object)
-      );
-    });
-
-    it('should check if device is connected', async () => {
-      const isConnected = await manager.isDeviceConnected(deviceId);
-      expect(isConnected).toBe(true);
-    });
-
-    it('should cancel device connection', async () => {
-      const device = await manager.cancelDeviceConnection(deviceId);
-      expect(device.id).toBe(deviceId);
-    });
-
-    it('should discover services and characteristics', async () => {
-      const device = await manager.discoverAllServicesAndCharacteristicsForDevice(deviceId);
-      expect(device.id).toBe(deviceId);
-    });
-  });
-
-  describe('GATT Operations', () => {
-    const deviceId = 'test-device';
-    const serviceUUID = '12345678-1234-5678-9abc-123456789abc';
-    const characteristicUUID = '87654321-4321-8765-cba9-987654321cba';
-
-    it('should list services for device', async () => {
-      const services = await manager.servicesForDevice(deviceId);
-      expect(services).toHaveLength(1);
-      expect(services[0].uuid).toBe(serviceUUID);
-    });
-
-    it('should list characteristics for service', async () => {
-      const characteristics = await manager.characteristicsForDevice(deviceId, serviceUUID);
-      expect(characteristics).toHaveLength(1);
-      expect(characteristics[0].uuid).toBe(characteristicUUID);
-    });
-
-    it('should read characteristic value', async () => {
-      const characteristic = await manager.readCharacteristicForDevice(
-        deviceId,
-        serviceUUID,
-        characteristicUUID
-      );
-      
-      expect(characteristic.value).toBe('dGVzdCB2YWx1ZQ==');
-    });
-
-    it('should write characteristic with response', async () => {
-      const value = 'dGVzdCB2YWx1ZQ=='; // "test value" in base64
-      
-      const characteristic = await manager.writeCharacteristicWithResponseForDevice(
-        deviceId,
-        serviceUUID,
-        characteristicUUID,
-        value
-      );
-      
-      expect(characteristic.value).toBe(value);
-    });
-
-    it('should monitor characteristic for changes', async () => {
-      const listener = jest.fn();
-      
-      const subscription = manager.monitorCharacteristicForDevice(
-        deviceId,
-        serviceUUID,
-        characteristicUUID,
-        listener
-      );
-      
-      expect(subscription).toHaveProperty('remove');
-      expect(mockNitroManager.monitorCharacteristicForDevice).toHaveBeenCalledWith(
-        deviceId,
-        serviceUUID,
-        characteristicUUID,
-        expect.any(Function),
-        undefined,
-        undefined
-      );
-    });
-  });
-
-  describe('Error Handling', () => {
-    it('should handle connection errors gracefully', async () => {
-      // Mock a connection failure
-      const mockError = new Error('Connection failed');
-      (mockNitroManager.connectToDevice as jest.Mock).mockRejectedValueOnce(mockError);
-
-      await expect(manager.connectToDevice('invalid-device')).rejects.toThrow('Connection failed');
-    });
-
-    it('should handle scan start errors', async () => {
-      const mockError = new Error('Scan failed');
-      (mockNitroManager.startDeviceScan as jest.Mock).mockRejectedValueOnce(mockError);
-
-      const listener = jest.fn();
-      await expect(manager.startDeviceScan(null, null, listener)).rejects.toThrow('Scan failed');
-    });
-  });
-
-  describe('Cleanup', () => {
-    it('should destroy manager and cleanup resources', async () => {
-      await manager.destroy();
-      expect(mockNitroManager.destroy).toHaveBeenCalled();
-    });
-  });
-});
-
-describe('Device Wrapper Compatibility', () => {
-  let manager: BleManager;
-
-  beforeEach(() => {
-    manager = new BleManager();
-  });
-
-  afterEach(async () => {
-    await manager.destroy();
-  });
-
-  it('should provide react-native-ble-plx compatible API', async () => {
-    const deviceId = 'test-device';
-    
-    // Connect to device
-    const device = await manager.connectToDevice(deviceId);
-    
-    // The device should have all expected properties
-    expect(device).toHaveProperty('id');
-    expect(device).toHaveProperty('name');
-    expect(device).toHaveProperty('rssi');
-    expect(device).toHaveProperty('mtu');
-    
-    // The device should have connect/disconnect methods
-    expect(device).toHaveProperty('connect');
-    expect(device).toHaveProperty('cancelConnection');
-    expect(device).toHaveProperty('isConnected');
-    expect(device).toHaveProperty('discoverAllServicesAndCharacteristics');
-    
-    // All methods should be functions
-    expect(typeof device.connect).toBe('function');
-    expect(typeof device.cancelConnection).toBe('function');
-    expect(typeof device.isConnected).toBe('function');
-    expect(typeof device.discoverAllServicesAndCharacteristics).toBe('function');
-  });
-
-  it('should convert enum values to PlxState for compatibility', async () => {
-    const state = await manager.state();
-    
-    // State should be PlxState string literal type (mocked return value is 'PoweredOn')
-    expect(typeof state).toBe('string');
-    expect(state).toBe('PoweredOn');
-    
-    // The compatibility layer should handle string/number conversion
-    expect(State.PoweredOn).toBe(5); // Numeric enum value
-  });
-});