@onekeyfe/hardware-cli 1.2.0-alpha.17 → 1.2.0-alpha.170

package/src/__tests__/noble-ble-plugin.test.ts

@@ -33,12 +33,13 @@ const createPeripheral = (id: string) => {
       state: 'connected',
       advertisement: {
         localName: `OneKey Pro 2 ${id}`,
-        serviceUuids: ['fffd'],
+        serviceUuids: ['0001'],
       },
       discoverServices: jest.fn((_uuids, callback) => callback(null, [service])),
       connect: jest.fn(callback => callback()),
       disconnect: jest.fn(callback => callback()),
     },
+    service,
     write,
     notify,
   };
@@ -46,10 +47,74 @@ const createPeripheral = (id: string) => {
 
 describe('Noble BLE plugin notification routing', () => {
   afterEach(() => {
+    jest.useRealTimers();
     jest.resetModules();
     jest.clearAllMocks();
   });
 
+  test('does not enumerate Find My advertisements that expose FFFD', async () => {
+    jest.useFakeTimers({ doNotFake: ['performance'] });
+    const oneKey = createPeripheral('onekey-device');
+    const findMy = createPeripheral('find-my-device');
+    findMy.peripheral.advertisement.localName = 'Find My';
+    findMy.peripheral.advertisement.serviceUuids = ['fffd'];
+    const noble = new EventEmitter() as EventEmitter & {
+      state: string;
+      startScanning: jest.Mock;
+      stopScanning: jest.Mock;
+    };
+    noble.state = 'poweredOn';
+    noble.startScanning = jest.fn((_services, _duplicates, callback) => {
+      callback?.();
+      noble.emit('discover', findMy.peripheral);
+      noble.emit('discover', oneKey.peripheral);
+    });
+    noble.stopScanning = jest.fn(callback => callback?.());
+    jest.doMock('@stoprocent/noble', () => noble);
+
+    const { createNobleBlePlugin } = await import('../transports/nobleBlePlugin');
+    const plugin = createNobleBlePlugin();
+    await plugin.init();
+    const devicesPromise = plugin.enumerate();
+    await Promise.resolve();
+    jest.runAllTimers();
+    await Promise.resolve();
+
+    await expect(devicesPromise).resolves.toEqual([
+      expect.objectContaining({ id: 'onekey-device' }),
+    ]);
+    jest.useRealTimers();
+  });
+
+  test('does not enumerate a name-only candidate without the communication service', async () => {
+    jest.useFakeTimers({ doNotFake: ['performance'] });
+    const nameOnly = createPeripheral('name-only-device');
+    nameOnly.peripheral.advertisement.serviceUuids = [];
+    const noble = new EventEmitter() as EventEmitter & {
+      state: string;
+      startScanning: jest.Mock;
+      stopScanning: jest.Mock;
+    };
+    noble.state = 'poweredOn';
+    noble.startScanning = jest.fn((_services, _duplicates, callback) => {
+      callback?.();
+      noble.emit('discover', nameOnly.peripheral);
+    });
+    noble.stopScanning = jest.fn(callback => callback?.());
+    jest.doMock('@stoprocent/noble', () => noble);
+
+    const { createNobleBlePlugin } = await import('../transports/nobleBlePlugin');
+    const plugin = createNobleBlePlugin();
+    await plugin.init();
+    const devicesPromise = plugin.enumerate();
+    await Promise.resolve();
+    jest.runAllTimers();
+    await Promise.resolve();
+
+    await expect(devicesPromise).resolves.toEqual([]);
+    jest.useRealTimers();
+  });
+
   test('routes notifications to the receiver waiting for the same device', async () => {
     const deviceA = createPeripheral('device-a');
     const deviceB = createPeripheral('device-b');
@@ -112,6 +177,82 @@ describe('Noble BLE plugin notification routing', () => {
     expect(result).toBe('completed');
   });
 
+  test('disconnects an untracked peripheral when service discovery fails', async () => {
+    const device = createPeripheral('device-a');
+    device.peripheral.discoverServices.mockImplementation((_uuids, callback) =>
+      callback(new Error('service discovery failed'))
+    );
+    const noble = new EventEmitter() as EventEmitter & {
+      state: string;
+      startScanning: jest.Mock;
+      stopScanning: jest.Mock;
+    };
+    noble.state = 'poweredOn';
+    noble.startScanning = jest.fn((_services, _duplicates, callback) => {
+      callback?.();
+      noble.emit('discover', device.peripheral);
+    });
+    noble.stopScanning = jest.fn(callback => callback?.());
+    jest.doMock('@stoprocent/noble', () => noble);
+
+    const { createNobleBlePlugin } = await import('../transports/nobleBlePlugin');
+    const plugin = createNobleBlePlugin();
+    await plugin.init();
+
+    await expect(plugin.connect('device-a')).rejects.toThrow('service discovery failed');
+    expect(device.peripheral.disconnect).toHaveBeenCalledTimes(1);
+  });
+
+  test('rejects a vendor-specific service containing the OneKey short UUID', async () => {
+    const device = createPeripheral('device-a');
+    device.service.uuid = 'abcd0001-1234-5678-9012-abcdefabcdef';
+    const noble = new EventEmitter() as EventEmitter & {
+      state: string;
+      startScanning: jest.Mock;
+      stopScanning: jest.Mock;
+    };
+    noble.state = 'poweredOn';
+    noble.startScanning = jest.fn((_services, _duplicates, callback) => {
+      callback?.();
+      noble.emit('discover', device.peripheral);
+    });
+    noble.stopScanning = jest.fn(callback => callback?.());
+    jest.doMock('@stoprocent/noble', () => noble);
+
+    const { createNobleBlePlugin } = await import('../transports/nobleBlePlugin');
+    const plugin = createNobleBlePlugin();
+    await plugin.init();
+
+    await expect(plugin.connect('device-a')).rejects.toThrow('No BLE service found');
+  });
+
+  test('unsubscribes and disconnects an untracked peripheral when notification setup fails', async () => {
+    const device = createPeripheral('device-a');
+    device.notify.subscribe.mockImplementation(callback =>
+      callback(new Error('notification setup failed'))
+    );
+    const noble = new EventEmitter() as EventEmitter & {
+      state: string;
+      startScanning: jest.Mock;
+      stopScanning: jest.Mock;
+    };
+    noble.state = 'poweredOn';
+    noble.startScanning = jest.fn((_services, _duplicates, callback) => {
+      callback?.();
+      noble.emit('discover', device.peripheral);
+    });
+    noble.stopScanning = jest.fn(callback => callback?.());
+    jest.doMock('@stoprocent/noble', () => noble);
+
+    const { createNobleBlePlugin } = await import('../transports/nobleBlePlugin');
+    const plugin = createNobleBlePlugin();
+    await plugin.init();
+
+    await expect(plugin.connect('device-a')).rejects.toThrow('notification setup failed');
+    expect(device.notify.unsubscribe).toHaveBeenCalled();
+    expect(device.peripheral.disconnect).toHaveBeenCalledTimes(1);
+  });
+
   test('uses withoutResponse for normal and high-volume writes', async () => {
     const device = createPeripheral('device-a');
     const noble = new EventEmitter() as EventEmitter & {
@@ -163,7 +304,11 @@ describe('Noble BLE plugin notification routing', () => {
 
     await (plugin.send as any)('device-a', 'aa', { withoutResponse: false });
 
-    expect(device.write.write).toHaveBeenCalledWith(expect.any(Buffer), false, expect.any(Function));
+    expect(device.write.write).toHaveBeenCalledWith(
+      expect.any(Buffer),
+      false,
+      expect.any(Function)
+    );
   });
 
   test('does not add a fixed delay between 192-byte writes', async () => {

package/src/__tests__/wallet-session.test.ts

@@ -0,0 +1,64 @@
+import { prepareSession } from '../cli';
+import { resolvePassphraseByChoice } from '../sdk';
+import { preloadSessionFromKeychain } from '../session';
+
+jest.mock('../session', () => ({
+  clearSessionFromKeychain: jest.fn(),
+  preloadSessionFromKeychain: jest.fn(),
+}));
+
+describe('CLI wallet session', () => {
+  test('maps the Attach PIN choice to an on-device Attach PIN response', async () => {
+    await expect(resolvePassphraseByChoice('4')).resolves.toEqual({
+      value: '',
+      passphraseOnDevice: false,
+      attachPinOnDevice: true,
+    });
+  });
+
+  test('uses the public wallet identity without persisting an internal session id', async () => {
+    const sdk = {
+      searchDevices: jest.fn().mockResolvedValue({
+        success: true,
+        payload: [
+          {
+            connectId: 'pro2-connect-id',
+            deviceId: 'device-id',
+            deviceType: 'pro2',
+            features: {
+              deviceId: 'device-id',
+              deviceType: 'pro2',
+              unlocked: true,
+              passphraseProtection: true,
+            },
+          },
+        ],
+      }),
+      getFeatures: jest.fn(),
+      openWalletSession: jest.fn().mockResolvedValue({
+        success: true,
+        payload: {
+          protocol: 'V2',
+          walletType: 'hidden',
+          deviceId: 'device-id',
+          passphraseState: 'wallet-state',
+          resumed: false,
+        },
+      }),
+    };
+    const globalOpts: Record<string, unknown> = {};
+    (preloadSessionFromKeychain as jest.Mock).mockResolvedValueOnce(undefined);
+
+    await expect(prepareSession(sdk as never, globalOpts)).resolves.toBe('wallet-state');
+
+    expect(sdk.openWalletSession).toHaveBeenCalledWith('pro2-connect-id', {
+      mode: 'select-hidden',
+    });
+    expect(sdk.getFeatures).not.toHaveBeenCalled();
+    expect(globalOpts).toMatchObject({
+      connectId: 'pro2-connect-id',
+      deviceId: 'device-id',
+      passphraseState: 'wallet-state',
+    });
+  });
+});

package/src/__tests__/wallpaper-upload-command.test.ts

@@ -6,6 +6,7 @@ describe('upload-wallpaper CLI command', () => {
 
     expect(command).toBeDefined();
     expect(command?.description()).toBe('Upload and activate a Pro2 wallpaper');
+    expect(command?.options.some(option => option.long === '--jpeg' && option.required)).toBe(true);
   });
 
   test('reports effective transfer speed from encoded bytes and elapsed time', () => {