@onekeyfe/hd-core 1.2.0-alpha.8 → 1.2.0-alpha.81

package/__tests__/public-device-state-api.test.ts

@@ -0,0 +1,275 @@
+import { EFirmwareType, HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import * as publicMethods from '../src/api';
+import * as publicTypes from '../src/types';
+import GetFeatures from '../src/api/GetFeatures';
+import GetOnekeyFeatures from '../src/api/GetOnekeyFeatures';
+import DeviceInfoGet from '../src/api/protocol-v2/DeviceInfoGet';
+import DeviceStatusGet from '../src/api/protocol-v2/DeviceStatusGet';
+import { createEmptyDeviceState } from '../src/device/DeviceStateStore';
+import { findMethod } from '../src/api/utils';
+import { createCoreApi } from '../src/inject';
+
+import type { CoreApi } from '../src/types/api';
+
+jest.mock('../src/data/config', () => ({
+  DEFAULT_DOMAIN: 'https://example.com/',
+  getSDKVersion: () => '0.0.0-test',
+}));
+
+describe('public device state API boundary', () => {
+  test('exports canonical wallet session modes', () => {
+    expect((publicTypes as Record<string, unknown>).OpenWalletSessionMode).toEqual({
+      Standard: 'standard',
+      SelectHidden: 'select-hidden',
+      ResumeHidden: 'resume-hidden',
+    });
+  });
+
+  test('exposes canonical device state operations without raw settings methods', () => {
+    const api = createCoreApi(jest.fn() as CoreApi['call']) as Record<string, unknown>;
+
+    expect(api.getDeviceState).toBeInstanceOf(Function);
+    expect(api.getPassphraseState).toBeInstanceOf(Function);
+    expect(api.openWalletSession).toBeInstanceOf(Function);
+    expect(api.clearSessionCache).toBeInstanceOf(Function);
+    expect(api.deviceGetOnboardingStatus).toBeInstanceOf(Function);
+    expect(api.uploadPortfolio).toBeInstanceOf(Function);
+    expect(api).not.toHaveProperty('refreshDeviceState');
+    expect(api.getFeatures).toBeInstanceOf(Function);
+    expect(api.getOnekeyFeatures).toBeInstanceOf(Function);
+    expect(api).not.toHaveProperty('getDeviceInfo');
+    expect(api).not.toHaveProperty('deviceInfoGet');
+    expect(api).not.toHaveProperty('deviceStatusGet');
+    expect(api).not.toHaveProperty('deviceSettingsGet');
+    expect(api).not.toHaveProperty('deviceSessionOpen');
+    expect(api).not.toHaveProperty('deviceSettingsSet');
+    expect(api).not.toHaveProperty('deviceSettingsPageShow');
+    expect(api).not.toHaveProperty('deviceFirmwareUpdate');
+    expect(api).not.toHaveProperty('deviceGetFirmwareUpdateStatus');
+    expect(api).not.toHaveProperty('deviceFactoryInfoSet');
+    expect(api).not.toHaveProperty('deviceFactoryInfoGet');
+    expect(api).not.toHaveProperty('filesystemPermissionFix');
+    expect(api).not.toHaveProperty('filesystemFormat');
+    expect(api).not.toHaveProperty('fileRead');
+    expect(api).not.toHaveProperty('fileWrite');
+    expect(api).not.toHaveProperty('fileDelete');
+    expect(api).not.toHaveProperty('dirRemove');
+    expect(api).not.toHaveProperty('filesystemFileRead');
+    expect(api).not.toHaveProperty('filesystemDirList');
+
+    expect(publicMethods).not.toHaveProperty('getDeviceInfo');
+    expect(publicMethods).not.toHaveProperty('deviceInfoGet');
+    expect(publicMethods).not.toHaveProperty('deviceStatusGet');
+    expect(publicMethods).not.toHaveProperty('deviceSettingsGet');
+    expect(publicMethods).not.toHaveProperty('deviceSessionOpen');
+    expect(publicMethods).not.toHaveProperty('deviceSettingsSet');
+    expect(publicMethods).not.toHaveProperty('deviceSettingsPageShow');
+    expect(publicMethods).not.toHaveProperty('filesystemPermissionFix');
+    expect(publicMethods).not.toHaveProperty('filesystemFormat');
+    expect(publicMethods).not.toHaveProperty('fileRead');
+    expect(publicMethods).not.toHaveProperty('fileWrite');
+    expect(publicMethods).not.toHaveProperty('fileDelete');
+    expect(publicMethods).not.toHaveProperty('dirRemove');
+    expect(publicMethods).not.toHaveProperty('filesystemFileRead');
+  });
+
+  test('forwards the V1 compatibility API and the explicit V2 wallet session API', async () => {
+    const call = jest.fn().mockResolvedValue({ success: true, payload: {} });
+    const api = createCoreApi(call as CoreApi['call']) as CoreApi;
+
+    await api.getPassphraseState('device-1', {
+      initSession: true,
+      useEmptyPassphrase: false,
+    });
+    await api.openWalletSession('device-2', {
+      mode: publicTypes.OpenWalletSessionMode.ResumeHidden,
+      deviceId: 'wallet-device-1',
+      passphraseState: 'wallet-state-1',
+    });
+    await api.clearSessionCache({
+      deviceId: 'wallet-device-1',
+      passphraseState: 'wallet-state-1',
+    });
+
+    expect(call).toHaveBeenNthCalledWith(1, {
+      connectId: 'device-1',
+      initSession: true,
+      useEmptyPassphrase: false,
+      method: 'getPassphraseState',
+    });
+    expect(call).toHaveBeenNthCalledWith(2, {
+      connectId: 'device-2',
+      mode: 'resume-hidden',
+      deviceId: 'wallet-device-1',
+      passphraseState: 'wallet-state-1',
+      method: 'openWalletSession',
+    });
+    expect(call).toHaveBeenNthCalledWith(3, {
+      deviceId: 'wallet-device-1',
+      passphraseState: 'wallet-state-1',
+      method: 'clearSessionCache',
+    });
+  });
+
+  test('forwards only the semantic scope through getDeviceState', async () => {
+    const call = jest.fn().mockResolvedValue({ success: true, payload: {} });
+    const api = createCoreApi(call as CoreApi['call']) as CoreApi;
+
+    await api.getDeviceState('device-1');
+    await (api.getDeviceState as any)('device-1', {
+      scope: 'settings',
+      refresh: ['status'],
+      includeRaw: true,
+    });
+
+    expect(call).toHaveBeenNthCalledWith(1, {
+      connectId: 'device-1',
+      method: 'getDeviceState',
+    });
+    expect(call).toHaveBeenNthCalledWith(2, {
+      connectId: 'device-1',
+      method: 'getDeviceState',
+      scope: 'settings',
+    });
+  });
+
+  test('keeps Protocol V2 command implementations available inside the SDK', () => {
+    expect(DeviceInfoGet).toBeDefined();
+    expect(DeviceStatusGet).toBeDefined();
+  });
+
+  test.each([
+    'deviceSessionOpen',
+    'deviceSettingsGet',
+    'deviceSettingsSet',
+    'deviceSettingsPageShow',
+  ])('rejects removed raw method %s', name => {
+    expect(() =>
+      findMethod({
+        id: 1,
+        payload: { method: name },
+      } as any)
+    ).toThrow(`Method ${name} is not set`);
+  });
+
+  test.each([
+    'deviceFirmwareUpdate',
+    'deviceFactoryInfoSet',
+    'filesystemPermissionFix',
+    'filesystemFormat',
+    'deviceInfoGet',
+    'deviceStatusGet',
+    'protocolInfoRequest',
+    'ping',
+    'deviceGetFirmwareUpdateStatus',
+    'deviceFactoryInfoGet',
+    'fileRead',
+    'dirList',
+    'dirMake',
+    'pathInfo',
+    'fileWrite',
+    'fileDelete',
+    'dirRemove',
+  ])('rejects removed privileged method %s', name => {
+    expect(() =>
+      findMethod({
+        id: 1,
+        payload: { method: name },
+      } as any)
+    ).toThrow(`Method ${name} is not set`);
+  });
+
+  test('projects getFeatures from the canonical state for Protocol V1 compatibility', async () => {
+    const state = createEmptyDeviceState({
+      deviceId: 'device-1',
+      serialNo: 'SERIAL-1',
+      label: 'Unified',
+    });
+    const getDeviceState = jest.fn().mockResolvedValue(state);
+    const method = new GetFeatures({ id: 1, payload: { method: 'getFeatures' } });
+    method.init();
+    expect(method.unlockPolicy).toBe('none');
+    (method as any).device = {
+      getDeviceState,
+      getCurrentFirmwareType: () => 'universal',
+      isBootloader: () => false,
+      isProtocolV2: () => false,
+    };
+
+    await expect(method.run()).resolves.toMatchObject({
+      deviceId: 'device-1',
+      label: 'Unified',
+    });
+    expect(getDeviceState).toHaveBeenCalledWith({
+      includeRaw: true,
+    });
+  });
+
+  test('declares getFeatures unsupported on Protocol V2 devices', () => {
+    const getDeviceState = jest.fn();
+    const method = new GetFeatures({ id: 1, payload: { method: 'getFeatures' } });
+    method.init();
+    expect(method.unlockPolicy).toBe('none');
+    (method as any).device = {
+      getDeviceState,
+      getCurrentFirmwareType: () => 'universal',
+      isBootloader: () => false,
+      isProtocolV2: () => true,
+    };
+
+    expect(() => method.assertProtocolSupported('V2', EFirmwareType.Universal)).toThrow(
+      expect.objectContaining({ errorCode: HardwareErrorCode.DeviceNotSupportMethod })
+    );
+    expect(getDeviceState).not.toHaveBeenCalled();
+  });
+
+  test('declares getOnekeyFeatures unsupported on Protocol V2 devices', () => {
+    const typedCall = jest.fn();
+    const method = new GetOnekeyFeatures({ id: 1, payload: { method: 'getOnekeyFeatures' } });
+    method.init();
+    expect(method.unlockPolicy).toBe('none');
+    (method as any).device = {
+      commands: { typedCall },
+      getCurrentFirmwareType: () => 'universal',
+      isProtocolV2: () => true,
+    };
+
+    expect(() => method.assertProtocolSupported('V2', EFirmwareType.Universal)).toThrow(
+      expect.objectContaining({ errorCode: HardwareErrorCode.DeviceNotSupportMethod })
+    );
+    expect(typedCall).not.toHaveBeenCalled();
+  });
+});
+
+// These raw Protocol V2 commands are intentionally absent from CoreApi.
+// @ts-expect-error getDeviceInfo is not part of the public API
+type RemovedGetDeviceInfo = CoreApi['getDeviceInfo'];
+// @ts-expect-error deviceInfoGet is not part of the public API
+type RemovedDeviceInfoGet = CoreApi['deviceInfoGet'];
+// @ts-expect-error deviceStatusGet is not part of the public API
+type RemovedDeviceStatusGet = CoreApi['deviceStatusGet'];
+// @ts-expect-error protocolInfoRequest is not part of the public API
+type RemovedProtocolInfoRequest = CoreApi['protocolInfoRequest'];
+// @ts-expect-error ping is not part of the public API
+type RemovedPing = CoreApi['ping'];
+// @ts-expect-error deviceGetFirmwareUpdateStatus is not part of the public API
+type RemovedFirmwareUpdateStatus = CoreApi['deviceGetFirmwareUpdateStatus'];
+// @ts-expect-error deviceFactoryInfoGet is not part of the public API
+type RemovedFactoryInfoGet = CoreApi['deviceFactoryInfoGet'];
+// @ts-expect-error fileRead is not part of the public API
+type RemovedFileRead = CoreApi['fileRead'];
+// @ts-expect-error dirList is not part of the public API
+type RemovedDirList = CoreApi['dirList'];
+// @ts-expect-error dirMake is not part of the public API
+type RemovedDirMake = CoreApi['dirMake'];
+// @ts-expect-error pathInfo is not part of the public API
+type RemovedPathInfo = CoreApi['pathInfo'];
+// @ts-expect-error deviceSettingsGet is not part of the public API
+type RemovedDeviceSettingsGet = CoreApi['deviceSettingsGet'];
+// @ts-expect-error deviceSettingsSet is not part of the public API
+type RemovedDeviceSettingsSet = CoreApi['deviceSettingsSet'];
+// @ts-expect-error deviceSettingsPageShow is not part of the public API
+type RemovedDeviceSettingsPageShow = CoreApi['deviceSettingsPageShow'];
+// @ts-expect-error refreshDeviceState was replaced by getDeviceState scope
+type RemovedRefreshDeviceState = CoreApi['refreshDeviceState'];

package/__tests__/public-pro2-api-boundary.test.ts

@@ -0,0 +1,107 @@
+import * as publicMethods from '../src/api';
+import { findMethod } from '../src/api/utils';
+import { createCoreApi } from '../src/inject';
+
+import type { CoreApi } from '../src/types/api';
+
+jest.mock('../src/data/config', () => ({
+  DEFAULT_DOMAIN: 'https://example.com/',
+  getSDKVersion: () => '0.0.0-test',
+}));
+
+const removedRawMethodNames = [
+  'deviceInfoGet',
+  'deviceStatusGet',
+  'protocolInfoRequest',
+  'ping',
+  'deviceGetFirmwareUpdateStatus',
+  'deviceFactoryInfoGet',
+  'deviceSettingsGet',
+  'deviceSettingsSet',
+  'deviceSettingsPageShow',
+  'deviceFactoryInfoSet',
+  'filesystemFormat',
+  'filesystemPermissionFix',
+  'deviceFirmwareUpdate',
+  'fileRead',
+  'fileWrite',
+  'fileDelete',
+  'dirList',
+  'dirMake',
+  'dirRemove',
+  'pathInfo',
+  'testProtocolV2FileWrite',
+] as const;
+
+const unpublishedFilesystemAliases = [
+  'filesystemFileRead',
+  'filesystemFileWrite',
+  'filesystemFileDelete',
+  'filesystemDirList',
+  'filesystemDirMake',
+  'filesystemDirRemove',
+  'filesystemPathInfoQuery',
+] as const;
+
+describe('public Pro2 API boundary', () => {
+  test('exposes business APIs without raw device or filesystem commands', () => {
+    const api = createCoreApi(jest.fn() as CoreApi['call']) as Record<string, unknown>;
+
+    expect(api.deviceGetOnboardingStatus).toBeInstanceOf(Function);
+    expect(api.deviceUploadNft).toBeInstanceOf(Function);
+    expect(api.uploadPortfolio).toBeInstanceOf(Function);
+    expect(api.testProtocolV2Ping).toBeInstanceOf(Function);
+    expect(publicMethods.testProtocolV2Ping).toBeInstanceOf(Function);
+
+    expect(api).not.toHaveProperty('deviceSessionOpen');
+    expect(publicMethods).not.toHaveProperty('deviceSessionOpen');
+    removedRawMethodNames.forEach(name => {
+      expect(api).not.toHaveProperty(name);
+      expect(publicMethods).not.toHaveProperty(name);
+    });
+    unpublishedFilesystemAliases.forEach(name => {
+      expect(api).not.toHaveProperty(name);
+      expect(publicMethods).not.toHaveProperty(name);
+    });
+  });
+
+  test('routes the diagnostic Protocol V2 Ping without publishing the raw ping command', async () => {
+    const call = jest.fn().mockResolvedValue({ success: true, payload: { message: 'benchmark' } });
+    const api = createCoreApi(call as CoreApi['call']) as CoreApi;
+
+    await api.testProtocolV2Ping('connect-id', {
+      message: 'benchmark',
+      connectProtocol: 'V2',
+    });
+
+    expect(call).toHaveBeenCalledWith({
+      method: 'testProtocolV2Ping',
+      connectId: 'connect-id',
+      message: 'benchmark',
+      connectProtocol: 'V2',
+    });
+    expect(api).not.toHaveProperty('ping');
+    expect(publicMethods).not.toHaveProperty('ping');
+  });
+
+  test('rejects deviceSessionOpen at the SDK dispatcher boundary', () => {
+    expect(() =>
+      findMethod({
+        id: 1,
+        payload: { method: 'deviceSessionOpen' },
+      } as any)
+    ).toThrow('Method deviceSessionOpen is not set');
+  });
+
+  test.each(removedRawMethodNames)(
+    'rejects removed raw method %s at the SDK dispatcher boundary',
+    name => {
+      expect(() =>
+        findMethod({
+          id: 1,
+          payload: { method: name },
+        } as any)
+      ).toThrow(`Method ${name} is not set`);
+    }
+  );
+});

package/__tests__/refresh-device-state.test.ts

@@ -0,0 +1,101 @@
+import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import GetDeviceState from '../src/api/GetDeviceState';
+
+jest.mock('../src/data/config', () => ({
+  getSDKVersion: jest.fn(() => '1.0.0'),
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
+}));
+
+describe('live device state reads', () => {
+  test('public getDeviceState defaults to a runtime refresh and ignores raw controls', async () => {
+    const getDeviceState = jest.fn().mockResolvedValue({ revision: 1 });
+    const method = new GetDeviceState({
+      id: 1,
+      payload: {
+        method: 'getDeviceState',
+        refresh: ['status'],
+        includeRaw: true,
+      },
+    });
+    method.init();
+    (method as any).device = { getDeviceState };
+
+    await method.run();
+
+    expect(getDeviceState).toHaveBeenCalledWith({ refreshSections: ['status'] });
+    expect(method.unlockPolicy).toBe('none');
+  });
+
+  test.each([
+    ['firmware', ['status', 'identity', 'versions', 'verification']],
+    ['settings', ['status', 'settings']],
+    ['runtime', ['status']],
+  ] as const)('maps the %s scope to internal refresh sections', async (scope, refreshSections) => {
+    const getDeviceState = jest.fn().mockResolvedValue({
+      revision: 2,
+      status: { mode: 'normal' },
+    });
+    const method = new GetDeviceState({
+      id: 1,
+      payload: { method: 'getDeviceState', scope },
+    });
+    method.init();
+    (method as any).device = {
+      isProtocolV2: () => true,
+      getDeviceState,
+    };
+
+    await method.run();
+
+    expect(getDeviceState).toHaveBeenCalledWith({ refreshSections: [...refreshSections] });
+  });
+
+  test.each(['bootloader', 'romloader'] as const)(
+    'returns loader state without rejecting the default runtime read in %s mode',
+    async mode => {
+      const state = { status: { mode } };
+      const getDeviceState = jest.fn().mockResolvedValue(state);
+      const method = new GetDeviceState({
+        id: 1,
+        payload: { method: 'getDeviceState' },
+      });
+      method.init();
+      (method as any).device = {
+        isProtocolV2: () => true,
+        getDeviceState,
+      };
+
+      await expect(method.run()).resolves.toBe(state);
+      expect(getDeviceState).toHaveBeenCalledWith({ refreshSections: ['status'] });
+    }
+  );
+
+  test('rejects settings scope in loader mode after minimal mode detection', async () => {
+    const getDeviceState = jest.fn().mockResolvedValue({ status: { mode: 'bootloader' } });
+    const method = new GetDeviceState({
+      id: 1,
+      payload: { method: 'getDeviceState', scope: 'settings' },
+    });
+    method.init();
+    (method as any).device = {
+      isProtocolV2: () => true,
+      getCurrentFirmwareType: () => 'universal',
+      getDeviceState,
+    };
+
+    await expect(method.run()).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.DeviceNotSupportMethod,
+    });
+    expect(getDeviceState).toHaveBeenCalledWith({ refreshSections: ['status', 'settings'] });
+  });
+
+  test('rejects an unknown scope', () => {
+    const method = new GetDeviceState({
+      id: 1,
+      payload: { method: 'getDeviceState', scope: 'unknown' as any },
+    });
+
+    expect(() => method.init()).toThrow();
+  });
+});

