refactor(step-generation): wasteChute command utils into compound com… (#17784)

…mands

This is the 2nd Pr in a series of PRs that refactors any utils that emit
several commands in step-generation into a compound command for py
interop.

Author: jerader

step-generation/src/__tests__/airGapInWasteChute.test.ts

@@ -0,0 +1,66 @@
+import { describe, it, expect } from 'vitest'
+import {
+  getInitialRobotStateStandard,
+  getSuccessResult,
+  makeContext,
+} from '../fixtures'
+import { airGapInWasteChute } from '../commandCreators/compound'
+import type { InvariantContext, PipetteEntities, RobotState } from '../types'
+
+const mockId = 'mockId'
+const mockPipEntities: PipetteEntities = {
+  [mockId]: {
+    name: 'p50_single_flex',
+    id: mockId,
+    spec: { channels: 1 },
+  },
+} as any
+
+const invariantContext: InvariantContext = {
+  ...makeContext(),
+  pipetteEntities: mockPipEntities,
+}
+const prevRobotState: RobotState = getInitialRobotStateStandard(
+  invariantContext
+)
+
+describe('airGapInWasteChute', () => {
+  it('returns correct commands for air gap in waste chute', () => {
+    const result = airGapInWasteChute(
+      {
+        pipetteId: mockId,
+        volume: 10,
+        flowRate: 10,
+      },
+      invariantContext,
+      prevRobotState
+    )
+    expect(getSuccessResult(result).commands).toEqual([
+      {
+        commandType: 'moveToAddressableArea',
+        key: expect.any(String),
+        params: {
+          pipetteId: mockId,
+          addressableAreaName: '1ChannelWasteChute',
+          offset: { x: 0, y: 0, z: 0 },
+        },
+      },
+      {
+        commandType: 'prepareToAspirate',
+        key: expect.any(String),
+        params: {
+          pipetteId: mockId,
+        },
+      },
+      {
+        commandType: 'airGapInPlace',
+        key: expect.any(String),
+        params: {
+          pipetteId: mockId,
+          flowRate: 10,
+          volume: 10,
+        },
+      },
+    ])
+  })
+})

step-generation/src/__tests__/blowOutinWasteChute.test.ts

@@ -0,0 +1,59 @@
+import { describe, it, expect, vi } from 'vitest'
+import {
+  getInitialRobotStateStandard,
+  getSuccessResult,
+  makeContext,
+} from '../fixtures'
+import { blowOutInWasteChute } from '../commandCreators/compound'
+import type { InvariantContext, PipetteEntities, RobotState } from '../types'
+
+vi.mock('../getNextRobotStateAndWarnings/dispenseUpdateLiquidState')
+
+const mockId = 'mockId'
+const mockPipEntities: PipetteEntities = {
+  [mockId]: {
+    name: 'p50_single_flex',
+    id: mockId,
+    spec: { channels: 1 },
+  },
+} as any
+
+const invariantContext: InvariantContext = {
+  ...makeContext(),
+  pipetteEntities: mockPipEntities,
+}
+const prevRobotState: RobotState = getInitialRobotStateStandard(
+  invariantContext
+)
+
+describe('blowOutInWasteChute', () => {
+  it('returns correct commands for blowing out in waste chute', () => {
+    const result = blowOutInWasteChute(
+      {
+        pipetteId: mockId,
+        flowRate: 10,
+      },
+      invariantContext,
+      prevRobotState
+    )
+    expect(getSuccessResult(result).commands).toEqual([
+      {
+        commandType: 'moveToAddressableArea',
+        key: expect.any(String),
+        params: {
+          pipetteId: mockId,
+          addressableAreaName: '1ChannelWasteChute',
+          offset: { x: 0, y: 0, z: 0 },
+        },
+      },
+      {
+        commandType: 'blowOutInPlace',
+        key: expect.any(String),
+        params: {
+          pipetteId: mockId,
+          flowRate: 10,
+        },
+      },
+    ])
+  })
+})

step-generation/src/__tests__/blowoutUtil.test.ts

@@ -1,15 +1,11 @@
 import { beforeEach, describe, it, expect, vi } from 'vitest'
-import { ONE_CHANNEL_WASTE_CHUTE_ADDRESSABLE_AREA } from '@opentrons/shared-data'
 import {
   blowoutUtil,
   SOURCE_WELL_BLOWOUT_DESTINATION,
   DEST_WELL_BLOWOUT_DESTINATION,
 } from '../utils'
-import {
-  blowOutInPlace,
-  moveToAddressableArea,
-  blowout,
-} from '../commandCreators/atomic'
+import { blowout } from '../commandCreators/atomic'
+import { blowOutInWasteChute } from '../commandCreators/compound'
 import { curryCommandCreator } from '../utils/curryCommandCreator'
 import {
   DEFAULT_PIPETTE,
@@ -23,6 +19,7 @@ import {
 } from '../fixtures'
 import type { RobotState, InvariantContext } from '../types'
 import type { BlowoutParams } from '@opentrons/shared-data'
+
 vi.mock('../utils/curryCommandCreator')
 
 let blowoutArgs: {
@@ -94,14 +91,9 @@ describe('blowoutUtil', () => {
       destWell: null,
       blowoutLocation: wasteChuteId,
     })
-    expect(curryCommandCreator).toHaveBeenCalledWith(moveToAddressableArea, {
-      addressableAreaName: ONE_CHANNEL_WASTE_CHUTE_ADDRESSABLE_AREA,
+    expect(curryCommandCreator).toHaveBeenCalledWith(blowOutInWasteChute, {
       pipetteId: blowoutArgs.pipette,
-      offset: { x: 0, y: 0, z: 0 },
-    })
-    expect(curryCommandCreator).toHaveBeenCalledWith(blowOutInPlace, {
       flowRate: 2.3,
-      pipetteId: blowoutArgs.pipette,
     })
   })
   it('blowoutUtil curries blowout with dest plate params', () => {

step-generation/src/__tests__/dispenseInWasteChute.test.ts

@@ -0,0 +1,61 @@
+import { describe, it, expect, vi } from 'vitest'
+import {
+  getInitialRobotStateStandard,
+  getSuccessResult,
+  makeContext,
+} from '../fixtures'
+import { dispenseInWasteChute } from '../commandCreators/compound'
+import type { InvariantContext, PipetteEntities, RobotState } from '../types'
+
+vi.mock('../getNextRobotStateAndWarnings/dispenseUpdateLiquidState')
+
+const mockId = 'mockId'
+const mockPipEntities: PipetteEntities = {
+  [mockId]: {
+    name: 'p50_single_flex',
+    id: mockId,
+    spec: { channels: 1 },
+  },
+} as any
+
+const invariantContext: InvariantContext = {
+  ...makeContext(),
+  pipetteEntities: mockPipEntities,
+}
+const prevRobotState: RobotState = getInitialRobotStateStandard(
+  invariantContext
+)
+
+describe('dispenseInWasteChute', () => {
+  it('returns correct commands for dispensing in waste chute', () => {
+    const result = dispenseInWasteChute(
+      {
+        pipetteId: mockId,
+        volume: 10,
+        flowRate: 10,
+      },
+      invariantContext,
+      prevRobotState
+    )
+    expect(getSuccessResult(result).commands).toEqual([
+      {
+        commandType: 'moveToAddressableArea',
+        key: expect.any(String),
+        params: {
+          pipetteId: mockId,
+          addressableAreaName: '1ChannelWasteChute',
+          offset: { x: 0, y: 0, z: 0 },
+        },
+      },
+      {
+        commandType: 'dispenseInPlace',
+        key: expect.any(String),
+        params: {
+          pipetteId: mockId,
+          flowRate: 10,
+          volume: 10,
+        },
+      },
+    ])
+  })
+})

step-generation/src/__tests__/wasteChuteCommandsUtil.test.ts

@@ -0,0 +1,53 @@
+import {
+  curryCommandCreator,
+  getWasteChuteAddressableAreaNamePip,
+  reduceCommandCreators,
+} from '../../utils'
+import { ZERO_OFFSET } from '../../constants'
+import {
+  airGapInPlace,
+  moveToAddressableArea,
+  prepareToAspirate,
+} from '../atomic'
+import type { CommandCreator, CurriedCommandCreator } from '../../types'
+
+interface AirGapInWasteChuteArgs {
+  pipetteId: string
+  volume: number
+  flowRate: number
+}
+
+export const airGapInWasteChute: CommandCreator<AirGapInWasteChuteArgs> = (
+  args,
+  invariantContext,
+  prevRobotState
+) => {
+  const { pipetteId, volume, flowRate } = args
+  const pipetteChannels =
+    invariantContext.pipetteEntities[pipetteId].spec.channels
+  const addressableAreaName = getWasteChuteAddressableAreaNamePip(
+    pipetteChannels
+  )
+
+  const commandCreators: CurriedCommandCreator[] = [
+    curryCommandCreator(moveToAddressableArea, {
+      pipetteId,
+      addressableAreaName,
+      offset: ZERO_OFFSET,
+    }),
+    curryCommandCreator(prepareToAspirate, {
+      pipetteId,
+    }),
+    curryCommandCreator(airGapInPlace, {
+      pipetteId,
+      flowRate,
+      volume,
+    }),
+  ]
+
+  return reduceCommandCreators(
+    commandCreators,
+    invariantContext,
+    prevRobotState
+  )
+}