@onekeyfe/hd-transport-react-native 1.2.3-alpha.9 → 1.2.4-alpha.0

package/src/__tests__/androidEncryption.test.ts

@@ -0,0 +1,482 @@
+import EventEmitter from 'events';
+import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import ReactNativeBleTransport, {
+  ANDROID_ENCRYPTION_RESULT_TIMEOUT_MS,
+  ANDROID_KEY_MISSING_GRACE_MS,
+  ANDROID_SYSTEM_REPAIR_TIMEOUT_MS,
+} from '../index';
+import {
+  HCI_PIN_OR_KEY_MISSING,
+  stopBleEncryptionTracking,
+  waitForAndroidLinkEncryption,
+} from '../bleEncryption';
+import { stopBleKeyMissingTracking } from '../bleKeyMissing';
+import protocolV1Schema from './protocolV1SchemaFixture';
+
+type EncryptionEvent = { id: string; status: number; enabled: boolean };
+
+let mockSupported = true;
+let mockPairResult: { bonded: boolean; bonding: boolean; initiated?: boolean } = {
+  bonded: true,
+  bonding: false,
+  initiated: false,
+};
+let mockEmitEncryption: ((event: EncryptionEvent) => void) | undefined;
+let mockEmitAclDisconnected: ((event: { id: string }) => void) | undefined;
+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(mockPairResult)),
+    supportsDeviceKeyMissing: jest.fn(() => mockSupported),
+    onDeviceKeyMissing: jest.fn((callback: (event: { id: string }) => void) => {
+      mockEmitKeyMissing = callback;
+      return () => {
+        mockEmitKeyMissing = undefined;
+      };
+    }),
+    supportsDeviceEncryptionChange: jest.fn(() => mockSupported),
+    onDeviceEncryptionChange: jest.fn((callback: (event: EncryptionEvent) => void) => {
+      mockEmitEncryption = callback;
+      return () => {
+        mockEmitEncryption = undefined;
+      };
+    }),
+    onDeviceAclDisconnected: jest.fn((callback: (event: { id: string }) => void) => {
+      mockEmitAclDisconnected = callback;
+      return () => {
+        mockEmitAclDisconnected = undefined;
+      };
+    }),
+    onDeviceBondState: jest.fn((callback: (peripheral: unknown) => void) => {
+      mockEmitBondState = callback;
+      return () => {
+        mockEmitBondState = undefined;
+      };
+    }),
+  },
+}));
+
+const UUID = 'CC:06:1C:FD:48:E9';
+const OTHER_UUID = 'E9:B9:F4:DD:DE:CD';
+
+const flush = () =>
+  new Promise(resolve => {
+    setImmediate(resolve);
+  });
+
+const advance = async (ms: number) => {
+  jest.advanceTimersByTime(ms);
+  await flush();
+};
+
+const encrypted = (id = UUID) => mockEmitEncryption?.({ id, status: 0, enabled: true });
+const keyMissing = (id = UUID) =>
+  mockEmitEncryption?.({ id, status: HCI_PIN_OR_KEY_MISSING, enabled: false });
+
+const settle = <T>(promise: Promise<T>) => {
+  const outcome: { value?: T; error?: { errorCode?: unknown }; done: boolean } = { done: false };
+  promise.then(
+    value => {
+      outcome.value = value;
+      outcome.done = true;
+    },
+    error => {
+      outcome.error = error;
+      outcome.done = true;
+    }
+  );
+  return outcome;
+};
+
+const waitFor = ({
+  linkStartedAt = Date.now(),
+  signal,
+}: { linkStartedAt?: number; signal?: AbortSignal } = {}) =>
+  settle(
+    waitForAndroidLinkEncryption({
+      deviceId: UUID,
+      linkStartedAt,
+      resultTimeoutMs: ANDROID_ENCRYPTION_RESULT_TIMEOUT_MS,
+      repairTimeoutMs: ANDROID_SYSTEM_REPAIR_TIMEOUT_MS,
+      keyMissingGraceMs: ANDROID_KEY_MISSING_GRACE_MS,
+      signal,
+    })
+  );
+
+describe('Android link encryption', () => {
+  beforeEach(() => {
+    jest.useFakeTimers({ doNotFake: ['setImmediate', 'performance'] });
+    mockSupported = true;
+    mockPairResult = { bonded: true, bonding: false, initiated: false };
+  });
+
+  afterEach(() => {
+    stopBleEncryptionTracking();
+    stopBleKeyMissingTracking();
+    jest.clearAllTimers();
+    jest.useRealTimers();
+  });
+
+  describe('first result of a new link', () => {
+    test('resolves when the stored bond encrypts the link', async () => {
+      const outcome = waitFor();
+      await flush();
+      expect(outcome.done).toBe(false);
+
+      encrypted();
+      await flush();
+
+      expect(outcome.value).toBe('encrypted');
+    });
+
+    test('uses a result that arrived before the wait started', async () => {
+      const linkStartedAt = Date.now();
+      waitFor({ linkStartedAt });
+      await flush();
+      encrypted();
+      await flush();
+
+      const outcome = waitFor({ linkStartedAt });
+      await flush();
+
+      expect(outcome.value).toBe('encrypted');
+    });
+
+    test('proceeds as before when no result arrives in time', async () => {
+      const outcome = waitFor();
+      await advance(ANDROID_ENCRYPTION_RESULT_TIMEOUT_MS - 1);
+      expect(outcome.done).toBe(false);
+
+      await advance(1);
+
+      expect(outcome.value).toBe('unresolved');
+    });
+
+    test('does not wait when the platform cannot report the result', async () => {
+      mockSupported = false;
+      const outcome = waitFor();
+      await flush();
+
+      expect(outcome.value).toBe('unresolved');
+    });
+
+    test('proceeds when encryption fails for a reason other than a lost bond', async () => {
+      const outcome = waitFor();
+      await flush();
+      mockEmitEncryption?.({ id: UUID, status: 0x08, enabled: false });
+      await flush();
+
+      expect(outcome.value).toBe('unresolved');
+    });
+
+    test('proceeds when the link drops before any result', async () => {
+      const outcome = waitFor();
+      await flush();
+      mockEmitAclDisconnected?.({ id: UUID });
+      await flush();
+
+      expect(outcome.value).toBe('unresolved');
+    });
+
+    test('ignores results for another device', async () => {
+      const outcome = waitFor();
+      await flush();
+      encrypted(OTHER_UUID);
+      await flush();
+      expect(outcome.done).toBe(false);
+
+      encrypted(UUID.toLowerCase());
+      await flush();
+
+      expect(outcome.value).toBe('encrypted');
+    });
+  });
+
+  describe('reused link', () => {
+    test('does not wait on a link that is still up and was encrypted earlier', async () => {
+      waitFor();
+      await flush();
+      encrypted();
+      await advance(1000);
+
+      const outcome = waitFor();
+      await flush();
+
+      expect(outcome.value).toBe('already-encrypted');
+    });
+
+    test('waits again once the earlier link has dropped', async () => {
+      waitFor();
+      await flush();
+      encrypted();
+      await advance(1000);
+      mockEmitAclDisconnected?.({ id: UUID });
+      await advance(1000);
+
+      const outcome = waitFor();
+      await flush();
+      expect(outcome.done).toBe(false);
+
+      keyMissing();
+      await flush();
+
+      expect(outcome.done).toBe(false);
+    });
+  });
+
+  describe('lost bond', () => {
+    test('holds until the system re-pairs on the same link', async () => {
+      const outcome = waitFor();
+      await flush();
+      keyMissing();
+      await advance(10_000);
+      expect(outcome.done).toBe(false);
+
+      encrypted();
+      await flush();
+
+      expect(outcome.value).toBe('re-paired');
+    });
+
+    test('reports an invalid bond when the system says re-pairing failed', async () => {
+      const outcome = waitFor();
+      await flush();
+      keyMissing();
+      await advance(5000);
+      mockEmitKeyMissing?.({ id: UUID });
+      await flush();
+
+      expect(outcome.error?.errorCode).toBe(HardwareErrorCode.BleBondInvalid);
+    });
+
+    test('reports an invalid bond when the drop is followed by key missing', async () => {
+      const outcome = waitFor();
+      await flush();
+      keyMissing();
+      await advance(5000);
+      mockEmitAclDisconnected?.({ id: UUID });
+      await advance(ANDROID_KEY_MISSING_GRACE_MS - 100);
+      mockEmitKeyMissing?.({ id: UUID });
+      await flush();
+
+      expect(outcome.error?.errorCode).toBe(HardwareErrorCode.BleBondInvalid);
+    });
+
+    test('reports a disconnect when the link drops without key missing', async () => {
+      const outcome = waitFor();
+      await flush();
+      keyMissing();
+      await advance(5000);
+      mockEmitAclDisconnected?.({ id: UUID });
+      await advance(ANDROID_KEY_MISSING_GRACE_MS);
+
+      expect(outcome.error?.errorCode).toBe(HardwareErrorCode.BleDeviceDisconnected);
+    });
+
+    test('gives up when re-pairing never finishes', async () => {
+      const outcome = waitFor();
+      await flush();
+      keyMissing();
+      await advance(ANDROID_SYSTEM_REPAIR_TIMEOUT_MS);
+
+      expect(outcome.error?.errorCode).toBe(HardwareErrorCode.BleDeviceNotBonded);
+    });
+
+    test('stops waiting when the transport is stopped', async () => {
+      const controller = new AbortController();
+      const outcome = waitFor({ signal: controller.signal });
+      await flush();
+      keyMissing();
+      await flush();
+
+      controller.abort();
+      await flush();
+
+      expect(outcome.error?.errorCode).toBe(HardwareErrorCode.BleDeviceDisconnected);
+      expect(jest.getTimerCount()).toBe(0);
+    });
+  });
+
+  describe('acquire', () => {
+    function createHarness() {
+      const monitor = jest.fn(() => ({ remove: jest.fn() }));
+      const writeCharacteristic = {
+        uuid: '00000002-0000-1000-8000-00805f9b34fb',
+        isWritableWithoutResponse: true,
+        writeWithoutResponse: jest.fn(() => Promise.resolve()),
+      };
+      const notifyCharacteristic = {
+        uuid: '00000003-0000-1000-8000-00805f9b34fb',
+        isNotifiable: true,
+        monitor,
+      };
+      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()),
+        onDeviceDisconnected: jest.fn(() => ({ remove: jest.fn() })),
+        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, monitor, device };
+    }
+
+    /** Drives acquire up to the point where it waits for the link's encryption result. */
+    async function reachGate(device: { characteristicsForService: jest.Mock }) {
+      for (let i = 0; i < 100 && device.characteristicsForService.mock.calls.length === 0; i += 1) {
+        // eslint-disable-next-line no-await-in-loop
+        await advance(10);
+      }
+      expect(device.characteristicsForService).toHaveBeenCalled();
+      await advance(10);
+    }
+
+    async function runUntil(done: () => boolean, maxMs = 2000) {
+      for (let elapsed = 0; elapsed < maxMs && !done(); elapsed += 50) {
+        // eslint-disable-next-line no-await-in-loop
+        await advance(50);
+      }
+    }
+
+    test('subscribes to notifications only after a bonded link is encrypted', async () => {
+      const { transport, monitor, device } = createHarness();
+      const outcome = settle(transport.acquire({ uuid: UUID, expectedProtocol: 'V1' }));
+      await reachGate(device);
+      await advance(ANDROID_ENCRYPTION_RESULT_TIMEOUT_MS / 2);
+      expect(monitor).not.toHaveBeenCalled();
+
+      encrypted();
+      await runUntil(() => outcome.done);
+
+      expect(outcome.error).toBeUndefined();
+      expect(outcome.value).toEqual({ uuid: UUID, protocolType: 'V1' });
+      expect(monitor).toHaveBeenCalledTimes(1);
+      await transport.release(UUID, true);
+    });
+
+    test('keeps GATT idle while the system re-pairs a lost bond', async () => {
+      const { transport, monitor, device } = createHarness();
+      const outcome = settle(transport.acquire({ uuid: UUID, expectedProtocol: 'V1' }));
+      await reachGate(device);
+      keyMissing();
+      await advance(8000);
+      expect(monitor).not.toHaveBeenCalled();
+      expect(outcome.done).toBe(false);
+
+      encrypted();
+      await runUntil(() => outcome.done);
+
+      expect(outcome.value).toEqual({ uuid: UUID, protocolType: 'V1' });
+      expect(monitor).toHaveBeenCalledTimes(1);
+      await transport.release(UUID, true);
+    });
+
+    test('fails as an invalid bond when the system re-pairing fails', async () => {
+      const { transport, monitor, device } = createHarness();
+      const outcome = settle(transport.acquire({ uuid: UUID, expectedProtocol: 'V1' }));
+      await reachGate(device);
+      keyMissing();
+      await advance(5000);
+      mockEmitKeyMissing?.({ id: UUID });
+      await runUntil(() => outcome.done);
+
+      expect(outcome.error?.errorCode).toBe(HardwareErrorCode.BleBondInvalid);
+      expect(monitor).not.toHaveBeenCalled();
+    });
+
+    test('does not wait for a bond created by this acquire', async () => {
+      mockPairResult = { bonded: false, bonding: true, initiated: true };
+      const { transport, monitor } = createHarness();
+      const outcome = settle(transport.acquire({ uuid: UUID, expectedProtocol: 'V1' }));
+      for (let i = 0; i < 100 && !mockEmitBondState; i += 1) {
+        // eslint-disable-next-line no-await-in-loop
+        await advance(10);
+      }
+      mockEmitBondState?.({
+        id: UUID,
+        advertising: {},
+        bondState: { preState: 'BOND_BONDING', state: 'BOND_BONDED' },
+      });
+      await runUntil(() => outcome.done);
+
+      expect(outcome.value).toEqual({ uuid: UUID, protocolType: 'V1' });
+      expect(monitor).toHaveBeenCalledTimes(1);
+      await transport.release(UUID, true);
+    });
+
+    test('reuses a link that notifications already worked on without waiting', async () => {
+      const { transport, monitor, device } = createHarness();
+      // No result arrives: the link was already up before tracking could observe it.
+      const first = settle(transport.acquire({ uuid: UUID, expectedProtocol: 'V1' }));
+      await reachGate(device);
+      await advance(ANDROID_ENCRYPTION_RESULT_TIMEOUT_MS - 100);
+      expect(monitor).not.toHaveBeenCalled();
+      await runUntil(() => first.done);
+      expect(first.value).toEqual({ uuid: UUID, protocolType: 'V1' });
+      await transport.release(UUID, true);
+      monitor.mockClear();
+      device.characteristicsForService.mockClear();
+
+      const second = settle(transport.acquire({ uuid: UUID, expectedProtocol: 'V1' }));
+      await reachGate(device);
+
+      expect(monitor).toHaveBeenCalledTimes(1);
+      await runUntil(() => second.done);
+      expect(second.value).toEqual({ uuid: UUID, protocolType: 'V1' });
+      await transport.release(UUID, true);
+    });
+  });
+});