package/__tests__/request-context-logging.test.ts

@@ -0,0 +1,16 @@
+import { LoggerNames, getLogger } from '../src/utils/logger';
+import { completeRequestContext, createRequestContext } from '../src/utils/tracing';
+
+describe('RequestContext 错误日志', () => {
+  test('已作为 API 响应返回的请求错误不写入 console.error 级别', () => {
+    const logger = getLogger(LoggerNames.Core);
+    const errorSpy = jest.spyOn(logger, 'error').mockImplementation(() => undefined);
+    const debugSpy = jest.spyOn(logger, 'debug').mockImplementation(() => undefined);
+
+    createRequestContext(1001, 'searchDevices', { sdkInstanceId: 'SDK-test' });
+    completeRequestContext(1001, new Error('device did not respond'));
+
+    expect(errorSpy).not.toHaveBeenCalled();
+    expect(debugSpy).toHaveBeenCalledWith(expect.stringContaining('method=searchDevices'));
+  });
+});

package/__tests__/search-devices.test.ts

@@ -0,0 +1,145 @@
+import SearchDevices from '../src/api/SearchDevices';
+
+jest.mock('../src/data-manager/TransportManager', () => ({
+  __esModule: true,
+  default: {
+    configure: jest.fn(),
+  },
+}));
+
+jest.mock('../src/data-manager', () => ({
+  DataManager: {
+    getSettings: jest.fn(() => 'webusb'),
+    isBleConnect: jest.fn(() => false),
+  },
+}));
+
+jest.mock('../src/device/DevicePool', () => ({
+  DevicePool: {
+    getDevices: jest.fn(),
+  },
+}));
+
+const transportManagerMock: { default: { configure: jest.Mock } } = jest.requireMock(
+  '../src/data-manager/TransportManager'
+);
+const devicePoolMock: { DevicePool: { getDevices: jest.Mock } } = jest.requireMock(
+  '../src/device/DevicePool'
+);
+const dataManagerMock: {
+  DataManager: {
+    getSettings: jest.Mock;
+    isBleConnect: jest.Mock;
+  };
+} = jest.requireMock('../src/data-manager');
+const { configure: mockConfigureTransport } = transportManagerMock.default;
+const { getDevices: mockGetDevices } = devicePoolMock.DevicePool;
+const { isBleConnect: mockIsBleConnect } = dataManagerMock.DataManager;
+
+describe('SearchDevices', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockIsBleConnect.mockReturnValue(false);
+  });
+
+  test('搜索忽略调用方协议并主动探测，单个无响应设备不阻断后续结果', async () => {
+    const unresponsiveDescriptor = {
+      path: 'stale-usb-device',
+      id: 'stale-usb-device',
+    } as any;
+    const availableDescriptor = {
+      path: 'available-usb-device',
+      id: 'available-usb-device',
+    } as any;
+    const availableDeviceInfo = {
+      connectId: 'available-usb-device',
+      deviceType: 'pro2',
+    };
+    const availableDevice = {
+      toMessageObject: jest.fn(() => availableDeviceInfo),
+    } as any;
+
+    mockGetDevices
+      .mockRejectedValueOnce(
+        new Error(
+          'Unable to detect USB protocol: device did not respond to Protocol V1 Initialize or Protocol V2 Ping'
+        )
+      )
+      .mockResolvedValueOnce({
+        devices: { 'available-usb-device': availableDevice },
+        deviceList: [availableDevice],
+      });
+
+    const method = new SearchDevices({
+      id: 1,
+      payload: {
+        method: 'searchDevices',
+        connectProtocol: 'V2',
+      },
+    } as any);
+    method.init();
+    method.connector = {
+      enumerate: jest.fn().mockResolvedValue({
+        descriptors: [unresponsiveDescriptor, availableDescriptor],
+      }),
+    } as any;
+
+    await expect(method.run()).resolves.toEqual([availableDeviceInfo]);
+    expect(mockConfigureTransport).toHaveBeenCalledTimes(1);
+    expect(mockGetDevices).toHaveBeenNthCalledWith(
+      1,
+      [unresponsiveDescriptor],
+      unresponsiveDescriptor.path,
+      {
+        connectProtocol: undefined,
+        forceProtocolDetection: true,
+        refreshRuntimeState: true,
+      }
+    );
+    expect(mockGetDevices).toHaveBeenNthCalledWith(
+      2,
+      [availableDescriptor],
+      availableDescriptor.path,
+      {
+        connectProtocol: undefined,
+        forceProtocolDetection: true,
+        refreshRuntimeState: true,
+      }
+    );
+  });
+
+  test('BLE discovery keeps transport identity separate from the unavailable serial number', async () => {
+    mockIsBleConnect.mockReturnValue(true);
+
+    const descriptor = {
+      id: 'ble-peripheral-id',
+      path: 'ble-peripheral-id',
+      name: 'OneKey Pro 2',
+      commType: 'ble',
+    };
+    const method = new SearchDevices({
+      id: 1,
+      payload: {
+        method: 'searchDevices',
+      },
+    } as any);
+    method.init();
+    method.connector = {
+      enumerate: jest.fn().mockResolvedValue({
+        descriptors: [descriptor],
+      }),
+    } as any;
+
+    await expect(method.run()).resolves.toEqual([
+      {
+        ...descriptor,
+        connectId: 'ble-peripheral-id',
+        serialNo: null,
+        uuid: 'ble-peripheral-id',
+        deviceId: null,
+        deviceType: 'pro2',
+      },
+    ]);
+    expect(mockGetDevices).not.toHaveBeenCalled();
+  });
+});