@onekeyfe/hardware-cli 1.2.0-alpha.2 → 1.2.0-alpha.21

package/src/__tests__/device-state-commands.test.ts

@@ -0,0 +1,118 @@
+import { getCanonicalDeviceState, getCompatibleFeatures } from '../deviceStateCommands';
+
+const createSdkMock = () => ({
+  searchDevices: jest.fn(),
+  getDeviceState: jest.fn(),
+  getFeatures: jest.fn(),
+});
+
+describe('设备状态 CLI 兼容层', () => {
+  test('Protocol V2 直接返回 SDK 搜索结果中的兼容 features', async () => {
+    const sdk = createSdkMock();
+    const features = {
+      protocol: 'V2',
+      deviceType: 'pro2',
+      deviceId: 'device-id',
+    };
+    sdk.searchDevices.mockResolvedValue({
+      success: true,
+      payload: [
+        {
+          connectId: 'pro2-connect-id',
+          state: { protocol: 'V2' },
+          features,
+        },
+      ],
+    });
+
+    await expect(getCompatibleFeatures(sdk as never, 'pro2-connect-id')).resolves.toEqual({
+      success: true,
+      payload: features,
+    });
+    expect(sdk.getFeatures).not.toHaveBeenCalled();
+  });
+
+  test('Protocol V1 继续调用公共 getFeatures 保持旧行为', async () => {
+    const sdk = createSdkMock();
+    const response = {
+      success: true,
+      payload: { protocol: 'V1', label: 'Classic' },
+    };
+    sdk.searchDevices.mockResolvedValue({
+      success: true,
+      payload: [
+        {
+          connectId: 'classic-connect-id',
+          state: { protocol: 'V1' },
+        },
+      ],
+    });
+    sdk.getFeatures.mockResolvedValue(response);
+
+    await expect(getCompatibleFeatures(sdk as never, 'classic-connect-id')).resolves.toBe(response);
+    expect(sdk.getFeatures).toHaveBeenCalledWith('classic-connect-id');
+  });
+
+  test('未显式指定设备时选择搜索结果中的第一台设备', async () => {
+    const sdk = createSdkMock();
+    const response = { success: true, payload: { protocol: 'V1' } };
+    sdk.searchDevices.mockResolvedValue({
+      success: true,
+      payload: [{ connectId: 'first-device', state: { protocol: 'V1' } }],
+    });
+    sdk.getFeatures.mockResolvedValue(response);
+
+    await expect(getCompatibleFeatures(sdk as never)).resolves.toBe(response);
+    expect(sdk.getFeatures).toHaveBeenCalledWith('first-device');
+  });
+
+  test('显式 connectId 不在搜索结果时返回结构化错误', async () => {
+    const sdk = createSdkMock();
+    sdk.searchDevices.mockResolvedValue({
+      success: true,
+      payload: [{ connectId: 'another-device', state: { protocol: 'V1' } }],
+    });
+
+    await expect(getCompatibleFeatures(sdk as never, 'missing-device')).resolves.toEqual({
+      success: false,
+      payload: {
+        code: 'DEVICE_NOT_FOUND',
+        error: 'Device not found: missing-device',
+      },
+    });
+    expect(sdk.getFeatures).not.toHaveBeenCalled();
+  });
+
+  test('get-state 将 firmware scope 传给 SDK', async () => {
+    const sdk = createSdkMock();
+    const response = { success: true, payload: { protocol: 'V2' } };
+    sdk.searchDevices.mockResolvedValue({
+      success: true,
+      payload: [{ connectId: 'pro2-connect-id', state: { protocol: 'V2' } }],
+    });
+    sdk.getDeviceState.mockResolvedValue(response);
+
+    await expect(
+      getCanonicalDeviceState(sdk as never, 'pro2-connect-id', 'firmware')
+    ).resolves.toBe(response);
+    expect(sdk.getDeviceState).toHaveBeenCalledWith('pro2-connect-id', {
+      scope: 'firmware',
+    });
+    expect(sdk.searchDevices).toHaveBeenCalledTimes(1);
+  });
+
+  test('get-state 未指定 connectId 时搜索并选择第一台设备', async () => {
+    const sdk = createSdkMock();
+    const state = { protocol: 'V2', revision: 2 };
+    sdk.searchDevices.mockResolvedValue({
+      success: true,
+      payload: [{ connectId: 'pro2-connect-id', state }],
+    });
+
+    await expect(getCanonicalDeviceState(sdk as never, undefined, 'runtime')).resolves.toEqual({
+      success: true,
+      payload: state,
+    });
+    expect(sdk.getDeviceState).not.toHaveBeenCalled();
+  });
+});

