@onekeyfe/hd-core 1.2.2-alpha.0 → 1.2.2-alpha.100

package/__tests__/firmware-update/firmware-update-v4-install-poll.test.ts

@@ -14,39 +14,18 @@ describe('FirmwareUpdateV4 install polling', () => {
     jest.restoreAllMocks();
   });
 
-  test('writes the USB Request before polling current install status', async () => {
+  test('uses Stage, an empty write-only Request, then status polling', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
         method: 'firmwareUpdateV4',
-        connectId: 'pro2-usb',
+        connectId: 'pro2-ble',
       },
     });
     const targets = [{ target_id: 4, path: 'vol0:/application_p1.bin' }];
     const typedCall = jest
       .fn()
       .mockResolvedValueOnce({ type: 'Success', message: {} })
-      .mockResolvedValueOnce({
-        type: 'DeviceFirmwareUpdateStatus',
-        message: { records: [] },
-      })
-      .mockResolvedValueOnce({
-        type: 'DeviceFirmwareUpdateStatus',
-        message: {
-          records: [
-            {
-              target_id: 4,
-              status: 'FW_MGMT_UPDATER_TASK_STATUS_IN_PROGRESS',
-              progress_percent: 42,
-              phase_info: {
-                phase: 'FW_MGMT_UPDATER_PHASE_INSTALL',
-                progress_percent: 60,
-              },
-              path: 'vol0:/application_p1.bin',
-            },
-          ],
-        },
-      })
       .mockResolvedValueOnce({
         type: 'DeviceFirmwareUpdateStatus',
         message: {
@@ -59,17 +38,13 @@ describe('FirmwareUpdateV4 install polling', () => {
           ],
         },
       });
-    const call = jest.fn().mockResolvedValue({
-      type: 'WriteCompleted',
-      message: {},
-    });
-    const setCancelableAction = jest.fn();
+    const call = jest.fn().mockResolvedValue({ type: 'WriteCompleted', message: {} });
 
     method.device = {
-      getCommands: () => ({ typedCall, call, cancelDevice: jest.fn() }),
+      getCommands: () => ({ typedCall, call }),
       createProtocolV2UiPhaseMetadata: jest.fn().mockReturnValue(undefined),
-      toMessageObject: jest.fn().mockReturnValue({ connectId: 'pro2-usb' }),
-      setCancelableAction,
+      toMessageObject: jest.fn().mockReturnValue({ connectId: 'pro2-ble' }),
+      setCancelableAction: jest.fn(),
       clearCancelableAction: jest.fn(),
     } as unknown as Device;
     method.postMessage = jest.fn();
@@ -78,458 +53,24 @@ describe('FirmwareUpdateV4 install polling', () => {
 
     const firmwareUpdate = method as unknown as {
       protocolV2StartFirmwareUpdate: (params: { targets: typeof targets }) => Promise<void>;
-      waitForProtocolV2FirmwareUpdateComplete: (
-        value: typeof targets,
-        requireCurrentInstallStatus: boolean
-      ) => Promise<void>;
+      waitForProtocolV2FirmwareUpdateComplete: (value: typeof targets) => Promise<void>;
       reconnectProtocolV2Device: () => Promise<void>;
       verifyProtocolV2ReconnectIdentity: () => Promise<Record<string, never>>;
     };
     firmwareUpdate.reconnectProtocolV2Device = jest.fn().mockResolvedValue(undefined);
     firmwareUpdate.verifyProtocolV2ReconnectIdentity = jest.fn().mockResolvedValue({});
-    (method as any).isBleReconnect = jest.fn(() => false);
 
     await firmwareUpdate.protocolV2StartFirmwareUpdate({ targets });
+    await firmwareUpdate.waitForProtocolV2FirmwareUpdateComplete(targets);
 
     expect(typedCall.mock.calls[0]).toEqual(['DeviceFirmwareUpdateStage', 'Success', { targets }]);
     expect(call).toHaveBeenCalledWith(
       'DeviceFirmwareUpdateRequest',
       {},
-      expect.objectContaining({
-        returnAfterWrite: true,
-        expectedTypes: ['Success'],
-        onResponseAfterWrite: expect.any(Function),
-      })
+      { returnAfterWrite: true }
     );
-    expect(method.postProgressMessage).not.toHaveBeenCalled();
-
-    await firmwareUpdate.waitForProtocolV2FirmwareUpdateComplete(targets, true);
-
     expect(typedCall.mock.calls[1]?.[0]).toBe('DeviceFirmwareUpdateStatusGet');
-    expect(typedCall.mock.calls[1]?.[2]).toEqual({
-      fields: {
-        status: true,
-        progress_percent: true,
-        phase_info: true,
-        payload_version: true,
-        path: true,
-      },
-    });
-    expect(method.postProgressMessage).toHaveBeenCalledWith(42, 'installingFirmware', {
-      installTargetId: 4,
-      installPhase: 'install',
-      installPhaseProgress: 60,
-    });
-    expect(method.postProgressMessage).toHaveBeenCalledWith(100, 'installingFirmware');
     expect(call.mock.invocationCallOrder[0]).toBeLessThan(typedCall.mock.invocationCallOrder[1]);
-    expect(setCancelableAction).toHaveBeenCalledTimes(2);
-  });
-
-  test('accepts path-less finished USB status after the Request terminal Success arrives', async () => {
-    const method = new FirmwareUpdateV4({
-      id: 1,
-      payload: {
-        method: 'firmwareUpdateV4',
-        connectId: 'pro2-usb',
-      },
-    });
-    const targets = [{ target_id: 4, path: 'vol0:/application_p1.bin' }];
-    const typedCall = jest
-      .fn()
-      .mockResolvedValueOnce({ type: 'Success', message: {} })
-      .mockResolvedValueOnce({
-        type: 'DeviceFirmwareUpdateStatus',
-        message: {
-          records: [
-            {
-              target_id: 4,
-              status: 'FW_MGMT_UPDATER_TASK_STATUS_FINISHED',
-            },
-          ],
-        },
-      });
-    const call = jest.fn().mockResolvedValue({
-      type: 'WriteCompleted',
-      message: {},
-    });
-
-    method.device = {
-      getCommands: () => ({ typedCall, call, cancelDevice: jest.fn() }),
-      createProtocolV2UiPhaseMetadata: jest.fn().mockReturnValue(undefined),
-      toMessageObject: jest.fn().mockReturnValue({ connectId: 'pro2-usb' }),
-      setCancelableAction: jest.fn(),
-      clearCancelableAction: jest.fn(),
-    } as unknown as Device;
-    method.postMessage = jest.fn();
-    method.postProgressMessage = jest.fn();
-
-    const firmwareUpdate = method as unknown as {
-      protocolV2StartFirmwareUpdate: (params: { targets: typeof targets }) => Promise<void>;
-      waitForProtocolV2FirmwareUpdateComplete: (
-        value: typeof targets,
-        requireCurrentInstallStatus: boolean
-      ) => Promise<void>;
-    };
-
-    await firmwareUpdate.protocolV2StartFirmwareUpdate({ targets });
-    const requestOptions = call.mock.calls[0]?.[2] as {
-      onResponseAfterWrite: (response: { type: 'Success'; message: Record<string, never> }) => void;
-    };
-    requestOptions.onResponseAfterWrite({ type: 'Success', message: {} });
-    await firmwareUpdate.waitForProtocolV2FirmwareUpdateComplete(targets, true);
-
-    expect(method.postProgressMessage).toHaveBeenCalledWith(100, 'installingFirmware');
-  });
-
-  test('reconnects USB when the link is released while writing the Request', async () => {
-    const method = new FirmwareUpdateV4({
-      id: 1,
-      payload: {
-        method: 'firmwareUpdateV4',
-        connectId: 'pro2-usb',
-      },
-    });
-    const targets = [{ target_id: 4, path: 'vol0:/application_p1.bin' }];
-    const typedCall = jest
-      .fn()
-      .mockResolvedValueOnce({ type: 'Success', message: {} })
-      .mockResolvedValueOnce({
-        type: 'DeviceFirmwareUpdateStatus',
-        message: {
-          records: [
-            {
-              target_id: 4,
-              status: 'FW_MGMT_UPDATER_TASK_STATUS_IN_PROGRESS',
-              path: 'vol0:/application_p1.bin',
-            },
-          ],
-        },
-      })
-      .mockResolvedValueOnce({
-        type: 'DeviceFirmwareUpdateStatus',
-        message: {
-          records: [
-            {
-              target_id: 4,
-              status: 'FW_MGMT_UPDATER_TASK_STATUS_FINISHED',
-              path: 'vol0:/application_p1.bin',
-            },
-          ],
-        },
-      });
-    const call = jest.fn().mockRejectedValue(new Error('device was disconnected'));
-
-    method.device = {
-      getCommands: () => ({ typedCall, call, cancelDevice: jest.fn() }),
-      createProtocolV2UiPhaseMetadata: jest.fn().mockReturnValue(undefined),
-      toMessageObject: jest.fn().mockReturnValue({ connectId: 'pro2-usb' }),
-      setCancelableAction: jest.fn(),
-      clearCancelableAction: jest.fn(),
-    } as unknown as Device;
-    method.postMessage = jest.fn();
-    method.postProgressMessage = jest.fn();
-
-    const firmwareUpdate = method as unknown as {
-      protocolV2StartFirmwareUpdate: (params: { targets: typeof targets }) => Promise<void>;
-      waitForProtocolV2FirmwareUpdateComplete: (
-        value: typeof targets,
-        requireCurrentInstallStatus: boolean
-      ) => Promise<void>;
-      reconnectProtocolV2Device: (options: { skipProtocolProbe: boolean }) => Promise<void>;
-      verifyProtocolV2ReconnectIdentity: () => Promise<Record<string, never>>;
-    };
-    firmwareUpdate.reconnectProtocolV2Device = jest.fn().mockResolvedValue(undefined);
-    firmwareUpdate.verifyProtocolV2ReconnectIdentity = jest.fn().mockResolvedValue({});
-    (method as any).isBleReconnect = jest.fn(() => false);
-
-    await firmwareUpdate.protocolV2StartFirmwareUpdate({ targets });
-    await firmwareUpdate.waitForProtocolV2FirmwareUpdateComplete(targets, true);
-
-    expect(firmwareUpdate.reconnectProtocolV2Device).toHaveBeenCalledWith({
-      skipProtocolProbe: true,
-    });
-    expect(firmwareUpdate.verifyProtocolV2ReconnectIdentity).toHaveBeenCalledTimes(1);
-    expect(method.postProgressMessage).toHaveBeenCalledWith(1, 'installingFirmware');
-    expect(method.postProgressMessage).toHaveBeenCalledWith(100, 'installingFirmware');
-  });
-
-  test('writes the BLE Request and completes only from target status polling', async () => {
-    const method = new FirmwareUpdateV4({
-      id: 1,
-      payload: {
-        method: 'firmwareUpdateV4',
-        connectId: 'pro2-ble',
-      },
-    });
-    const targets = [{ target_id: 6, path: 'vol0:/coprocessor.bin' }];
-    const typedCall = jest
-      .fn()
-      .mockResolvedValueOnce({ type: 'Success', message: {} })
-      .mockResolvedValueOnce({
-        type: 'DeviceFirmwareUpdateStatus',
-        message: {
-          records: [
-            {
-              target_id: 6,
-              status: 'FW_MGMT_UPDATER_TASK_STATUS_IN_PROGRESS',
-              path: 'vol0:/coprocessor.bin',
-            },
-          ],
-        },
-      })
-      .mockResolvedValueOnce({
-        type: 'DeviceFirmwareUpdateStatus',
-        message: {
-          records: [
-            {
-              target_id: 6,
-              status: 'FW_MGMT_UPDATER_TASK_STATUS_FINISHED',
-              path: 'vol0:/coprocessor.bin',
-            },
-          ],
-        },
-      });
-    const call = jest.fn().mockResolvedValue({
-      type: 'WriteCompleted',
-      message: {},
-    });
-
-    method.device = {
-      getCommands: () => ({ typedCall, call }),
-      createProtocolV2UiPhaseMetadata: jest.fn().mockReturnValue(undefined),
-      toMessageObject: jest.fn().mockReturnValue({ connectId: 'pro2-ble' }),
-      setCancelableAction: jest.fn(),
-      clearCancelableAction: jest.fn(),
-    } as unknown as Device;
-    method.postMessage = jest.fn();
-    method.postProgressMessage = jest.fn();
-    (method as any).isBleReconnect = jest.fn(() => true);
-
-    const firmwareUpdate = method as unknown as {
-      protocolV2StartFirmwareUpdate: (params: { targets: typeof targets }) => Promise<void>;
-      waitForProtocolV2FirmwareUpdateComplete: (
-        value: typeof targets,
-        requireCurrentInstallStatus: boolean
-      ) => Promise<void>;
-    };
-
-    await firmwareUpdate.protocolV2StartFirmwareUpdate({ targets });
-
-    expect(typedCall).toHaveBeenCalledTimes(1);
-    expect(typedCall).toHaveBeenCalledWith('DeviceFirmwareUpdateStage', 'Success', { targets });
-    expect(call).toHaveBeenCalledWith(
-      'DeviceFirmwareUpdateRequest',
-      {},
-      expect.objectContaining({
-        returnAfterWrite: true,
-        expectedTypes: ['Success'],
-        onResponseAfterWrite: expect.any(Function),
-      })
-    );
-    expect(method.postProgressMessage).not.toHaveBeenCalled();
-
-    await firmwareUpdate.waitForProtocolV2FirmwareUpdateComplete(targets, true);
-
-    expect(typedCall.mock.calls[1]?.[0]).toBe('DeviceFirmwareUpdateStatusGet');
-    expect(typedCall.mock.calls[1]?.[1]).toBe('DeviceFirmwareUpdateStatus');
-    expect(method.postProgressMessage).toHaveBeenCalledWith(100, 'installingFirmware');
-  });
-
-  test('accepts stable finished BLE status after an actual install disconnect hides in-progress', async () => {
-    const method = new FirmwareUpdateV4({
-      id: 1,
-      payload: {
-        method: 'firmwareUpdateV4',
-        connectId: 'pro2-ble',
-      },
-    });
-    const targets = [{ target_id: 6, path: 'vol0:/coprocessor.bin' }];
-    const finishedStatus = {
-      type: 'DeviceFirmwareUpdateStatus',
-      message: {
-        records: [
-          {
-            target_id: 6,
-            status: 'FW_MGMT_UPDATER_TASK_STATUS_FINISHED',
-            payload_version: 65_556,
-            path: 'vol0:/coprocessor.bin',
-          },
-        ],
-      },
-    };
-    const typedCall = jest
-      .fn()
-      .mockResolvedValueOnce(finishedStatus)
-      .mockImplementationOnce(() => {
-        expect(method.postProgressMessage).not.toHaveBeenCalled();
-        throw new Error('device was disconnected');
-      })
-      .mockResolvedValueOnce(finishedStatus)
-      .mockImplementationOnce(() => {
-        expect(method.postProgressMessage).toHaveBeenCalledTimes(1);
-        expect(method.postProgressMessage).toHaveBeenCalledWith(1, 'installingFirmware');
-        return finishedStatus;
-      })
-      .mockResolvedValueOnce(finishedStatus)
-      .mockResolvedValueOnce(finishedStatus)
-      .mockRejectedValueOnce(ERRORS.TypedError(HardwareErrorCode.ActionCancelled));
-    const reconnectProtocolV2Device = jest.fn().mockResolvedValue(undefined);
-
-    (method as any).params = {
-      expectedTargetVersions: { coprocessor: '1.0.20' },
-    };
-
-    method.device = {
-      getCommands: () => ({ typedCall }),
-      setCancelableAction: jest.fn(),
-    } as unknown as Device;
-    method.postProgressMessage = jest.fn();
-
-    const firmwareUpdate = method as unknown as {
-      waitForProtocolV2FirmwareUpdateComplete: (
-        value: typeof targets,
-        requireCurrentInstallStatus: boolean
-      ) => Promise<void>;
-      reconnectProtocolV2Device: (options: { skipProtocolProbe: boolean }) => Promise<void>;
-    };
-    firmwareUpdate.reconnectProtocolV2Device = reconnectProtocolV2Device;
-    (method as any).isBleReconnect = jest.fn(() => true);
-
-    await firmwareUpdate.waitForProtocolV2FirmwareUpdateComplete(targets, true);
-
-    expect(reconnectProtocolV2Device).toHaveBeenCalledWith({ skipProtocolProbe: true });
-    expect(typedCall).toHaveBeenCalledTimes(6);
-    expect(method.postProgressMessage).toHaveBeenNthCalledWith(1, 1, 'installingFirmware');
-    expect(method.postProgressMessage).toHaveBeenNthCalledWith(2, 100, 'installingFirmware');
-    expect(method.postProgressMessage).toHaveBeenCalledTimes(2);
-  }, 10_000);
-
-  test('rejects stable stale finished BLE status after a status response timeout', async () => {
-    const method = new FirmwareUpdateV4({
-      id: 1,
-      payload: {
-        method: 'firmwareUpdateV4',
-        connectId: 'pro2-ble',
-      },
-    });
-    const targets = [{ target_id: 6, path: 'vol0:/coprocessor.bin' }];
-    const finishedStatus = {
-      type: 'DeviceFirmwareUpdateStatus',
-      message: {
-        records: [
-          {
-            target_id: 6,
-            status: 'FW_MGMT_UPDATER_TASK_STATUS_FINISHED',
-            payload_version: 65_556,
-            path: 'vol0:/coprocessor.bin',
-          },
-        ],
-      },
-    };
-    const typedCall = jest
-      .fn()
-      .mockResolvedValueOnce(finishedStatus)
-      .mockRejectedValueOnce(
-        ERRORS.TypedError(
-          HardwareErrorCode.BleTimeoutError,
-          'Lowlevel response timeout after 15000ms for DeviceFirmwareUpdateStatusGet'
-        )
-      )
-      .mockResolvedValueOnce(finishedStatus)
-      .mockResolvedValueOnce(finishedStatus)
-      .mockResolvedValueOnce(finishedStatus)
-      .mockResolvedValueOnce(finishedStatus)
-      .mockRejectedValueOnce(ERRORS.TypedError(HardwareErrorCode.ActionCancelled));
-    const reconnectProtocolV2Device = jest.fn().mockResolvedValue(undefined);
-
-    (method as any).params = {
-      expectedTargetVersions: { coprocessor: '1.0.20' },
-    };
-    method.device = {
-      getCommands: () => ({ typedCall }),
-      setCancelableAction: jest.fn(),
-    } as unknown as Device;
-    method.postProgressMessage = jest.fn();
-
-    const firmwareUpdate = method as unknown as {
-      waitForProtocolV2FirmwareUpdateComplete: (
-        value: typeof targets,
-        requireCurrentInstallStatus: boolean
-      ) => Promise<void>;
-      reconnectProtocolV2Device: (options: { skipProtocolProbe: boolean }) => Promise<void>;
-    };
-    firmwareUpdate.reconnectProtocolV2Device = reconnectProtocolV2Device;
-    (method as any).isBleReconnect = jest.fn(() => true);
-
-    await expect(
-      firmwareUpdate.waitForProtocolV2FirmwareUpdateComplete(targets, true)
-    ).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.ActionCancelled,
-    });
-
-    expect(reconnectProtocolV2Device).toHaveBeenCalledWith({ skipProtocolProbe: true });
-    expect(method.postProgressMessage).not.toHaveBeenCalled();
-  }, 10_000);
-
-  test('confirms App mode when BLE status becomes empty after current install progress', async () => {
-    const method = new FirmwareUpdateV4({
-      id: 1,
-      payload: {
-        method: 'firmwareUpdateV4',
-        connectId: 'pro2-ble',
-      },
-    });
-    const targets = [{ target_id: 4, path: 'vol0:/application_p1.bin' }];
-    const typedCall = jest
-      .fn()
-      .mockResolvedValueOnce({
-        type: 'DeviceFirmwareUpdateStatus',
-        message: {
-          records: [
-            {
-              target_id: 4,
-              status: 'FW_MGMT_UPDATER_TASK_STATUS_IN_PROGRESS',
-              path: 'vol0:/application_p1.bin',
-            },
-          ],
-        },
-      })
-      .mockResolvedValueOnce({
-        type: 'DeviceFirmwareUpdateStatus',
-        message: { records: [] },
-      });
-    const reconnectProtocolV2Device = jest.fn().mockResolvedValue(undefined);
-    const deviceInfo = {};
-    const verifyProtocolV2ReconnectIdentity = jest.fn().mockResolvedValue(deviceInfo);
-    const probeProtocolV2NormalMode = jest.fn().mockResolvedValue(true);
-
-    method.device = {
-      getCommands: () => ({ typedCall }),
-    } as unknown as Device;
-    method.postProgressMessage = jest.fn();
-
-    const firmwareUpdate = method as unknown as {
-      protocolV2InstallNeedsReconnect: boolean;
-      waitForProtocolV2FirmwareUpdateComplete: (
-        value: typeof targets,
-        requireCurrentInstallStatus: boolean
-      ) => Promise<void>;
-      reconnectProtocolV2Device: (options: { skipProtocolProbe: boolean }) => Promise<void>;
-      verifyProtocolV2ReconnectIdentity: () => Promise<typeof deviceInfo>;
-      probeProtocolV2NormalMode: (value: typeof deviceInfo) => Promise<boolean>;
-    };
-    firmwareUpdate.protocolV2InstallNeedsReconnect = true;
-    firmwareUpdate.reconnectProtocolV2Device = reconnectProtocolV2Device;
-    firmwareUpdate.verifyProtocolV2ReconnectIdentity = verifyProtocolV2ReconnectIdentity;
-    firmwareUpdate.probeProtocolV2NormalMode = probeProtocolV2NormalMode;
-    (method as any).isBleReconnect = jest.fn(() => true);
-
-    await firmwareUpdate.waitForProtocolV2FirmwareUpdateComplete(targets, true);
-
-    expect(reconnectProtocolV2Device).toHaveBeenCalledWith({ skipProtocolProbe: true });
-    expect(verifyProtocolV2ReconnectIdentity).toHaveBeenCalledTimes(1);
-    expect(probeProtocolV2NormalMode).toHaveBeenCalledWith(deviceInfo);
-    expect(method.postProgressMessage).toHaveBeenCalledWith(100, 'installingFirmware');
   });
 
   test('does not send Request when Stage is rejected', async () => {
@@ -542,9 +83,10 @@ describe('FirmwareUpdateV4 install polling', () => {
     });
     const targets = [{ target_id: 4, path: 'vol0:/application_p1.bin' }];
     const typedCall = jest.fn().mockRejectedValue(new Error('stage rejected'));
+    const call = jest.fn();
 
     method.device = {
-      getCommands: () => ({ typedCall }),
+      getCommands: () => ({ typedCall, call }),
     } as unknown as Device;
 
     await expect(
@@ -555,61 +97,7 @@ describe('FirmwareUpdateV4 install polling', () => {
       ).protocolV2StartFirmwareUpdate({ targets })
     ).rejects.toThrow('stage rejected');
 
-    expect(typedCall).toHaveBeenCalledTimes(1);
-  });
-
-  test('does not enter install state when the device cancels the Request', async () => {
-    const method = new FirmwareUpdateV4({
-      id: 1,
-      payload: {
-        method: 'firmwareUpdateV4',
-        connectId: 'pro2-usb',
-      },
-    });
-    const targets = [{ target_id: 4, path: 'vol0:/application_p1.bin' }];
-    const actionCancelledError = ERRORS.TypedError(HardwareErrorCode.ActionCancelled);
-    const typedCall = jest.fn().mockImplementation((type: string) => {
-      if (type === 'DeviceFirmwareUpdateStatusGet') {
-        return Promise.reject(actionCancelledError);
-      }
-      return Promise.resolve({ type: 'Success', message: {} });
-    });
-    const call = jest.fn().mockResolvedValue({
-      type: 'WriteCompleted',
-      message: {},
-    });
-
-    method.device = {
-      getCommands: () => ({ typedCall, call, cancelDevice: jest.fn() }),
-      createProtocolV2UiPhaseMetadata: jest.fn().mockReturnValue(undefined),
-      toMessageObject: jest.fn().mockReturnValue({ connectId: 'pro2-usb' }),
-      setCancelableAction: jest.fn(),
-      clearCancelableAction: jest.fn(),
-    } as unknown as Device;
-    method.postMessage = jest.fn();
-    method.postProgressMessage = jest.fn();
-
-    const firmwareUpdate = method as unknown as {
-      protocolV2StartFirmwareUpdate: (params: { targets: typeof targets }) => Promise<void>;
-      waitForProtocolV2FirmwareUpdateComplete: (
-        value: typeof targets,
-        requireCurrentInstallStatus: boolean
-      ) => Promise<void>;
-    };
-
-    await firmwareUpdate.protocolV2StartFirmwareUpdate({ targets });
-    await expect(
-      firmwareUpdate.waitForProtocolV2FirmwareUpdateComplete(targets, true)
-    ).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.ActionCancelled,
-    });
-
-    expect(call).toHaveBeenCalledWith(
-      'DeviceFirmwareUpdateRequest',
-      {},
-      expect.objectContaining({ returnAfterWrite: true })
-    );
-    expect(method.postProgressMessage).not.toHaveBeenCalled();
+    expect(call).not.toHaveBeenCalled();
   });
 
   test('does not hide an explicit workflow cancellation during status polling', async () => {