@onekeyfe/hd-core 1.2.0-alpha.21 → 1.2.0-alpha.22

package/__tests__/firmware-update/firmware-update-plan.test.ts

@@ -0,0 +1,326 @@
+import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
+
+import { buildFirmwareUpdatePlan } from '../../src/api/firmware/FirmwareUpdatePlan';
+
+import type { Features } from '../../src/types';
+
+const createFeatures = ({
+  deviceType,
+  firmwareVersion = '1.0.0',
+  bootloaderVersion = '1.0.0',
+}: {
+  deviceType: EDeviceType;
+  firmwareVersion?: string;
+  bootloaderVersion?: string;
+}) =>
+  ({
+    deviceType,
+    serialNo: `${deviceType}-device-id`,
+    firmwareVersion,
+    bootloaderVersion,
+  } as Features);
+
+const noUpdate = {
+  status: 'valid',
+  release: undefined,
+};
+
+describe('buildFirmwareUpdatePlan', () => {
+  test('selects all legacy artifacts before execution and chooses the desktop full resource', () => {
+    const plan = buildFirmwareUpdatePlan({
+      features: createFeatures({
+        deviceType: EDeviceType.Classic1s,
+        firmwareVersion: '1.0.0',
+      }),
+      firmwareType: EFirmwareType.Universal,
+      platform: 'desktop',
+      firmware: {
+        status: 'outdated',
+        release: {
+          url: 'https://firmware.onekey.so/classic/firmware.bin',
+          expectedSize: 1024,
+          fingerprint: '1111111111111111111111111111111111111111111111111111111111111111',
+          version: [3, 0, 0],
+          resource: 'https://firmware.onekey.so/classic/resource.zip',
+          fullResource: 'https://firmware.onekey.so/classic/full-resource.zip',
+          fullResourceExpectedSize: 4096,
+          fullResourceFingerprint:
+            '2222222222222222222222222222222222222222222222222222222222222222',
+          fullResourceRange: ['2.0.0', '3.0.0'],
+        },
+      },
+      ble: {
+        status: 'outdated',
+        release: {
+          webUpdate: 'https://firmware.onekey.so/classic/ble.bin',
+          expectedSize: 512,
+          fingerprintWeb: '3333333333333333333333333333333333333333333333333333333333333333',
+        },
+      },
+      bootloader: {
+        status: 'outdated',
+        shouldUpdate: true,
+        release: {
+          bootloaderResource: 'https://firmware.onekey.so/classic/bootloader.bin',
+          bootloaderExpectedSize: 768,
+          bootloaderFingerprint: '4444444444444444444444444444444444444444444444444444444444444444',
+          bootloaderVersion: [2, 0, 0],
+        },
+      },
+    });
+
+    expect(plan.executor).toBe('v2');
+    expect(plan.artifacts).toEqual([
+      expect.objectContaining({
+        artifactId: 'bootloader',
+        role: 'bootloader',
+        expectedSize: 768,
+        targetVersion: '2.0.0',
+      }),
+      expect.objectContaining({
+        artifactId: 'firmware',
+        role: 'firmware',
+        expectedSize: 1024,
+        targetVersion: '3.0.0',
+      }),
+      expect.objectContaining({
+        artifactId: 'resource',
+        role: 'resource',
+        url: 'https://firmware.onekey.so/classic/full-resource.zip',
+        expectedSize: 4096,
+      }),
+      expect.objectContaining({
+        artifactId: 'ble',
+        role: 'ble',
+        expectedSize: 512,
+      }),
+    ]);
+    expect(plan.targetsToUpdate).toEqual(['bootloader', 'firmware', 'resource', 'ble']);
+  });
+
+  test('selects V3 for Pro with bootloader 2.8 or newer', () => {
+    const plan = buildFirmwareUpdatePlan({
+      features: createFeatures({
+        deviceType: EDeviceType.Pro,
+        bootloaderVersion: '2.8.0',
+      }),
+      firmwareType: EFirmwareType.BitcoinOnly,
+      platform: 'native',
+      firmware: {
+        status: 'outdated',
+        release: {
+          url: 'https://firmware.onekey.so/pro/firmware.bin',
+          version: [4, 0, 0],
+        },
+      },
+      ble: noUpdate,
+      bootloader: noUpdate,
+    });
+
+    expect(plan.executor).toBe('v3');
+    expect(plan.firmwareType).toBe(EFirmwareType.BitcoinOnly);
+    expect(plan.platform).toBe('native');
+  });
+
+  test('rejects a prepared native plan without a stable device identity', () => {
+    const features = createFeatures({
+      deviceType: EDeviceType.Classic1s,
+    });
+    delete (features as Partial<Features>).serialNo;
+
+    expect(() =>
+      buildFirmwareUpdatePlan({
+        features,
+        firmwareType: EFirmwareType.Universal,
+        platform: 'native',
+        firmware: {
+          status: 'outdated',
+          release: {
+            url: 'https://firmware.onekey.so/classic/firmware.bin',
+          },
+        },
+        ble: noUpdate,
+        bootloader: noUpdate,
+      })
+    ).toThrow('requires a stable device identity');
+  });
+
+  test('maps the Pro2 component order and resource bundles without downloading them', () => {
+    const plan = buildFirmwareUpdatePlan({
+      features: createFeatures({ deviceType: EDeviceType.Pro2 }),
+      firmwareType: EFirmwareType.Universal,
+      platform: 'desktop',
+      firmware: {
+        status: 'required',
+        release: {
+          installOrder: ['bootloader', 'applicationP1'],
+          components: {
+            applicationP1: {
+              target: 'APPLICATION_P1',
+              url: 'https://firmware.onekey.so/pro2/application-p1.bin',
+              expectedSize: 1024,
+              fingerprint: '1111111111111111111111111111111111111111111111111111111111111111',
+            },
+            bootloader: {
+              target: 'BOOTLOADER',
+              url: 'https://firmware.onekey.so/pro2/bootloader.bin',
+            },
+            se01: {
+              target: 'SE01',
+              url: 'https://firmware.onekey.so/pro2/se01.bin',
+            },
+          },
+          resourceBundles: [
+            {
+              name: 'images',
+              url: 'https://firmware.onekey.so/pro2/images.okpkg',
+            },
+          ],
+        },
+      },
+      ble: noUpdate,
+      bootloader: noUpdate,
+    });
+
+    expect(plan.executor).toBe('v4');
+    expect(plan.artifacts.map(artifact => artifact.artifactId)).toEqual([
+      'component:boot',
+      'component:app_v1',
+      'component:se01',
+      'resourceBundle:images',
+    ]);
+    expect(plan.targetsToUpdate).toEqual(['boot', 'app_v1', 'se01', 'resource']);
+    expect(plan.artifacts[1]).toEqual(
+      expect.objectContaining({
+        expectedSize: 1024,
+        expectedSha256: '1111111111111111111111111111111111111111111111111111111111111111',
+      })
+    );
+  });
+
+  test('rejects Pro2 ROMLOADER because it requires a separate loader flow', () => {
+    expect(() =>
+      buildFirmwareUpdatePlan({
+        features: createFeatures({ deviceType: EDeviceType.Pro2 }),
+        firmwareType: EFirmwareType.Universal,
+        platform: 'desktop',
+        firmware: {
+          status: 'required',
+          release: {
+            components: {
+              romloader: {
+                target: 'ROMLOADER',
+                url: 'https://firmware.onekey.so/pro2/romloader.bin',
+              },
+            },
+          },
+        },
+        ble: noUpdate,
+        bootloader: noUpdate,
+      })
+    ).toThrow('ROMLOADER requires its dedicated loader flow');
+  });
+
+  test.each([
+    {
+      label: 'component target',
+      release: {
+        components: {
+          application: {
+            target: 'APPLICATION_P1',
+            url: 'https://firmware.onekey.so/pro2/application.bin',
+          },
+          applicationDuplicate: {
+            target: 'APPLICATION_P1',
+            url: 'https://firmware.onekey.so/pro2/application-duplicate.bin',
+          },
+        },
+      },
+      expectedError: 'duplicates target app_v1',
+    },
+    {
+      label: 'resource bundle name',
+      release: {
+        components: {
+          application: {
+            target: 'APPLICATION_P1',
+            url: 'https://firmware.onekey.so/pro2/application.bin',
+          },
+        },
+        resourceBundles: [
+          {
+            name: 'images',
+            url: 'https://firmware.onekey.so/pro2/images.okpkg',
+          },
+          {
+            name: 'images',
+            url: 'https://firmware.onekey.so/pro2/images-duplicate.okpkg',
+          },
+        ],
+      },
+      expectedError: 'duplicates name images',
+    },
+  ])('rejects a duplicate Pro2 $label', ({ release, expectedError }) => {
+    expect(() =>
+      buildFirmwareUpdatePlan({
+        features: createFeatures({ deviceType: EDeviceType.Pro2 }),
+        firmwareType: EFirmwareType.Universal,
+        platform: 'desktop',
+        firmware: {
+          status: 'required',
+          release,
+        },
+        ble: noUpdate,
+        bootloader: noUpdate,
+      })
+    ).toThrow(expectedError);
+  });
+
+  test('produces a deterministic digest and binds it to the platform', () => {
+    const input = {
+      features: createFeatures({ deviceType: EDeviceType.Classic1s }),
+      firmwareType: EFirmwareType.Universal,
+      firmware: noUpdate,
+      ble: noUpdate,
+      bootloader: noUpdate,
+    };
+    const first = buildFirmwareUpdatePlan({ ...input, platform: 'native' });
+    const second = buildFirmwareUpdatePlan({ ...input, platform: 'native' });
+    const desktop = buildFirmwareUpdatePlan({ ...input, platform: 'desktop' });
+
+    expect(first.planDigest).toMatch(/^[a-f0-9]{64}$/);
+    expect(first.planDigest).toBe(second.planDigest);
+    expect(first.planDigest).not.toBe(desktop.planDigest);
+  });
+
+  test('binds trusted artifact integrity metadata into the plan digest', () => {
+    const createPlan = (fingerprint: string) =>
+      buildFirmwareUpdatePlan({
+        features: createFeatures({ deviceType: EDeviceType.Classic1s }),
+        firmwareType: EFirmwareType.Universal,
+        platform: 'native',
+        firmware: {
+          status: 'outdated',
+          release: {
+            url: 'https://firmware.onekey.so/classic/firmware.bin',
+            version: [3, 0, 0],
+            expectedSize: 1024,
+            fingerprint,
+          },
+        },
+        ble: noUpdate,
+        bootloader: noUpdate,
+      });
+
+    const first = createPlan('1111111111111111111111111111111111111111111111111111111111111111');
+    const second = createPlan('2222222222222222222222222222222222222222222222222222222222222222');
+
+    expect(first.artifacts[0]).toEqual(
+      expect.objectContaining({
+        expectedSize: 1024,
+        expectedSha256: '1111111111111111111111111111111111111111111111111111111111111111',
+      })
+    );
+    expect(first.planDigest).not.toBe(second.planDigest);
+  });
+});

