fix(app): move to initial calibration position after cancelling detach probe during desktop lpc (#18300)

Closes RQA-4177

On specifically the desktop app, it's possible to exit LPC on any view. During the detach view, we move the pipette to a maintenance position. If a user decides to cancel the detachment, we home the gantry and then return to whatever view the user previously visited.

This is all well and good except in one particular case: while actively calibrating an offset. We should move the pipette back to the initial position instead of the home position. This isn't currently a breaking bug, because we have the "start over" button on the desktop app as a workaround, but doing the correct movement implicitly is much nicer UX.

Although this seems like a decent amount of code, it's pretty straightforward: on specifically this calibrate offset view, we do the special homing behavior. We need a new command for this as well, because we don't want to reuse the existing command for moving to the initial position, since that one also does some labware loading.

Author: mjhuff

app/src/organisms/LabwarePositionCheck/hooks/useLPCCommands/__tests__/useHandleConfirmLwModulePlacement.test.ts

@@ -142,6 +142,34 @@ describe('useHandleConfirmLwModulePlacement', () => {
     expect(position).toEqual(mockPosition)
   })
 
+  it('should chain commands in the correct order when handleMoveToInitialOffsetPosition is called', async () => {
+    const { result } = renderHook(() =>
+      useHandleConfirmLwModulePlacement(mockProps)
+    )
+
+    const position = await result.current.handleMoveToInitialOffsetPosition(
+      mockOffsetLocationDetails,
+      mockPipetteId,
+      mockInitialVectorOffset
+    )
+
+    expect(moveToWellCommands).toHaveBeenCalledWith(
+      mockOffsetLocationDetails,
+      mockPipetteId,
+      mockInitialVectorOffset
+    )
+    expect(savePositionCommands).toHaveBeenCalledWith(mockPipetteId)
+
+    expect(mockChainLPCCommands).toHaveBeenCalled()
+    const commandsArg = mockChainLPCCommands.mock.calls[0][0]
+
+    expect(commandsArg.length).toBe(2)
+    expect(commandsArg[0].commandType).toBe('moveToWell')
+    expect(commandsArg[1].commandType).toBe('savePosition')
+
+    expect(position).toEqual(mockPosition)
+  })
+
   it('should handle labware placement on deck when no module or labware beneath', async () => {
     const mockOffsetLocationDetailsNoPriorItem = {
       ...mockOffsetLocationDetails,
@@ -173,7 +201,7 @@ describe('useHandleConfirmLwModulePlacement', () => {
     })
   })
 
-  it('should reject with error when final command response is incorrect', async () => {
+  it('should reject with error when final command response is incorrect for handleConfirmLwModulePlacement', async () => {
     mockChainLPCCommands.mockResolvedValueOnce([
       { data: { commandType: 'moveLabware' } },
       { data: { commandType: 'moduleInitDuringLPC' } },
@@ -204,6 +232,36 @@ describe('useHandleConfirmLwModulePlacement', () => {
     )
   })
 
+  it('should reject with error when final command response is incorrect for handleMoveToInitialOffsetPosition', async () => {
+    mockChainLPCCommands.mockResolvedValueOnce([
+      { data: { commandType: 'moveToWell' } },
+      {
+        data: {
+          commandType: 'unknownCommand',
+          result: null,
+        },
+      },
+    ])
+
+    const { result } = renderHook(() =>
+      useHandleConfirmLwModulePlacement(mockProps)
+    )
+
+    await expect(
+      result.current.handleMoveToInitialOffsetPosition(
+        mockOffsetLocationDetails,
+        mockPipetteId,
+        mockInitialVectorOffset
+      )
+    ).rejects.toThrow(
+      'CheckItem failed to save position for initial placement.'
+    )
+
+    expect(mockSetErrorMessage).toHaveBeenCalledWith(
+      'CheckItem failed to save position for initial placement.'
+    )
+  })
+
   it('should reject with error when result is null', async () => {
     mockChainLPCCommands.mockResolvedValueOnce([
       { data: { commandType: 'moveLabware' } },

app/src/organisms/LabwarePositionCheck/hooks/useLPCCommands/useHandleConfirmLwModulePlacement.ts

@@ -27,6 +27,11 @@ export interface UseHandleConfirmPlacementResult {
     pipetteId: string,
     initialVectorOffset?: VectorOffset | null
   ) => Promise<Coordinates>
+  handleMoveToInitialOffsetPosition: (
+    offsetLocationDetails: OffsetLocationDetails,
+    pipetteId: string,
+    initialVectorOffset: VectorOffset | null
+  ) => Promise<Coordinates>
 }
 
 export function useHandleConfirmLwModulePlacement({
@@ -70,7 +75,41 @@ export function useHandleConfirmLwModulePlacement({
     })
   }
 
-  return { handleConfirmLwModulePlacement }
+  const handleMoveToInitialOffsetPosition = (
+    offsetLocationDetails: OffsetLocationDetails,
+    pipetteId: string,
+    initialVectorOffset: VectorOffset | null
+  ): Promise<Coordinates> => {
+    const moveCommands: CreateCommand[] = [
+      ...moveToWellCommands(
+        offsetLocationDetails,
+        pipetteId,
+        initialVectorOffset
+      ),
+      ...savePositionCommands(pipetteId),
+    ]
+
+    return chainLPCCommands(moveCommands, false).then(responses => {
+      const finalResponse = responses[responses.length - 1]
+      if (
+        finalResponse.data.commandType === 'savePosition' &&
+        finalResponse.data.result != null
+      ) {
+        const { position } = finalResponse.data.result
+
+        return Promise.resolve(position)
+      } else {
+        setErrorMessage(
+          'CheckItem failed to save position for initial placement.'
+        )
+        return Promise.reject(
+          new Error('CheckItem failed to save position for initial placement.')
+        )
+      }
+    })
+  }
+
+  return { handleConfirmLwModulePlacement, handleMoveToInitialOffsetPosition }
 }
 
 function buildMoveLabwareCommand(

app/src/organisms/LabwarePositionCheck/steps/DetachProbe.tsx

@@ -5,27 +5,69 @@ import { useSelector } from 'react-redux'
 import { LegacyStyledText, StyledText } from '@opentrons/components'
 
 import { LPCContentContainer } from '/app/organisms/LabwarePositionCheck/LPCContentContainer'
-import { selectActivePipetteChannelCount } from '/app/redux/protocol-runs'
+import {
+  selectActivePipette,
+  selectActivePipetteChannelCount,
+  selectCurrentSubstep,
+  selectSelectedLwOverview,
+  selectSelectedLwWithOffsetDetailsMostRecentVectorOffset,
+} from '/app/redux/protocol-runs'
 import { DescriptionContent, TwoColumn } from '/app/molecules/InterventionModal'
 
+import type { LoadedPipette } from '@opentrons/shared-data'
+import type {
+  OffsetLocationDetails,
+  SelectedLwOverview,
+} from '/app/redux/protocol-runs'
 import type { LPCWizardContentProps } from '/app/organisms/LabwarePositionCheck/types'
 
 import detachProbe1 from '/app/assets/videos/pipette-wizard-flows/Pipette_Detach_Probe_1.webm'
 import detachProbe8 from '/app/assets/videos/pipette-wizard-flows/Pipette_Detach_Probe_8.webm'
 import detachProbe96 from '/app/assets/videos/pipette-wizard-flows/Pipette_Detach_Probe_96.webm'
 
 export function DetachProbe(props: LPCWizardContentProps): JSX.Element {
-  const { proceedStep, goBackLastStep, commandUtils } = props
+  const { proceedStep, goBackLastStep, commandUtils, runId } = props
   const { t } = useTranslation('labware_position_check')
+  const {
+    toggleRobotMoving,
+    handleMoveToInitialOffsetPosition,
+    home,
+  } = commandUtils
+
+  const currentSubstep = useSelector(selectCurrentSubstep(runId))
+  const pipette = useSelector(selectActivePipette(runId)) as LoadedPipette
+  const pipetteId = pipette.id
+  const selectedLwInfo = useSelector(
+    selectSelectedLwOverview(runId)
+  ) as SelectedLwOverview
+  const mostRecentVectorOffset = useSelector(
+    selectSelectedLwWithOffsetDetailsMostRecentVectorOffset(runId)
+  )
+  const offsetLocationDetails = selectedLwInfo.offsetLocationDetails as OffsetLocationDetails
 
   const handleGoBack = (): void => {
-    void commandUtils
-      .toggleRobotMoving(true)
-      .then(() => commandUtils.home())
+    void toggleRobotMoving(true)
+      .then(() => {
+        // On the desktop app, ensure the robot returns to the initial offset position instead of the home position
+        // when actively calibrating an offset.
+        if (currentSubstep === 'handle-lw/edit-offset/check-labware') {
+          return home()
+            .then(() =>
+              handleMoveToInitialOffsetPosition(
+                offsetLocationDetails,
+                pipetteId,
+                mostRecentVectorOffset
+              )
+            )
+            .then(() => Promise.resolve())
+        } else {
+          return home()
+        }
+      })
       .then(() => {
         goBackLastStep()
       })
-      .then(() => commandUtils.toggleRobotMoving(false))
+      .then(() => toggleRobotMoving(false))
   }
 
   const channelCount = useSelector(selectActivePipetteChannelCount(props.runId))

app/src/organisms/LabwarePositionCheck/steps/__tests__/DetachProbe.test.tsx

@@ -9,6 +9,10 @@ import { DetachProbe } from '/app/organisms/LabwarePositionCheck/steps'
 import {
   selectStepInfo,
   selectActivePipetteChannelCount,
+  selectActivePipette,
+  selectCurrentSubstep,
+  selectSelectedLwOverview,
+  selectSelectedLwWithOffsetDetailsMostRecentVectorOffset,
 } from '/app/redux/protocol-runs'
 
 import detachProbe1 from '/app/assets/videos/pipette-wizard-flows/Pipette_Detach_Probe_1.webm'
@@ -26,7 +30,8 @@ vi.mock('/app/redux/protocol-runs')
 
 const render = (
   props: ComponentProps<typeof DetachProbe>,
-  channelCount = 1
+  channelCount = 1,
+  currentSubstep = 'default-substep'
 ) => {
   const mockState = {
     [props.runId]: {
@@ -36,8 +41,21 @@ const render = (
         protocolName: 'MOCK_PROTOCOL',
       },
       activePipette: {
+        id: 'mock-pipette-id',
         channelCount: channelCount,
       },
+      currentSubstep: currentSubstep,
+      selectedLwOverview: {
+        offsetLocationDetails: {
+          labwareId: 'mock-labware-id',
+          well: 'A1',
+        },
+      },
+      selectedLwWithOffsetDetailsMostRecentVectorOffset: {
+        x: 1,
+        y: 2,
+        z: 3,
+      },
     },
   }
 
@@ -50,9 +68,17 @@ const render = (
 describe('DetachProbe', () => {
   let props: ComponentProps<typeof DetachProbe>
   let mockHandleProceed: Mock
+  let mockToggleRobotMoving: Mock
+  let mockHome: Mock
+  let mockHandleMoveToInitialOffsetPosition: Mock
+  let mockGoBackLastStep: Mock
 
   beforeEach(() => {
     mockHandleProceed = vi.fn()
+    mockToggleRobotMoving = vi.fn().mockResolvedValue(undefined)
+    mockHome = vi.fn().mockResolvedValue(undefined)
+    mockHandleMoveToInitialOffsetPosition = vi.fn().mockResolvedValue(undefined)
+    mockGoBackLastStep = vi.fn()
 
     vi.mocked(
       selectStepInfo
@@ -62,6 +88,26 @@ describe('DetachProbe', () => {
     ).mockImplementation((runId: string) => (state: any) =>
       state[runId]?.activePipette?.channelCount || 1
     )
+    vi.mocked(
+      selectActivePipette
+    ).mockImplementation((runId: string) => (state: any) =>
+      state[runId]?.activePipette
+    )
+    vi.mocked(
+      selectCurrentSubstep
+    ).mockImplementation((runId: string) => (state: any) =>
+      state[runId]?.currentSubstep
+    )
+    vi.mocked(
+      selectSelectedLwOverview
+    ).mockImplementation((runId: string) => (state: any) =>
+      state[runId]?.selectedLwOverview
+    )
+    vi.mocked(
+      selectSelectedLwWithOffsetDetailsMostRecentVectorOffset
+    ).mockImplementation((runId: string) => (state: any) =>
+      state[runId]?.selectedLwWithOffsetDetailsMostRecentVectorOffset
+    )
 
     props = {
       ...mockLPCContentProps,
@@ -71,7 +117,11 @@ describe('DetachProbe', () => {
           ...mockLPCContentProps.commandUtils.headerCommands,
           handleProceed: mockHandleProceed,
         },
+        toggleRobotMoving: mockToggleRobotMoving,
+        home: mockHome,
+        handleMoveToInitialOffsetPosition: mockHandleMoveToInitialOffsetPosition,
       },
+      goBackLastStep: mockGoBackLastStep,
     }
   })