package/src/__tests__/enumerate.test.ts

@@ -25,13 +25,20 @@ jest.mock('../BleManager', () => ({
   pairDevice: jest.fn(),
 }));
 
-// The native facade is replaced wholesale above; key missing is covered by its own suite.
+// The native facade is replaced wholesale above; key missing and link encryption are covered
+// by their own suites.
 jest.mock('../bleKeyMissing', () => ({
   isBleKeyMissingSupported: jest.fn(() => false),
   startBleKeyMissingTracking: jest.fn(() => false),
   stopBleKeyMissingTracking: jest.fn(),
   waitForBleKeyMissing: jest.fn(() => Promise.resolve(false)),
 }));
+jest.mock('../bleEncryption', () => ({
+  markBleLinkEncrypted: jest.fn(),
+  startBleEncryptionTracking: jest.fn(() => false),
+  stopBleEncryptionTracking: jest.fn(),
+  waitForAndroidLinkEncryption: jest.fn(() => Promise.resolve('unresolved')),
+}));
 
 jest.mock('../subscribeBleOn', () => ({
   subscribeBleOn: jest.fn(() => Promise.resolve()),

package/src/__tests__/protocolReprobe.test.ts

@@ -1,3 +1,6 @@
+import { Platform } from 'react-native';
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+
 import ReactNativeBleTransport, { PROTOCOL_REPROBE_FALLBACK_ATTEMPTS } from '../index';
 import protocolV1Schema from './protocolV1SchemaFixture';
 
@@ -89,7 +92,9 @@ describe('protocol re-probe after a known device goes away', () => {
   test('an unknown device still probes both protocols', async () => {
     const { transport, probeV1, probeV2 } = createHarness({ v1: false, v2: false });
 
-    await expect(detect(transport)).rejects.toBeDefined();
+    await expect(detect(transport)).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.BleTimeoutError,
+    });
 
     expect(probeV1).toHaveBeenCalledTimes(1);
     expect(probeV2).toHaveBeenCalledTimes(1);
@@ -154,3 +159,113 @@ describe('protocol re-probe after a known device goes away', () => {
     expect((known.transport as any).protocolReprobeFailures.get(UUID)).toBeUndefined();
   });
 });
+
+describe('iOS reset-device stale bond confirmation', () => {
+  afterEach(() => {
+    Object.assign(Platform, { OS: 'ios' });
+  });
+
+  test('promotes a probe disconnect followed by a silent reconnect to BleBondInvalid', async () => {
+    const transport = new ReactNativeBleTransport({});
+    transport.configure(protocolV1Schema);
+    (transport as any).callProtocolV1 = jest
+      .fn()
+      .mockRejectedValue(ERRORS.TypedError(HardwareErrorCode.BleDeviceNotBonded));
+
+    await expect(detect(transport)).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.BleDeviceNotBonded,
+    });
+
+    (transport as any).probeProtocolV1 = jest.fn(() => Promise.resolve(false));
+    (transport as any).probeProtocolV2 = jest.fn(() => Promise.resolve(false));
+    (transport as any).resetProbeStateAfterProtocolProbe = jest.fn(() => Promise.resolve());
+
+    await expect(detect(transport)).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.BleBondInvalid,
+    });
+    await expect(detect(transport)).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.BleBondInvalid,
+    });
+    expect((transport as any).iosProbeDisconnectEvidence.has(UUID)).toBe(true);
+  });
+
+  test('promotes a repeated iOS probe disconnect without waiting for probe timeouts', () => {
+    const { transport } = createHarness({ v1: false, v2: false });
+    const firstError = Object.assign(new Error('The specified device has disconnected from us'), {
+      errorCode: 201,
+      iosErrorCode: 7,
+    });
+    const secondError = ERRORS.TypedError(HardwareErrorCode.BleDeviceDisconnected);
+
+    expect(
+      (transport as any).rememberIosProbeDisconnect(UUID, 'protocol-v1-get-features', firstError)
+    ).toBeUndefined();
+    expect(
+      (transport as any).rememberIosProbeDisconnect(UUID, 'protocol-v2-ping', secondError)
+    ).toMatchObject({ errorCode: HardwareErrorCode.BleBondInvalid });
+    expect((transport as any).iosProbeDisconnectEvidence.has(UUID)).toBe(true);
+  });
+
+  test('clears the disconnect evidence after a valid protocol response', async () => {
+    const { transport } = createHarness({ v1: true, v2: false });
+    (transport as any).rememberIosProbeDisconnect(
+      UUID,
+      'protocol-v1-get-features',
+      ERRORS.TypedError(HardwareErrorCode.BleDeviceNotBonded)
+    );
+
+    await expect(detect(transport)).resolves.toBe('V1');
+    expect((transport as any).iosProbeDisconnectEvidence.has(UUID)).toBe(false);
+  });
+
+  test('preserves evidence across disconnect and stalled setup cleanup', async () => {
+    const { transport } = createHarness({ v1: false, v2: false });
+    (transport as any).rememberIosProbeDisconnect(
+      UUID,
+      'protocol-v1-get-features',
+      ERRORS.TypedError(HardwareErrorCode.BleDeviceNotBonded)
+    );
+
+    await (transport as any).disconnectUnlocked(UUID);
+    expect((transport as any).iosProbeDisconnectEvidence.has(UUID)).toBe(true);
+
+    (transport as any).abandonStalledConnection(UUID, 'connect-native');
+    expect((transport as any).iosProbeDisconnectEvidence.has(UUID)).toBe(true);
+
+    await expect(detect(transport)).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.BleBondInvalid,
+    });
+  });
+
+  test('expires old disconnect evidence before classifying a later timeout', async () => {
+    const { transport } = createHarness({ v1: false, v2: false });
+    (transport as any).rememberIosProbeDisconnect(
+      UUID,
+      'protocol-v1-get-features',
+      ERRORS.TypedError(HardwareErrorCode.BleDeviceNotBonded)
+    );
+    const evidence = (transport as any).iosProbeDisconnectEvidence.get(UUID);
+    evidence.recordedAt = Date.now() - 5 * 60_000 - 1;
+
+    await expect(detect(transport)).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.BleTimeoutError,
+    });
+    expect((transport as any).iosProbeDisconnectEvidence.has(UUID)).toBe(false);
+  });
+
+  test('does not classify the same sequence as a stale bond on Android', async () => {
+    Object.assign(Platform, { OS: 'android' });
+    const { transport } = createHarness({ v1: false, v2: false });
+
+    expect(
+      (transport as any).rememberIosProbeDisconnect(
+        UUID,
+        'protocol-v1-get-features',
+        ERRORS.TypedError(HardwareErrorCode.BleDeviceNotBonded)
+      )
+    ).toBeUndefined();
+    await expect(detect(transport)).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.BleTimeoutError,
+    });
+  });
+});

package/src/__tests__/protocolV2Link.test.ts

@@ -45,13 +45,20 @@ jest.mock('../BleManager', () => ({
   pairDevice: jest.fn(() => Promise.resolve({ bonded: true, bonding: false })),
 }));
 
-// The native facade is replaced wholesale above; key missing is covered by its own suite.
+// The native facade is replaced wholesale above; key missing and link encryption are covered
+// by their own suites.
 jest.mock('../bleKeyMissing', () => ({
   isBleKeyMissingSupported: jest.fn(() => false),
   startBleKeyMissingTracking: jest.fn(() => false),
   stopBleKeyMissingTracking: jest.fn(),
   waitForBleKeyMissing: jest.fn(() => Promise.resolve(false)),
 }));
+jest.mock('../bleEncryption', () => ({
+  markBleLinkEncrypted: jest.fn(),
+  startBleEncryptionTracking: jest.fn(() => false),
+  stopBleEncryptionTracking: jest.fn(),
+  waitForAndroidLinkEncryption: jest.fn(() => Promise.resolve('unresolved')),
+}));
 
 jest.mock('../subscribeBleOn', () => ({
   subscribeBleOn: jest.fn(() => Promise.resolve()),