@onekeyfe/hd-transport-react-native 1.2.3-alpha.1 → 1.2.3-alpha.10

package/src/__tests__/androidKeyMissing.test.ts

@@ -0,0 +1,307 @@
+import EventEmitter from 'events';
+
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import ReactNativeBleTransport, {
+  ANDROID_KEY_MISSING_GRACE_MS,
+  ANDROID_KEY_MISSING_LINK_WINDOW_MS,
+} from '../index';
+import { SYSTEM_BONDING_RESTART_WINDOW_MS, onDeviceBondState } from '../BleManager';
+import { stopBleKeyMissingTracking } from '../bleKeyMissing';
+import protocolV1Schema from './protocolV1SchemaFixture';
+
+let mockKeyMissingSupported = true;
+let mockEmitKeyMissing: ((event: { id?: string }) => void) | undefined;
+let mockEmitBondState: ((peripheral: unknown) => void) | undefined;
+
+jest.mock(
+  'react-native',
+  () => ({
+    Platform: { OS: 'android', select: (spec: Record<string, unknown>) => spec.android },
+    PermissionsAndroid: {
+      PERMISSIONS: {},
+      RESULTS: {},
+      request: jest.fn(),
+      requestMultiple: jest.fn(),
+    },
+  }),
+  { virtual: true }
+);
+
+jest.mock('react-native-ble-plx', () => ({
+  BleATTErrorCode: { InvalidHandle: 1 },
+  BleError: Error,
+  BleErrorCode: { DeviceDisconnected: 201, OperationStartFailed: 601 },
+  BleManager: jest.fn(),
+  ScanMode: { LowLatency: 2 },
+}));
+
+jest.mock('@onekeyfe/react-native-ble-utils', () => ({
+  __esModule: true,
+  default: {
+    getConnectedPeripherals: jest.fn(() => Promise.resolve([])),
+    getBondedPeripherals: jest.fn(() => Promise.resolve([])),
+    pairDevice: jest.fn(() => Promise.resolve({ bonded: true, bonding: false })),
+    supportsDeviceKeyMissing: jest.fn(() => mockKeyMissingSupported),
+    onDeviceKeyMissing: jest.fn((callback: (event: { id?: string }) => void) => {
+      mockEmitKeyMissing = callback;
+      return () => {
+        mockEmitKeyMissing = undefined;
+      };
+    }),
+    onDeviceBondState: jest.fn((callback: (peripheral: unknown) => void) => {
+      mockEmitBondState = callback;
+      return () => {
+        mockEmitBondState = undefined;
+      };
+    }),
+  },
+}));
+
+const UUID = 'CC:06:1C:FD:48:E9';
+
+const flush = () =>
+  new Promise(resolve => {
+    setImmediate(resolve);
+  });
+
+const advance = async (ms: number) => {
+  jest.advanceTimersByTime(ms);
+  await flush();
+};
+
+// What ble-plx reports when the device drops the link while the first write is queued.
+const peerTerminated = () =>
+  Promise.reject(
+    Object.assign(new Error(`Device ${UUID} was disconnected`), {
+      errorCode: 201,
+      attErrorCode: 19,
+      reason: 'Disconnected with status 19 (GATT_CONN_TERMINATE_PEER_USER)',
+    })
+  );
+
+function createConnectedTransport(linkAgeMs = 0) {
+  const t = new ReactNativeBleTransport({});
+  t.configure(protocolV1Schema);
+  (t as any).deviceProtocol.set(UUID, 'V1');
+  (t as any).getCachedTransport = () => ({
+    writeCharacteristic: { writeWithoutResponse: jest.fn(peerTerminated) },
+  });
+  (t as any).androidLinkStartedAt.set(UUID, Date.now() - linkAgeMs);
+  return t;
+}
+
+const settle = (promise: Promise<unknown>) => {
+  const outcome: { error?: { errorCode?: unknown }; done: boolean } = { done: false };
+  promise.then(
+    () => {
+      outcome.done = true;
+    },
+    error => {
+      outcome.error = error;
+      outcome.done = true;
+    }
+  );
+  return outcome;
+};
+
+describe('Android key missing', () => {
+  beforeEach(() => {
+    jest.useFakeTimers({ doNotFake: ['setImmediate', 'performance'] });
+    mockKeyMissingSupported = true;
+  });
+
+  afterEach(() => {
+    stopBleKeyMissingTracking();
+    jest.clearAllTimers();
+    jest.useRealTimers();
+  });
+
+  describe('link dropped right after connect', () => {
+    test('reports an invalid bond when the system says the keys are missing', async () => {
+      const outcome = settle(createConnectedTransport().call(UUID, 'GetFeatures', {}));
+      await flush();
+      // The broadcast is delivered separately and can trail the GATT disconnect.
+      mockEmitKeyMissing?.({ id: UUID.toLowerCase() });
+      await flush();
+
+      expect(outcome.error?.errorCode).toBe(HardwareErrorCode.BleBondInvalid);
+    });
+
+    test('keeps the original error when no key missing follows', async () => {
+      const outcome = settle(createConnectedTransport().call(UUID, 'GetFeatures', {}));
+      await flush();
+      expect(outcome.done).toBe(false);
+
+      await advance(ANDROID_KEY_MISSING_GRACE_MS);
+
+      expect(outcome.error?.errorCode).toBe(HardwareErrorCode.BleDeviceNotBonded);
+    });
+
+    test('ignores key missing reported for an earlier link', async () => {
+      const transport = createConnectedTransport();
+      const earlier = settle(transport.call(UUID, 'GetFeatures', {}));
+      await flush();
+      mockEmitKeyMissing?.({ id: UUID });
+      await flush();
+      expect(earlier.error?.errorCode).toBe(HardwareErrorCode.BleBondInvalid);
+
+      // The user re-paired; a later link that drops is an ordinary disconnect.
+      await advance(1000);
+      (transport as any).androidLinkStartedAt.set(UUID, Date.now());
+      const later = settle(transport.call(UUID, 'GetFeatures', {}));
+      await flush();
+      await advance(ANDROID_KEY_MISSING_GRACE_MS);
+
+      expect(later.error?.errorCode).toBe(HardwareErrorCode.BleDeviceNotBonded);
+    });
+
+    test('ignores key missing for another device', async () => {
+      const outcome = settle(createConnectedTransport().call(UUID, 'GetFeatures', {}));
+      await flush();
+      mockEmitKeyMissing?.({ id: 'E9:B9:F4:DD:DE:CD' });
+      await advance(ANDROID_KEY_MISSING_GRACE_MS);
+
+      expect(outcome.error?.errorCode).toBe(HardwareErrorCode.BleDeviceNotBonded);
+    });
+
+    test('does not wait on a link that has been up for a while', async () => {
+      const transport = createConnectedTransport(ANDROID_KEY_MISSING_LINK_WINDOW_MS + 1);
+      const outcome = settle(transport.call(UUID, 'GetFeatures', {}));
+      await flush();
+
+      expect(outcome.error?.errorCode).toBe(HardwareErrorCode.BleDeviceNotBonded);
+    });
+
+    test('does not wait when the OS or native build never reports key missing', async () => {
+      mockKeyMissingSupported = false;
+      const outcome = settle(createConnectedTransport().call(UUID, 'GetFeatures', {}));
+      await flush();
+
+      expect(outcome.error?.errorCode).toBe(HardwareErrorCode.BleDeviceNotBonded);
+    });
+  });
+
+  describe('acquire over a bond the device no longer holds', () => {
+    // Android still reports BONDED, so connect, MTU and GATT setup all succeed and the
+    // protocol probe is the first operation to meet the dropped link.
+    function createStaleBondHarness() {
+      const writeCharacteristic = {
+        uuid: '00000002-0000-1000-8000-00805f9b34fb',
+        isWritableWithoutResponse: true,
+        writeWithoutResponse: jest.fn(peerTerminated),
+      };
+      const notifyCharacteristic = {
+        uuid: '00000003-0000-1000-8000-00805f9b34fb',
+        isNotifiable: true,
+        monitor: jest.fn(() => ({ remove: jest.fn() })),
+      };
+      const device = {
+        id: UUID,
+        name: 'Pro 2 48E9',
+        localName: 'Pro 2 48E9',
+        mtu: 247,
+        serviceUUIDs: ['00000001-0000-1000-8000-00805f9b34fb'],
+        isConnected: jest.fn(() => Promise.resolve(true)),
+        cancelConnection: jest.fn(() => Promise.resolve()),
+        discoverAllServicesAndCharacteristics: jest.fn(() => Promise.resolve()),
+        characteristicsForService: jest.fn(() =>
+          Promise.resolve([writeCharacteristic, notifyCharacteristic])
+        ),
+        services: jest.fn(() => Promise.resolve([])),
+        onDisconnected: jest.fn(() => ({ remove: jest.fn() })),
+      };
+      const transport = new ReactNativeBleTransport({});
+      (transport as any).blePlxManager = {
+        devices: jest.fn(() => Promise.resolve([device])),
+        connectedDevices: jest.fn(() => Promise.resolve([])),
+        cancelTransaction: jest.fn(() => Promise.resolve()),
+        cancelDeviceConnection: jest.fn(() => Promise.resolve()),
+        onStateChange: jest.fn((listener: (state: string) => void) => {
+          setImmediate(() => listener('PoweredOn'));
+          return { remove: jest.fn() };
+        }),
+        state: jest.fn(() => Promise.resolve('PoweredOn')),
+      };
+      transport.init(
+        { debug: jest.fn(), error: jest.fn(), warn: jest.fn() } as any,
+        new EventEmitter()
+      );
+      transport.configure(protocolV1Schema);
+      return { transport, write: writeCharacteristic.writeWithoutResponse };
+    }
+
+    async function acquireUntilSettled(keyMissing: boolean) {
+      const { transport, write } = createStaleBondHarness();
+      const outcome = settle(transport.acquire({ uuid: UUID }));
+      for (let i = 0; i < 100 && !outcome.done; i += 1) {
+        // eslint-disable-next-line no-await-in-loop
+        await advance(100);
+        // The broadcast follows the dropped link, which the probe write is first to meet.
+        if (keyMissing && write.mock.calls.length > 0) mockEmitKeyMissing?.({ id: UUID });
+      }
+      expect(write).toHaveBeenCalled();
+      return JSON.parse(JSON.stringify(ERRORS.serializeError({ error: outcome.error })));
+    }
+
+    test('ends as an invalid bond that survives the Core response path', async () => {
+      await expect(acquireUntilSettled(true)).resolves.toEqual({
+        code: HardwareErrorCode.BleBondInvalid,
+        error: expect.stringContaining('Forget the device'),
+        params: { phase: 'connect', reason: 'key_missing' },
+      });
+    });
+
+    test('keeps the legacy error when the system reports nothing', async () => {
+      await expect(acquireUntilSettled(false)).resolves.toMatchObject({
+        code: HardwareErrorCode.BleDeviceNotBonded,
+      });
+    });
+  });
+
+  describe('waiting for bonding', () => {
+    const bondState = (preState: string, state: string) =>
+      mockEmitBondState?.({ id: UUID, bondState: { preState, state } });
+
+    test('fails as an invalid bond when the system re-pair ends in key missing', async () => {
+      const outcome = settle(onDeviceBondState(UUID, undefined, { systemInitiated: true }));
+      mockEmitKeyMissing?.({ id: UUID });
+      await flush();
+
+      expect(outcome.error?.errorCode).toBe(HardwareErrorCode.BleBondInvalid);
+    });
+
+    test('follows a system re-pair that replaces the bond', async () => {
+      const outcome = settle(onDeviceBondState(UUID, undefined, { systemInitiated: true }));
+      bondState('BOND_BONDING', 'BOND_NONE');
+      bondState('BOND_NONE', 'BOND_BONDING');
+      await advance(SYSTEM_BONDING_RESTART_WINDOW_MS);
+      expect(outcome.done).toBe(false);
+
+      bondState('BOND_BONDING', 'BOND_BONDED');
+      await flush();
+
+      expect(outcome.done).toBe(true);
+      expect(outcome.error).toBeUndefined();
+    });
+
+    test('fails a system re-pair that ends without a bond', async () => {
+      const outcome = settle(onDeviceBondState(UUID, undefined, { systemInitiated: true }));
+      bondState('BOND_BONDING', 'BOND_NONE');
+      await flush();
+      expect(outcome.done).toBe(false);
+
+      await advance(SYSTEM_BONDING_RESTART_WINDOW_MS);
+
+      expect(outcome.error?.errorCode).toBe(HardwareErrorCode.BleDeviceNotBonded);
+    });
+
+    test('fails a bonding this transport started as soon as it ends without a bond', async () => {
+      const outcome = settle(onDeviceBondState(UUID));
+      bondState('BOND_BONDING', 'BOND_NONE');
+      await flush();
+
+      expect(outcome.error?.errorCode).toBe(HardwareErrorCode.BleDeviceNotBonded);
+    });
+  });
+});