package/__tests__/firmware-update/firmware-update-prepared-plan.test.ts

@@ -0,0 +1,200 @@
+import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
+
+import { buildFirmwareUpdatePlan } from '../../src/api/firmware/FirmwareUpdatePlan';
+import {
+  assertFirmwareUpdatePreparedPlanBinding,
+  prepareFirmwareUpdatePlan,
+  validateFirmwareUpdatePreparedPlan,
+} from '../../src/api/firmware/FirmwareUpdatePreparedPlan';
+
+import type { Features } from '../../src/types';
+
+const buildPlan = () =>
+  buildFirmwareUpdatePlan({
+    features: {
+      deviceType: EDeviceType.Classic1s,
+      serialNo: 'classic1s-device-id',
+      firmwareVersion: '1.0.0',
+      bootloaderVersion: '1.0.0',
+    } as Features,
+    firmwareType: EFirmwareType.Universal,
+    platform: 'native',
+    firmware: {
+      status: 'outdated',
+      release: {
+        url: 'https://firmware.onekey.so/classic/firmware.bin',
+        expectedSize: 4,
+        fingerprint: 'a'.repeat(64),
+        version: [3, 0, 0],
+        resource: 'https://firmware.onekey.so/classic/resource.zip',
+        resourceExpectedSize: 8,
+        resourceFingerprint: 'b'.repeat(64),
+      },
+    },
+    ble: {
+      status: 'valid',
+      release: undefined,
+    },
+    bootloader: {
+      status: 'valid',
+      release: undefined,
+    },
+  });
+
+const artifact = (sha256: string, size: number) => ({
+  artifactRef: `fw:${sha256}`,
+  size,
+  sha256,
+});
+
+describe('FirmwareUpdatePreparedPlan', () => {
+  test('binds all receipts into a URL-free, network-forbidden plan', () => {
+    const plan = buildPlan();
+    const prepared = prepareFirmwareUpdatePlan({
+      plan,
+      leaseRef: 'fwlease:00000000-0000-4000-8000-000000000001',
+      artifacts: [
+        {
+          artifactId: 'firmware',
+          artifact: artifact('a'.repeat(64), 4),
+        },
+        {
+          artifactId: 'resource',
+          artifact: artifact('b'.repeat(64), 8),
+          materializedEntries: [
+            {
+              entryName: 'resource/index.bin',
+              artifact: artifact('c'.repeat(64), 2),
+            },
+          ],
+        },
+      ],
+    });
+
+    expect(prepared.networkPolicy).toBe('forbid');
+    expect(prepared.planDigest).toBe(plan.planDigest);
+    expect(prepared.preparedPlanDigest).toMatch(/^[a-f0-9]{64}$/u);
+    expect(JSON.stringify(prepared)).not.toContain('https://');
+    expect(validateFirmwareUpdatePreparedPlan(prepared)).toEqual(prepared);
+    expect(
+      assertFirmwareUpdatePreparedPlanBinding({
+        preparedPlan: prepared,
+        executor: 'v2',
+        platform: 'native',
+        scopeTargets: ['firmware', 'resource'],
+        bindings: [
+          {
+            target: 'firmware',
+            artifact: artifact('a'.repeat(64), 4),
+          },
+          {
+            target: 'resource',
+            entryName: 'resource/index.bin',
+            artifact: artifact('c'.repeat(64), 2),
+          },
+        ],
+      })
+    ).toEqual(prepared);
+    expect(() =>
+      assertFirmwareUpdatePreparedPlanBinding({
+        preparedPlan: prepared,
+        executor: 'v2',
+        platform: 'native',
+        scopeTargets: ['firmware'],
+        bindings: [
+          {
+            target: 'firmware',
+            artifact: artifact('b'.repeat(64), 8),
+          },
+        ],
+      })
+    ).toThrow('artifact binding is invalid');
+  });
+
+  test('rejects receipt drift and a tampered update plan digest', () => {
+    const plan = buildPlan();
+    expect(() =>
+      prepareFirmwareUpdatePlan({
+        plan,
+        leaseRef: 'fwlease:00000000-0000-4000-8000-000000000001',
+        artifacts: [
+          {
+            artifactId: 'firmware',
+            artifact: artifact('d'.repeat(64), 4),
+          },
+          {
+            artifactId: 'resource',
+            artifact: artifact('b'.repeat(64), 8),
+            materializedEntries: [
+              {
+                entryName: 'resource/index.bin',
+                artifact: artifact('c'.repeat(64), 2),
+              },
+            ],
+          },
+        ],
+      })
+    ).toThrow('receipt does not match');
+
+    expect(() =>
+      prepareFirmwareUpdatePlan({
+        plan: { ...plan, planDigest: 'f'.repeat(64) },
+        leaseRef: 'fwlease:00000000-0000-4000-8000-000000000001',
+        artifacts: [],
+      })
+    ).toThrow('plan digest is invalid');
+  });
+
+  test('projects portable archive paths to unique device resource names', () => {
+    const plan = buildPlan();
+    const buildArtifacts = (entryNames: string[]) => [
+      {
+        artifactId: 'firmware',
+        artifact: artifact('a'.repeat(64), 4),
+      },
+      {
+        artifactId: 'resource',
+        artifact: artifact('b'.repeat(64), 8),
+        materializedEntries: entryNames.map((entryName, index) => ({
+          entryName,
+          artifact: artifact(String(index + 1).repeat(64), 2),
+        })),
+      },
+    ];
+
+    expect(() =>
+      prepareFirmwareUpdatePlan({
+        plan,
+        leaseRef: 'fwlease:00000000-0000-4000-8000-000000000001',
+        artifacts: buildArtifacts(['icons/index.bin', 'fonts/index.bin']),
+      })
+    ).toThrow('duplicate entry names');
+    expect(() =>
+      prepareFirmwareUpdatePlan({
+        plan,
+        leaseRef: 'fwlease:00000000-0000-4000-8000-000000000001',
+        artifacts: buildArtifacts(['../index.bin']),
+      })
+    ).toThrow('entry name is invalid');
+  });
+
+  test('rejects unknown fields even when a caller presents a plan-shaped object', () => {
+    const plan = buildPlan();
+    expect(() =>
+      prepareFirmwareUpdatePlan({
+        plan: {
+          ...plan,
+          artifacts: [
+            {
+              ...plan.artifacts[0],
+              unexpectedUrl: 'https://attacker.invalid/payload',
+            },
+            plan.artifacts[1],
+          ],
+        } as typeof plan,
+        leaseRef: 'fwlease:00000000-0000-4000-8000-000000000001',
+        artifacts: [],
+      })
+    ).toThrow('invalid field set');
+  });
+});

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

