@onekeyfe/hd-core 1.2.0-alpha.73 → 1.2.0-alpha.75

package/__tests__/connectSettings.test.ts

@@ -1,59 +1,19 @@
-import DataManager from '../src/data-manager/DataManager';
 import { parseConnectSettings } from '../src/data-manager/connectSettings';
 
-import type { RemoteConfigResponse } from '../src/types';
-
-jest.mock('axios', () => ({
-  get: jest.fn(),
-}));
-
 jest.mock('../src/data/config', () => ({
   getSDKVersion: jest.fn(() => '1.0.0'),
   DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
 }));
 
-const mockAxiosGet: jest.Mock = jest.requireMock('axios').get;
-
 describe('parseConnectSettings', () => {
-  const preloadedConfig = {
-    bridge: {},
-    classic: { firmware: [], ble: [] },
-    classic1s: { firmware: [], ble: [] },
-    classicpure: { firmware: [], ble: [] },
-    mini: { firmware: [], ble: [] },
-    touch: { firmware: [], ble: [] },
-    pro: { firmware: [], ble: [] },
-    pro2: { firmware: [], ble: [] },
-  } as unknown as RemoteConfigResponse;
-
-  it('keeps a serializable preloaded config in parsed settings', () => {
-    const settings = parseConnectSettings({
-      firmwareManifestMode: 'sdk-managed',
-      preloadedConfig,
-    });
-
-    expect(settings.firmwareManifestMode).toBe('sdk-managed');
-    expect(settings.preloadedConfig).toBe(preloadedConfig);
-  });
-
-  it('uses the preloaded config before the SDK network client', async () => {
-    const settings = parseConnectSettings({
-      firmwareManifestMode: 'sdk-managed',
-      preloadedConfig,
-    });
-
-    await DataManager.load(settings);
-
-    expect(mockAxiosGet).not.toHaveBeenCalled();
-    expect(DataManager.deviceMap.classic).toEqual({ firmware: [], ble: [] });
-  });
+  it('keeps custom configFetcher in parsed settings', () => {
+    const configFetcher = jest.fn();
 
-  it('keeps the SDK offline and available without an external manifest snapshot', async () => {
     const settings = parseConnectSettings({
-      firmwareManifestMode: 'external-only',
+      fetchConfig: true,
+      configFetcher,
     });
 
-    await expect(DataManager.load(settings)).resolves.toBe(false);
-    expect(mockAxiosGet).not.toHaveBeenCalled();
+    expect(settings.configFetcher).toBe(configFetcher);
   });
 });

package/__tests__/devicePoolBootloaderPath.test.ts

@@ -0,0 +1,64 @@
+import { DevicePool, canPathIdentifyDevice } from '../src/device/DevicePool';
+
+jest.mock('../src/data/config', () => ({
+  getSDKVersion: () => '1.0.0',
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
+}));
+
+// A bootloader device reports this placeholder as its USB serial number, and the
+// descriptor path is that serial number.
+const BOOTLOADER_PATH = '000000000000000000000000';
+const MINI_SERIAL = 'MI05W01202110270714200000644';
+
+const deviceStub = (path: string, deviceType: string) =>
+  ({
+    originalDescriptor: { path },
+    features: { serial_no: `${deviceType}-serial` },
+    deviceType,
+    updateDescriptor: jest.fn(),
+  } as any);
+
+describe('canPathIdentifyDevice', () => {
+  it('accepts a real serial number', () => {
+    expect(canPathIdentifyDevice(MINI_SERIAL)).toBe(true);
+  });
+
+  it('rejects the all-zero placeholder every bootloader device reports', () => {
+    expect(canPathIdentifyDevice(BOOTLOADER_PATH)).toBe(false);
+    expect(canPathIdentifyDevice('0')).toBe(false);
+  });
+
+  it('rejects an absent path', () => {
+    expect(canPathIdentifyDevice('')).toBe(false);
+    expect(canPathIdentifyDevice(undefined)).toBe(false);
+  });
+});
+
+describe('DevicePool.getDeviceByPath', () => {
+  afterEach(() => {
+    DevicePool.devicesCache = {};
+  });
+
+  it('still reuses a cached device addressed by a real serial', () => {
+    const mini = deviceStub(MINI_SERIAL, 'mini');
+    DevicePool.devicesCache = { 'uuid-mini': mini };
+    expect(DevicePool.getDeviceByPath(MINI_SERIAL)).toBe(mini);
+  });
+
+  // The placeholder path is what handed a Classic back as the Mini plugged in
+  // first: both descriptors carry it, so the cache hit won and the device was
+  // never read. Reporting a miss is what sends the caller to read it.
+  it('reports a miss on the path every bootloader device shares', () => {
+    const mini = deviceStub(BOOTLOADER_PATH, 'mini');
+    DevicePool.devicesCache = { 'uuid-mini': mini };
+    expect(DevicePool.getDeviceByPath(BOOTLOADER_PATH)).toBeUndefined();
+  });
+
+  it('reports a miss rather than an arbitrary entry when several share the path', () => {
+    DevicePool.devicesCache = {
+      'uuid-mini': deviceStub(BOOTLOADER_PATH, 'mini'),
+      'uuid-classic': deviceStub(BOOTLOADER_PATH, 'classic'),
+    };
+    expect(DevicePool.getDeviceByPath(BOOTLOADER_PATH)).toBeUndefined();
+  });
+});

package/__tests__/firmware-update/firmware-update-v2-download-before-boot.test.ts

@@ -1,8 +1,8 @@
-import { EDeviceType, EFirmwareType, ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { EDeviceType, EFirmwareType, HardwareErrorCode } from '@onekeyfe/hd-shared';
 
 import FirmwareUpdateV2 from '../../src/api/FirmwareUpdateV2';
 import { getBinary } from '../../src/api/firmware/getBinary';
-import { uploadFirmwareFromSource } from '../../src/api/firmware/uploadFirmware';
+import { uploadFirmware } from '../../src/api/firmware/uploadFirmware';
 import * as utils from '../../src/utils';
 
 jest.mock('../../src/data/config', () => ({
@@ -18,8 +18,7 @@ jest.mock('../../src/api/firmware/getBinary', () => ({
 
 jest.mock('../../src/api/firmware/uploadFirmware', () => ({
   updateResources: jest.fn(),
-  updateResourcesFromSources: jest.fn(),
-  uploadFirmwareFromSource: jest.fn(),
+  uploadFirmware: jest.fn(),
 }));
 
 jest.mock('../../src/device/DevicePool', () => ({
@@ -30,9 +29,7 @@ jest.mock('../../src/device/DevicePool', () => ({
 }));
 
 const mockGetBinary = getBinary as jest.MockedFunction<typeof getBinary>;
-const mockUploadFirmwareFromSource = uploadFirmwareFromSource as jest.MockedFunction<
-  typeof uploadFirmwareFromSource
->;
+const mockUploadFirmware = uploadFirmware as jest.MockedFunction<typeof uploadFirmware>;
 
 type DeviceType = 'CLASSIC1S' | 'PURE';
 
@@ -178,26 +175,7 @@ describe('FirmwareUpdateV2 download-before-reboot safety', () => {
     expect(mockGetBinary).toHaveBeenCalledTimes(1);
     expectNoFirmwareMutationCalls(typedCall);
     expect(acquire).not.toHaveBeenCalled();
-    expect(mockUploadFirmwareFromSource).not.toHaveBeenCalled();
-  });
-
-  it('preserves structured preparation errors before any firmware mutation', async () => {
-    const preparationError = ERRORS.TypedError(
-      HardwareErrorCode.RuntimeError,
-      'Firmware must be prepared by the external firmware host',
-      {
-        firmwareUpdateCode: 'FirmwareArtifactsNotPrepared',
-        artifactName: 'firmware',
-      }
-    );
-    mockGetBinary.mockRejectedValue(preparationError);
-    const { method, typedCall, acquire } = createMethod();
-
-    await expect(method.run()).rejects.toBe(preparationError);
-
-    expectNoFirmwareMutationCalls(typedCall);
-    expect(acquire).not.toHaveBeenCalled();
-    expect(mockUploadFirmwareFromSource).not.toHaveBeenCalled();
+    expect(mockUploadFirmware).not.toHaveBeenCalled();
   });
 
   it.each([
@@ -238,11 +216,9 @@ describe('FirmwareUpdateV2 download-before-reboot safety', () => {
           binary: firmwareBinary,
         } as Awaited<ReturnType<typeof getBinary>>);
       });
-      mockUploadFirmwareFromSource.mockImplementation(() => {
+      mockUploadFirmware.mockImplementation(() => {
         callOrder.push('upload');
-        return Promise.resolve(
-          expectedResponse as Awaited<ReturnType<typeof uploadFirmwareFromSource>>
-        );
+        return Promise.resolve(expectedResponse as Awaited<ReturnType<typeof uploadFirmware>>);
       });
       const { method, typedCall } = createMethod({
         updateType,
@@ -272,15 +248,15 @@ describe('FirmwareUpdateV2 download-before-reboot safety', () => {
           },
         })
       );
-      expect(mockUploadFirmwareFromSource).toHaveBeenCalledWith(
+      expect(mockUploadFirmware).toHaveBeenCalledWith(
         updateType,
         expect.any(Function),
         expect.any(Function),
         method.device,
-        expect.objectContaining({
-          size: firmwareBinary.byteLength,
-        }),
-        true,
+        {
+          payload: firmwareBinary,
+          rebootOnSuccess: true,
+        },
         isUpdateBootloader
       );
     }
@@ -295,11 +271,11 @@ describe('FirmwareUpdateV2 download-before-reboot safety', () => {
         binary: firmwareBinary,
       } as Awaited<ReturnType<typeof getBinary>>);
     });
-    mockUploadFirmwareFromSource.mockImplementation(() => {
+    mockUploadFirmware.mockImplementation(() => {
       callOrder.push('upload');
       return Promise.resolve({
         success: true,
-      } as Awaited<ReturnType<typeof uploadFirmwareFromSource>>);
+      } as Awaited<ReturnType<typeof uploadFirmware>>);
     });
     const { method, typedCall, acquire } = createMethod({
       bootloaderMode: true,
@@ -324,9 +300,9 @@ describe('FirmwareUpdateV2 download-before-reboot safety', () => {
           resolveDownload = resolve;
         })
     );
-    mockUploadFirmwareFromSource.mockResolvedValue({
+    mockUploadFirmware.mockResolvedValue({
       success: true,
-    } as Awaited<ReturnType<typeof uploadFirmwareFromSource>>);
+    } as Awaited<ReturnType<typeof uploadFirmware>>);
     const { method, typedCall } = createMethod();
 
     const runPromise = method.run();
@@ -357,7 +333,7 @@ describe('FirmwareUpdateV2 download-before-reboot safety', () => {
 
     expectNoFirmwareMutationCalls(typedCall);
     expect(acquire).not.toHaveBeenCalled();
-    expect(mockUploadFirmwareFromSource).not.toHaveBeenCalled();
+    expect(mockUploadFirmware).not.toHaveBeenCalled();
   });
 
   it.each([
@@ -366,23 +342,23 @@ describe('FirmwareUpdateV2 download-before-reboot safety', () => {
   ])(
     'keeps the non-empty %s binary overload and never downloads it again',
     async (_kind, binary) => {
-      mockUploadFirmwareFromSource.mockResolvedValue({
+      mockUploadFirmware.mockResolvedValue({
         success: true,
-      } as Awaited<ReturnType<typeof uploadFirmwareFromSource>>);
+      } as Awaited<ReturnType<typeof uploadFirmware>>);
       const { method } = createMethod({ binary });
 
       await method.run();
 
       expect(mockGetBinary).not.toHaveBeenCalled();
-      expect(mockUploadFirmwareFromSource).toHaveBeenCalledWith(
+      expect(mockUploadFirmware).toHaveBeenCalledWith(
         'firmware',
         expect.any(Function),
         expect.any(Function),
         method.device,
-        expect.objectContaining({
-          size: binary.byteLength,
-        }),
-        true,
+        {
+          payload: binary,
+          rebootOnSuccess: true,
+        },
         undefined
       );
     }
@@ -393,21 +369,17 @@ describe('FirmwareUpdateV2 download-before-reboot safety', () => {
     ['DataView', new DataView(new Uint8Array([9, 3, 4, 9]).buffer, 1, 2), [3, 4]],
     ['custom Buffer', createCustomBuffer(4), [1, 2, 3, 4]],
   ])('normalizes a non-empty %s before rebooting', async (_kind, binary, expectedBytes) => {
-    let uploadedBytes: number[] = [];
-    mockUploadFirmwareFromSource.mockImplementation(
-      async (_updateType, _typedCall, _postMessage, _device, source) => {
-        uploadedBytes = Array.from(new Uint8Array(await source.readAt(0, source.size)));
-        return {
-          success: true,
-        } as Awaited<ReturnType<typeof uploadFirmwareFromSource>>;
-      }
-    );
+    mockUploadFirmware.mockResolvedValue({
+      success: true,
+    } as Awaited<ReturnType<typeof uploadFirmware>>);
     const { method } = createMethod({ binary });
 
     await method.run();
 
     expect(mockGetBinary).not.toHaveBeenCalled();
-    expect(uploadedBytes).toEqual(expectedBytes);
+    const normalizedBinary = mockUploadFirmware.mock.calls[0][4].payload;
+    expect(normalizedBinary).toBeInstanceOf(ArrayBuffer);
+    expect(Array.from(new Uint8Array(normalizedBinary))).toEqual(expectedBytes);
   });
 
   it.each([
@@ -425,6 +397,6 @@ describe('FirmwareUpdateV2 download-before-reboot safety', () => {
     expect(mockGetBinary).not.toHaveBeenCalled();
     expectNoFirmwareMutationCalls(typedCall);
     expect(acquire).not.toHaveBeenCalled();
-    expect(mockUploadFirmwareFromSource).not.toHaveBeenCalled();
+    expect(mockUploadFirmware).not.toHaveBeenCalled();
   });
 });