package/src/__tests__/bleNativeDisconnect.test.ts

@@ -0,0 +1,33 @@
+import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import { isNativeBleDisconnectError, toBleDisconnectHardwareError } from '../bleNativeDisconnect';
+
+describe('native BLE disconnect mapping', () => {
+  test.each([
+    [{ errorCode: 201, reason: 'The specified device has disconnected from us.' }],
+    [{ errorCode: 201, iosErrorCode: 7, reason: 'The specified device has disconnected from us.' }],
+    [{ iosErrorCode: 7, reason: 'Peripheral disconnected' }],
+  ])('recognizes %j as a native disconnect', nativeError => {
+    expect(isNativeBleDisconnectError(nativeError)).toBe(true);
+    expect(toBleDisconnectHardwareError(nativeError)).toMatchObject({
+      errorCode: HardwareErrorCode.BleDeviceDisconnected,
+    });
+  });
+
+  test('does not treat a stale-bond iOS code as a disconnect', () => {
+    expect(
+      isNativeBleDisconnectError({
+        iosErrorCode: 14,
+        reason: 'Peer removed pairing information',
+      })
+    ).toBe(false);
+  });
+
+  test('does not treat an already-canonical unpaired error as a native disconnect', () => {
+    expect(
+      isNativeBleDisconnectError({
+        errorCode: HardwareErrorCode.BleDeviceNotBonded,
+      })
+    ).toBe(false);
+  });
+});