@@ -2,7 +2,7 @@ import { EDeviceType, EFirmwareType, HardwareErrorCode } from '@onekeyfe/hd-shar
 
 import FirmwareUpdateV2 from '../../src/api/FirmwareUpdateV2';
 import { getBinary } from '../../src/api/firmware/getBinary';
-import { uploadFirmware } from '../../src/api/firmware/uploadFirmware';
+import { uploadFirmwareFromSource } from '../../src/api/firmware/uploadFirmware';
 import * as utils from '../../src/utils';
 
 jest.mock('../../src/data/config', () => ({
@@ -18,7 +18,8 @@ jest.mock('../../src/api/firmware/getBinary', () => ({
 
 jest.mock('../../src/api/firmware/uploadFirmware', () => ({
   updateResources: jest.fn(),
-  uploadFirmware: jest.fn(),
+  updateResourcesFromSources: jest.fn(),
+  uploadFirmwareFromSource: jest.fn(),
 }));
 
 jest.mock('../../src/device/DevicePool', () => ({
@@ -29,7 +30,9 @@ jest.mock('../../src/device/DevicePool', () => ({
 }));
 
 const mockGetBinary = getBinary as jest.MockedFunction<typeof getBinary>;
-const mockUploadFirmware = uploadFirmware as jest.MockedFunction<typeof uploadFirmware>;
+const mockUploadFirmwareFromSource = uploadFirmwareFromSource as jest.MockedFunction<
+  typeof uploadFirmwareFromSource
+>;
 
 type DeviceType = 'CLASSIC1S' | 'PURE';
 
@@ -175,7 +178,7 @@ describe('FirmwareUpdateV2 download-before-reboot safety', () => {
     expect(mockGetBinary).toHaveBeenCalledTimes(1);
     expectNoFirmwareMutationCalls(typedCall);
     expect(acquire).not.toHaveBeenCalled();
-    expect(mockUploadFirmware).not.toHaveBeenCalled();
+    expect(mockUploadFirmwareFromSource).not.toHaveBeenCalled();
   });
 
   it.each([
@@ -216,9 +219,11 @@ describe('FirmwareUpdateV2 download-before-reboot safety', () => {
           binary: firmwareBinary,
         } as Awaited<ReturnType<typeof getBinary>>);
       });
-      mockUploadFirmware.mockImplementation(() => {
+      mockUploadFirmwareFromSource.mockImplementation(() => {
         callOrder.push('upload');
-        return Promise.resolve(expectedResponse as Awaited<ReturnType<typeof uploadFirmware>>);
+        return Promise.resolve(
+          expectedResponse as Awaited<ReturnType<typeof uploadFirmwareFromSource>>
+        );
       });
       const { method, typedCall } = createMethod({
         updateType,
@@ -248,15 +253,15 @@ describe('FirmwareUpdateV2 download-before-reboot safety', () => {
           },
         })
       );
-      expect(mockUploadFirmware).toHaveBeenCalledWith(
+      expect(mockUploadFirmwareFromSource).toHaveBeenCalledWith(
         updateType,
         expect.any(Function),
         expect.any(Function),
         method.device,
-        {
-          payload: firmwareBinary,
-          rebootOnSuccess: true,
-        },
+        expect.objectContaining({
+          size: firmwareBinary.byteLength,
+        }),
+        true,
         isUpdateBootloader
       );
     }
@@ -271,11 +276,11 @@ describe('FirmwareUpdateV2 download-before-reboot safety', () => {
         binary: firmwareBinary,
       } as Awaited<ReturnType<typeof getBinary>>);
     });
-    mockUploadFirmware.mockImplementation(() => {
+    mockUploadFirmwareFromSource.mockImplementation(() => {
       callOrder.push('upload');
       return Promise.resolve({
         success: true,
-      } as Awaited<ReturnType<typeof uploadFirmware>>);
+      } as Awaited<ReturnType<typeof uploadFirmwareFromSource>>);
     });
     const { method, typedCall, acquire } = createMethod({
       bootloaderMode: true,
@@ -300,9 +305,9 @@ describe('FirmwareUpdateV2 download-before-reboot safety', () => {
           resolveDownload = resolve;
         })
     );
-    mockUploadFirmware.mockResolvedValue({
+    mockUploadFirmwareFromSource.mockResolvedValue({
       success: true,
-    } as Awaited<ReturnType<typeof uploadFirmware>>);
+    } as Awaited<ReturnType<typeof uploadFirmwareFromSource>>);
     const { method, typedCall } = createMethod();
 
     const runPromise = method.run();
@@ -333,7 +338,7 @@ describe('FirmwareUpdateV2 download-before-reboot safety', () => {
 
     expectNoFirmwareMutationCalls(typedCall);
     expect(acquire).not.toHaveBeenCalled();
-    expect(mockUploadFirmware).not.toHaveBeenCalled();
+    expect(mockUploadFirmwareFromSource).not.toHaveBeenCalled();
   });
 
   it.each([
@@ -342,23 +347,23 @@ describe('FirmwareUpdateV2 download-before-reboot safety', () => {
   ])(
     'keeps the non-empty %s binary overload and never downloads it again',
     async (_kind, binary) => {
-      mockUploadFirmware.mockResolvedValue({
+      mockUploadFirmwareFromSource.mockResolvedValue({
         success: true,
-      } as Awaited<ReturnType<typeof uploadFirmware>>);
+      } as Awaited<ReturnType<typeof uploadFirmwareFromSource>>);
       const { method } = createMethod({ binary });
 
       await method.run();
 
       expect(mockGetBinary).not.toHaveBeenCalled();
-      expect(mockUploadFirmware).toHaveBeenCalledWith(
+      expect(mockUploadFirmwareFromSource).toHaveBeenCalledWith(
         'firmware',
         expect.any(Function),
         expect.any(Function),
         method.device,
-        {
-          payload: binary,
-          rebootOnSuccess: true,
-        },
+        expect.objectContaining({
+          size: binary.byteLength,
+        }),
+        true,
         undefined
       );
     }
@@ -369,17 +374,21 @@ 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) => {
-    mockUploadFirmware.mockResolvedValue({
-      success: true,
-    } as Awaited<ReturnType<typeof uploadFirmware>>);
+    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>>;
+      }
+    );
     const { method } = createMethod({ binary });
 
     await method.run();
 
     expect(mockGetBinary).not.toHaveBeenCalled();
-    const normalizedBinary = mockUploadFirmware.mock.calls[0][4].payload;
-    expect(normalizedBinary).toBeInstanceOf(ArrayBuffer);
-    expect(Array.from(new Uint8Array(normalizedBinary))).toEqual(expectedBytes);
+    expect(uploadedBytes).toEqual(expectedBytes);
   });
 
   it.each([
@@ -397,6 +406,6 @@ describe('FirmwareUpdateV2 download-before-reboot safety', () => {
     expect(mockGetBinary).not.toHaveBeenCalled();
     expectNoFirmwareMutationCalls(typedCall);
     expect(acquire).not.toHaveBeenCalled();
-    expect(mockUploadFirmware).not.toHaveBeenCalled();
+    expect(mockUploadFirmwareFromSource).not.toHaveBeenCalled();
   });
 });