package/src/__tests__/firmware-update-legacy-command.test.ts

@@ -0,0 +1,20 @@
+import { getLegacyFirmwareConnectTimeout, program } from '../cli';
+
+describe('firmware-update-legacy CLI command', () => {
+  test('提供 Classic/Pure 的本地固件升级命令', () => {
+    const command = program.commands.find(item => item.name() === 'firmware-update-legacy');
+
+    expect(command).toBeDefined();
+    expect(command?.description()).toBe(
+      'Update Classic/Pure firmware through the legacy protocol'
+    );
+    expect(command?.options.find(option => option.long === '--binary')?.mandatory).toBe(true);
+    expect(command?.options.some(option => option.long === '--device-name')).toBe(true);
+    expect(command?.options.some(option => option.long === '--update-type')).toBe(true);
+  });
+
+  test('USB Classic 固件升级使用足够的设备探测超时', () => {
+    expect(getLegacyFirmwareConnectTimeout('usb')).toBe(90_000);
+    expect(getLegacyFirmwareConnectTimeout('ble')).toBeUndefined();
+  });
+});

package/src/__tests__/firmware-update-v4-command.test.ts

@@ -0,0 +1,19 @@
+import { program } from '../cli';
+
+describe('firmware-update-v4 CLI command', () => {
+  test('exposes firmware-update-v4 as the formal command', () => {
+    const command = program.commands.find(item => item.name() === 'firmware-update-v4');
+
+    expect(command).toBeDefined();
+    expect(command?.description()).toBe(
+      'Run Protocol V2 firmware update through sdk.firmwareUpdateV4'
+    );
+  });
+
+  test('does not expose the pre-release firmware-update-v4-debug command', () => {
+    expect(program.commands.some(item => item.name() === 'firmware-update-v4-debug')).toBe(false);
+    expect(program.commands.some(item => item.aliases().includes('firmware-update-v4-debug'))).toBe(
+      false
+    );
+  });
+});

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

