CU-868f46emq Working on getting Bluetooth on Android working.

Author: ucswift

src/components/settings/__tests__/bluetooth-device-selection-bottom-sheet-simple.test.tsx

@@ -0,0 +1,224 @@
+// This is a simplified test that focuses on the logic without UI rendering
+import { bluetoothAudioService } from '@/services/bluetooth-audio.service';
+
+// Mock the bluetooth audio service
+jest.mock('@/services/bluetooth-audio.service', () => ({
+  bluetoothAudioService: {
+    startScanning: jest.fn(),
+    stopScanning: jest.fn(),
+    connectToDevice: jest.fn(),
+    disconnectDevice: jest.fn(),
+  },
+}));
+
+// Mock the hook
+const mockSetPreferredDevice = jest.fn();
+jest.mock('@/lib/hooks/use-preferred-bluetooth-device', () => ({
+  usePreferredBluetoothDevice: () => ({
+    preferredDevice: null,
+    setPreferredDevice: mockSetPreferredDevice,
+  }),
+}));
+
+describe('BluetoothDeviceSelectionBottomSheet Device Selection Logic', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('handleDeviceSelect function behavior', () => {
+    it('should clear preferred device first, then disconnect, then set new device and connect', async () => {
+      // Simulate the handleDeviceSelect logic directly
+      const mockDevice = {
+        id: 'test-device-1',
+        name: 'Test Headset',
+        rssi: -50,
+        isConnected: false,
+        hasAudioCapability: true,
+        supportsMicrophoneControl: true,
+        device: {} as any,
+      };
+
+      const mockConnectedDevice = {
+        id: 'current-device',
+        name: 'Current Device',
+        rssi: -40,
+        isConnected: true,
+        hasAudioCapability: true,
+        supportsMicrophoneControl: true,
+        device: {} as any,
+      };
+
+      // Simulate the handleDeviceSelect function logic
+      await mockSetPreferredDevice(null);
+
+      if (mockConnectedDevice) {
+        await bluetoothAudioService.disconnectDevice();
+      }
+
+      const selectedDevice = {
+        id: mockDevice.id,
+        name: mockDevice.name || 'Unknown Device',
+      };
+
+      await mockSetPreferredDevice(selectedDevice);
+      await bluetoothAudioService.connectToDevice(mockDevice.id);
+
+      // Verify the order of operations
+      expect(mockSetPreferredDevice).toHaveBeenNthCalledWith(1, null);
+      expect(bluetoothAudioService.disconnectDevice).toHaveBeenCalled();
+      expect(mockSetPreferredDevice).toHaveBeenNthCalledWith(2, {
+        id: 'test-device-1',
+        name: 'Test Headset',
+      });
+      expect(bluetoothAudioService.connectToDevice).toHaveBeenCalledWith('test-device-1');
+    });
+
+    it('should handle disconnect failure gracefully and continue with new connection', async () => {
+      // Make disconnect fail
+      (bluetoothAudioService.disconnectDevice as jest.Mock).mockRejectedValue(new Error('Disconnect failed'));
+
+      const mockDevice = {
+        id: 'test-device-1',
+        name: 'Test Headset',
+        rssi: -50,
+        isConnected: false,
+        hasAudioCapability: true,
+        supportsMicrophoneControl: true,
+        device: {} as any,
+      };
+
+      const mockConnectedDevice = {
+        id: 'current-device',
+        name: 'Current Device',
+        rssi: -40,
+        isConnected: true,
+        hasAudioCapability: true,
+        supportsMicrophoneControl: true,
+        device: {} as any,
+      };
+
+      // Simulate the handleDeviceSelect function logic with error handling
+      try {
+        await mockSetPreferredDevice(null);
+
+        if (mockConnectedDevice) {
+          try {
+            await bluetoothAudioService.disconnectDevice();
+          } catch (disconnectError) {
+            // Should continue even if disconnect fails
+          }
+        }
+
+        const selectedDevice = {
+          id: mockDevice.id,
+          name: mockDevice.name || 'Unknown Device',
+        };
+
+        await mockSetPreferredDevice(selectedDevice);
+        await bluetoothAudioService.connectToDevice(mockDevice.id);
+      } catch (error) {
+        // Should not throw
+      }
+
+      // Verify operations still executed despite disconnect failure
+      expect(mockSetPreferredDevice).toHaveBeenNthCalledWith(1, null);
+      expect(bluetoothAudioService.disconnectDevice).toHaveBeenCalled();
+      expect(mockSetPreferredDevice).toHaveBeenNthCalledWith(2, {
+        id: 'test-device-1',
+        name: 'Test Headset',
+      });
+      expect(bluetoothAudioService.connectToDevice).toHaveBeenCalledWith('test-device-1');
+    });
+
+    it('should skip disconnect when no device is currently connected', async () => {
+      const mockDevice = {
+        id: 'test-device-1',
+        name: 'Test Headset',
+        rssi: -50,
+        isConnected: false,
+        hasAudioCapability: true,
+        supportsMicrophoneControl: true,
+        device: {} as any,
+      };
+
+      const mockConnectedDevice = null;
+
+      // Simulate the handleDeviceSelect function logic
+      await mockSetPreferredDevice(null);
+
+      if (mockConnectedDevice) {
+        await bluetoothAudioService.disconnectDevice();
+      }
+
+      const selectedDevice = {
+        id: mockDevice.id,
+        name: mockDevice.name || 'Unknown Device',
+      };
+
+      await mockSetPreferredDevice(selectedDevice);
+      await bluetoothAudioService.connectToDevice(mockDevice.id);
+
+      // Verify disconnect was not called since no device was connected
+      expect(mockSetPreferredDevice).toHaveBeenNthCalledWith(1, null);
+      expect(bluetoothAudioService.disconnectDevice).not.toHaveBeenCalled();
+      expect(mockSetPreferredDevice).toHaveBeenNthCalledWith(2, {
+        id: 'test-device-1',
+        name: 'Test Headset',
+      });
+      expect(bluetoothAudioService.connectToDevice).toHaveBeenCalledWith('test-device-1');
+    });
+
+    it('should handle connection failure gracefully', async () => {
+      // Make connect fail
+      (bluetoothAudioService.connectToDevice as jest.Mock).mockRejectedValue(new Error('Connection failed'));
+
+      const mockDevice = {
+        id: 'test-device-1',
+        name: 'Test Headset',
+        rssi: -50,
+        isConnected: false,
+        hasAudioCapability: true,
+        supportsMicrophoneControl: true,
+        device: {} as any,
+      };
+
+      const mockConnectedDevice = null;
+
+      // Simulate the handleDeviceSelect function logic with error handling
+      try {
+        await mockSetPreferredDevice(null);
+
+        if (mockConnectedDevice) {
+          try {
+            await bluetoothAudioService.disconnectDevice();
+          } catch (disconnectError) {
+            // Continue even if disconnect fails
+          }
+        }
+
+        const selectedDevice = {
+          id: mockDevice.id,
+          name: mockDevice.name || 'Unknown Device',
+        };
+
+        await mockSetPreferredDevice(selectedDevice);
+
+        try {
+          await bluetoothAudioService.connectToDevice(mockDevice.id);
+        } catch (connectionError) {
+          // Should not prevent setting the preferred device
+        }
+      } catch (error) {
+        // Should not throw
+      }
+
+      // Verify preferred device was still set despite connection failure
+      expect(mockSetPreferredDevice).toHaveBeenNthCalledWith(1, null);
+      expect(mockSetPreferredDevice).toHaveBeenNthCalledWith(2, {
+        id: 'test-device-1',
+        name: 'Test Headset',
+      });
+      expect(bluetoothAudioService.connectToDevice).toHaveBeenCalledWith('test-device-1');
+    });
+  });
+});