@@ -0,0 +1,225 @@
+import { EventEmitter } from 'events';
+
+type MockCharacteristic = EventEmitter & {
+  uuid: string;
+  unsubscribe: jest.Mock;
+  subscribe: jest.Mock;
+  write: jest.Mock;
+  removeAllListeners: jest.Mock;
+};
+
+const createCharacteristic = (uuid: string): MockCharacteristic => {
+  const characteristic = new EventEmitter() as MockCharacteristic;
+  characteristic.uuid = uuid;
+  characteristic.unsubscribe = jest.fn(callback => callback());
+  characteristic.subscribe = jest.fn(callback => callback());
+  characteristic.write = jest.fn((_buffer, _withoutResponse, callback) => callback());
+  characteristic.removeAllListeners = jest.fn(
+    characteristic.removeAllListeners.bind(characteristic)
+  );
+  return characteristic;
+};
+
+const createPeripheral = (id: string) => {
+  const write = createCharacteristic('0002');
+  const notify = createCharacteristic('0003');
+  const service = {
+    uuid: '0001',
+    discoverCharacteristics: jest.fn((_uuids, callback) => callback(null, [write, notify])),
+  };
+  return {
+    peripheral: {
+      id,
+      state: 'connected',
+      advertisement: {
+        localName: `OneKey Pro 2 ${id}`,
+        serviceUuids: ['fffd'],
+      },
+      discoverServices: jest.fn((_uuids, callback) => callback(null, [service])),
+      connect: jest.fn(callback => callback()),
+      disconnect: jest.fn(callback => callback()),
+    },
+    write,
+    notify,
+  };
+};
+
+describe('Noble BLE plugin notification routing', () => {
+  afterEach(() => {
+    jest.resetModules();
+    jest.clearAllMocks();
+  });
+
+  test('routes notifications to the receiver waiting for the same device', async () => {
+    const deviceA = createPeripheral('device-a');
+    const deviceB = createPeripheral('device-b');
+    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', deviceA.peripheral);
+      noble.emit('discover', deviceB.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 plugin.connect('device-a');
+    await plugin.connect('device-b');
+
+    const receiveA = plugin.receive('device-a');
+    const receiveB = plugin.receive('device-b');
+    deviceB.notify.emit('data', Buffer.from('bb', 'hex'));
+    deviceA.notify.emit('data', Buffer.from('aa', 'hex'));
+
+    await expect(Promise.all([receiveA, receiveB])).resolves.toEqual(['aa', 'bb']);
+  });
+
+  test('finishes disconnect cleanup when Noble never calls unsubscribe back', async () => {
+    const device = createPeripheral('device-a');
+    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 plugin.connect('device-a');
+    device.notify.unsubscribe.mockImplementation(() => undefined);
+
+    const result = await Promise.race([
+      plugin.disconnect('device-a').then(() => 'completed'),
+      new Promise(resolve => {
+        setTimeout(() => resolve('blocked'), 300);
+      }),
+    ]);
+
+    expect(result).toBe('completed');
+  });
+
+  test('uses withoutResponse for normal and high-volume writes', async () => {
+    const device = createPeripheral('device-a');
+    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 plugin.connect('device-a');
+
+    await plugin.send('device-a', 'aa');
+    await plugin.send('device-a', 'bb');
+
+    expect(device.write.write.mock.calls.map(([, withoutResponse]) => withoutResponse)).toEqual([
+      true,
+      true,
+    ]);
+  });
+
+  test('uses acknowledged writes when requested by firmware upload', async () => {
+    const device = createPeripheral('device-a');
+    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 plugin.connect('device-a');
+
+    await (plugin.send as any)('device-a', 'aa', { withoutResponse: false });
+
+    expect(device.write.write).toHaveBeenCalledWith(expect.any(Buffer), false, expect.any(Function));
+  });
+
+  test('does not add a fixed delay between 192-byte writes', async () => {
+    const device = createPeripheral('device-a');
+    const noble = new EventEmitter() as EventEmitter & {
+      state: string;
+      startScanning: jest.Mock;
+      stopScanning: jest.Mock;
+    };
+    const wait = jest.fn(() => Promise.resolve());
+    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);
+    jest.doMock('@onekeyfe/hd-shared', () => ({
+      ...jest.requireActual('@onekeyfe/hd-shared'),
+      wait,
+    }));
+
+    const { createNobleBlePlugin } = await import('../transports/nobleBlePlugin');
+    const plugin = createNobleBlePlugin();
+    await plugin.init();
+    await plugin.connect('device-a');
+
+    await plugin.send('device-a', 'aa'.repeat(193));
+
+    expect(device.write.write).toHaveBeenCalledTimes(2);
+    expect(wait).not.toHaveBeenCalled();
+  });
+
+  test('preserves a short final BLE packet without padding', async () => {
+    const device = createPeripheral('device-a');
+    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 plugin.connect('device-a');
+
+    await plugin.send('device-a', 'aabb');
+
+    const packet = device.write.write.mock.calls[0][0] as Buffer;
+    expect(packet).toEqual(Buffer.from('aabb', 'hex'));
+  });
+});

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

@@ -0,0 +1,46 @@
+import { buildWallpaperUploadMetrics, program } from '../cli';
+
+describe('upload-wallpaper CLI command', () => {
+  test('exposes a command backed by the SDK wallpaper API', () => {
+    const command = program.commands.find(item => item.name() === 'upload-wallpaper');
+
+    expect(command).toBeDefined();
+    expect(command?.description()).toBe('Upload and activate a Pro2 wallpaper');
+  });
+
+  test('reports effective transfer speed from encoded bytes and elapsed time', () => {
+    expect(
+      buildWallpaperUploadMetrics({
+        totalBytes: 2_473_984,
+        transferredBytes: 2_473_984,
+        startedAt: 1_000,
+        endedAt: 2_000,
+        lastProgress: 100,
+      })
+    ).toEqual({
+      totalBytes: 2_473_984,
+      transferredBytes: 2_473_984,
+      totalSeconds: 1,
+      transferKiBPerSecond: 2416,
+      lastProgress: 100,
+    });
+  });
+
+  test('uses confirmed bytes for an interrupted transfer rate', () => {
+    expect(
+      buildWallpaperUploadMetrics({
+        totalBytes: 1_855_500,
+        transferredBytes: 631_800,
+        startedAt: 1_000,
+        endedAt: 101_000,
+        lastProgress: 34,
+      })
+    ).toEqual({
+      totalBytes: 1_855_500,
+      transferredBytes: 631_800,
+      totalSeconds: 100,
+      transferKiBPerSecond: 6.17,
+      lastProgress: 34,
+    });
+  });
+});