@opentrons/components 0.1.6-alpha.9 → 0.1.7-alpha.1

package/src/organisms/CommandText/useCommandTextString/utils/__tests__/getFinalLabwareLocation.test.ts

@@ -0,0 +1,133 @@
+import { describe, expect, it } from 'vitest'
+
+import { fixtureTiprack10ul } from '@opentrons/shared-data'
+
+import { getFinalLabwareLocation } from '../getFinalLabwareLocation'
+
+import type { LabwareDefinition2 } from '@opentrons/shared-data'
+
+describe('getFinalLabwareLocation', () => {
+  it('calculates labware location after only load_labware', () => {
+    const labwareId = 'fakeLabwareId'
+    const location = { slotName: 'C3' }
+    expect(
+      getFinalLabwareLocation(labwareId, [
+        {
+          id: 'fakeId1',
+          commandType: 'loadLabware',
+          params: {
+            location,
+            loadName: 'fakeLoadname',
+            namespace: 'opentrons',
+            version: 1,
+          },
+          result: {
+            labwareId,
+            definition: fixtureTiprack10ul as LabwareDefinition2,
+            offset: { x: 1, y: 2, z: 3 },
+          },
+          status: 'succeeded',
+          createdAt: 'fake_timestamp',
+          startedAt: 'fake_timestamp',
+          completedAt: 'fake_timestamp',
+        },
+      ]).location
+    ).toBe(location)
+  })
+  it('calculates labware location after only load_labware and move_labware', () => {
+    const labwareId = 'fakeLabwareId'
+    const initialLocation = { slotName: 'C3' }
+    const finalLocation = { slotName: 'D1' }
+    expect(
+      getFinalLabwareLocation(labwareId, [
+        {
+          id: 'fakeId1',
+          commandType: 'loadLabware',
+          params: {
+            location: initialLocation,
+            loadName: 'fakeLoadname',
+            namespace: 'opentrons',
+            version: 1,
+          },
+          result: {
+            labwareId,
+            definition: fixtureTiprack10ul as LabwareDefinition2,
+            offset: { x: 1, y: 2, z: 3 },
+          },
+          status: 'succeeded',
+          createdAt: 'fake_timestamp',
+          startedAt: 'fake_timestamp',
+          completedAt: 'fake_timestamp',
+        },
+        {
+          id: 'fakeId2',
+          commandType: 'moveLabware',
+          params: {
+            labwareId,
+            newLocation: finalLocation,
+            strategy: 'usingGripper',
+          },
+          status: 'succeeded',
+          createdAt: 'fake_timestamp',
+          startedAt: 'fake_timestamp',
+          completedAt: 'fake_timestamp',
+        },
+      ]).location
+    ).toBe(finalLocation)
+  })
+  it('calculates labware location after multiple moves', () => {
+    const labwareId = 'fakeLabwareId'
+    const initialLocation = { slotName: 'C3' }
+    const secondLocation = { slotName: 'D1' }
+    const finalLocation = { slotName: 'A2' }
+    expect(
+      getFinalLabwareLocation(labwareId, [
+        {
+          id: 'fakeId1',
+          commandType: 'loadLabware',
+          params: {
+            location: initialLocation,
+            loadName: 'fakeLoadname',
+            namespace: 'opentrons',
+            version: 1,
+          },
+          result: {
+            labwareId,
+            definition: fixtureTiprack10ul as LabwareDefinition2,
+            offset: { x: 1, y: 2, z: 3 },
+          },
+          status: 'succeeded',
+          createdAt: 'fake_timestamp',
+          startedAt: 'fake_timestamp',
+          completedAt: 'fake_timestamp',
+        },
+        {
+          id: 'fakeId2',
+          commandType: 'moveLabware',
+          params: {
+            labwareId,
+            newLocation: secondLocation,
+            strategy: 'usingGripper',
+          },
+          status: 'succeeded',
+          createdAt: 'fake_timestamp',
+          startedAt: 'fake_timestamp',
+          completedAt: 'fake_timestamp',
+        },
+        {
+          id: 'fakeId3',
+          commandType: 'moveLabware',
+          params: {
+            labwareId,
+            newLocation: finalLocation,
+            strategy: 'usingGripper',
+          },
+          status: 'succeeded',
+          createdAt: 'fake_timestamp',
+          startedAt: 'fake_timestamp',
+          completedAt: 'fake_timestamp',
+        },
+      ]).location
+    ).toBe(finalLocation)
+  })
+})

package/src/organisms/CommandText/useCommandTextString/utils/__tests__/getLabwareDisplayLocation.test.tsx

@@ -0,0 +1,186 @@
+import { useTranslation } from 'react-i18next'
+import { screen } from '@testing-library/react'
+import { describe, expect, it, vi } from 'vitest'
+
+import {
+  FLEX_ROBOT_TYPE,
+  getLabwareDefURI,
+  getLabwareDisplayName,
+  getModuleDisplayName,
+  getModuleType,
+  getOccludedSlotCountForModule,
+} from '@opentrons/shared-data'
+
+import { i18n } from '../../../../../i18n'
+import { renderWithProviders } from '../../../../../testing/utils'
+import { getLabwareDisplayLocation } from '../getLabwareDisplayLocation'
+import { getModuleDisplayLocation } from '../getModuleDisplayLocation'
+import { getModuleModel } from '../getModuleModel'
+
+import type { ComponentProps } from 'react'
+import type { LabwareLocation } from '@opentrons/shared-data'
+
+vi.mock('../getModuleModel')
+vi.mock('../getModuleDisplayLocation')
+vi.mock('@opentrons/shared-data', async () => {
+  const actual = await vi.importActual('@opentrons/shared-data')
+  return {
+    ...actual,
+    getModuleDisplayName: vi.fn(),
+    getModuleType: vi.fn(),
+    getOccludedSlotCountForModule: vi.fn(),
+    getLabwareDefURI: vi.fn(),
+    getLabwareDisplayName: vi.fn(),
+  }
+})
+
+const TestWrapper = ({
+  location,
+  params,
+}: {
+  location: LabwareLocation | null
+  params: any
+}) => {
+  const { t } = useTranslation('protocol_command_text')
+  const displayLocation = getLabwareDisplayLocation({ ...params, location, t })
+  return <div>{displayLocation}</div>
+}
+
+const render = (props: ComponentProps<typeof TestWrapper>) => {
+  return renderWithProviders(<TestWrapper {...props} />, {
+    i18nInstance: i18n,
+  })[0]
+}
+
+describe('getLabwareDisplayLocation with translations', () => {
+  const defaultParams = {
+    loadedLabwares: [],
+    loadedModules: [],
+    robotType: FLEX_ROBOT_TYPE,
+    allRunDefs: [],
+  }
+
+  it('should return an empty string for null location', () => {
+    render({ location: null, params: defaultParams })
+    expect(screen.queryByText(/.+/)).toBeNull()
+  })
+
+  it('should return "off deck" for offDeck location', () => {
+    render({ location: 'offDeck', params: defaultParams })
+
+    screen.getByText('off deck')
+  })
+
+  it('should return a slot name for slot location', () => {
+    render({ location: { slotName: 'A1' }, params: defaultParams })
+
+    screen.getByText('Slot A1')
+  })
+
+  it('should return an addressable area name for an addressable area location', () => {
+    render({ location: { addressableAreaName: 'B2' }, params: defaultParams })
+
+    screen.getByText('Slot B2')
+  })
+
+  it('should return a module location for a module location', () => {
+    const mockModuleModel = 'temperatureModuleV2'
+    vi.mocked(getModuleModel).mockReturnValue(mockModuleModel)
+    vi.mocked(getModuleDisplayLocation).mockReturnValue('3')
+    vi.mocked(getModuleDisplayName).mockReturnValue('Temperature Module')
+    vi.mocked(getModuleType).mockReturnValue('temperatureModuleType')
+    vi.mocked(getOccludedSlotCountForModule).mockReturnValue(1)
+
+    render({ location: { moduleId: 'temp123' }, params: defaultParams })
+
+    screen.getByText('Temperature Module in Slot 3')
+  })
+
+  it('should return an adapter location for an adapter location', () => {
+    const mockLoadedLabwares = [
+      {
+        id: 'adapter123',
+        definitionUri: 'adapter-uri',
+        location: { slotName: 'D1' },
+      },
+    ]
+    const mockAllRunDefs = [
+      { uri: 'adapter-uri', metadata: { displayName: 'Mock Adapter' } },
+    ]
+    vi.mocked(getLabwareDefURI).mockReturnValue('adapter-uri')
+    vi.mocked(getLabwareDisplayName).mockReturnValue('Mock Adapter')
+
+    render({
+      location: { labwareId: 'adapter123' },
+      params: {
+        ...defaultParams,
+        loadedLabwares: mockLoadedLabwares,
+        allRunDefs: mockAllRunDefs,
+        detailLevel: 'full',
+      },
+    })
+
+    screen.getByText('Mock Adapter in Slot D1')
+  })
+
+  it('should return a slot-only location when detailLevel is "slot-only"', () => {
+    render({
+      location: { slotName: 'C1' },
+      params: { ...defaultParams, detailLevel: 'slot-only' },
+    })
+
+    screen.getByText('Slot C1')
+  })
+
+  it('should special case the slotName if it contains "waste chute"', () => {
+    render({
+      location: { slotName: 'gripperWasteChute' },
+      params: { ...defaultParams, detailLevel: 'slot-only' },
+    })
+
+    screen.getByText('Waste Chute')
+  })
+
+  it('should special case the slotName if it contains "trash bin"', () => {
+    render({
+      location: { slotName: 'trashBin' },
+      params: { ...defaultParams, detailLevel: 'slot-only' },
+    })
+
+    screen.getByText('Trash Bin')
+  })
+
+  it('should handle an adapter on module location when the detail level is full', () => {
+    const mockLoadedLabwares = [
+      {
+        id: 'adapter123',
+        definitionUri: 'adapter-uri',
+        location: { moduleId: 'temp123' },
+      },
+    ]
+    const mockLoadedModules = [{ id: 'temp123', model: 'temperatureModuleV2' }]
+    const mockAllRunDefs = [
+      { uri: 'adapter-uri', metadata: { displayName: 'Mock Adapter' } },
+    ]
+
+    vi.mocked(getLabwareDefURI).mockReturnValue('adapter-uri')
+    vi.mocked(getLabwareDisplayName).mockReturnValue('Mock Adapter')
+    vi.mocked(getModuleDisplayLocation).mockReturnValue('2')
+    vi.mocked(getModuleDisplayName).mockReturnValue('Temperature Module')
+    vi.mocked(getModuleType).mockReturnValue('temperatureModuleType')
+    vi.mocked(getOccludedSlotCountForModule).mockReturnValue(1)
+
+    render({
+      location: { labwareId: 'adapter123' },
+      params: {
+        ...defaultParams,
+        loadedLabwares: mockLoadedLabwares,
+        loadedModules: mockLoadedModules,
+        allRunDefs: mockAllRunDefs,
+        detailLevel: 'full',
+      },
+    })
+
+    screen.getByText('Mock Adapter on Temperature Module in Slot 2')
+  })
+})

package/src/organisms/CommandText/useCommandTextString/utils/commandText/__tests__/getFlexStackerCommandText.test.tsx

@@ -0,0 +1,179 @@
+import { useTranslation } from 'react-i18next'
+import { screen } from '@testing-library/react'
+import { beforeEach, describe, it, vi } from 'vitest'
+
+import { getLabwareDefURI } from '@opentrons/shared-data'
+
+import { i18n } from '../../../../../../i18n'
+import { renderWithProviders } from '../../../../../../testing/utils'
+import { getLabwareDisplayLocation } from '../../getLabwareDisplayLocation'
+import {
+  getFlexStackerCommandText,
+  KEYS_BY_COMMAND_TYPE,
+} from '../getFlexStackerCommandText'
+
+vi.mock('@opentrons/shared-data')
+vi.mock('../../getLabwareDisplayLocation')
+
+const baseCommandData = {
+  allRunDefs: [
+    { metadata: { displayName: 'tip rack' } },
+    { metadata: { displayName: 'plate' } },
+  ],
+  robotType: 'OT-2',
+  commandTextData: {
+    commands: [],
+    labware: [],
+    modules: [],
+    pipettes: [{ id: 'pipette-1', pipetteName: 'p300_single' }],
+  },
+} as any
+
+function TestWrapper({ command }: { command: any }): JSX.Element {
+  const { t } = useTranslation(['protocol_command_text', 'branded'])
+  const text = getFlexStackerCommandText({
+    command,
+    ...baseCommandData,
+    t,
+  })
+
+  return <div>{text}</div>
+}
+
+const render = (command: any) => {
+  return renderWithProviders(<TestWrapper command={command} />, {
+    i18nInstance: i18n,
+  })
+}
+
+describe('getPipettingCommandText', () => {
+  beforeEach(() => {
+    vi.mocked(getLabwareDefURI).mockReturnValue('tiprack-uri')
+    vi.mocked(getLabwareDisplayLocation).mockReturnValue('Slot 1')
+  })
+
+  it('should render retrieve command text correctly', () => {
+    const command = {
+      id: 'cmd-1',
+      commandType: 'flexStacker/retrieve',
+      params: {
+        moduleId: 'module-id',
+      },
+      result: {
+        primaryLabwareURI: 'tiprack-uri',
+      },
+    }
+
+    render(command)
+    screen.getByText('retrieve_labware_from_stacker_to')
+  })
+
+  it('should render store command text correctly', () => {
+    const command = {
+      id: 'cmd-1',
+      commandType: 'flexStacker/store',
+      params: {
+        moduleId: 'module-id',
+      },
+      result: {
+        primaryLabwareURI: 'tiprack-uri',
+        primaryOriginLocationSequence: [
+          { kind: 'onAddressableArea', addressableAreaName: 'A1' },
+        ],
+      },
+    }
+
+    render(command)
+    screen.getByText('store_labware_from_slot_to_stacker')
+  })
+
+  it('should render setStoredLabware command text correctly', () => {
+    const command = {
+      id: 'cmd-1',
+      commandType: 'flexStacker/setStoredLabware',
+      params: {
+        moduleId: 'module-id',
+      },
+      result: {
+        primaryLabwareURI: 'tiprack-uri',
+        primaryLabwareDefinition: {
+          metadata: {
+            displayName: 'dummy def',
+          },
+        },
+        primaryOriginLocationSequence: [
+          { kind: 'onAddressableArea', addressableAreaName: 'A1' },
+        ],
+      },
+    }
+
+    render(command)
+    screen.getByText(
+      'flex_stacker_set_stored_labware_with_quantity_and_location'
+    )
+  })
+
+  it('should render fill command text correctly', () => {
+    const command = {
+      id: 'cmd-1',
+      commandType: 'flexStacker/fill',
+      params: {
+        moduleId: 'module-id',
+      },
+      result: {
+        primaryLabwareURI: 'tiprack-uri',
+        primaryLabwareDefinition: {
+          metadata: {
+            displayName: 'dummy def',
+          },
+        },
+        primaryOriginLocationSequence: [
+          { kind: 'onAddressableArea', addressableAreaName: 'A1' },
+        ],
+      },
+    }
+
+    render(command)
+    screen.getByText('flex_stacker_fill_with_quantity_and_labware')
+  })
+
+  it('should render empty command text correctly', () => {
+    const command = {
+      id: 'cmd-1',
+      commandType: 'flexStacker/empty',
+      params: {
+        moduleId: 'module-id',
+      },
+      result: {
+        primaryLabwareURI: 'tiprack-uri',
+        primaryLabwareDefinition: {
+          metadata: {
+            displayName: 'dummy def',
+          },
+        },
+        primaryOriginLocationSequence: [
+          { kind: 'onAddressableArea', addressableAreaName: 'A1' },
+        ],
+      },
+    }
+    render(command)
+    screen.getByText('flex_stacker_empty_from_location')
+  })
+})
+
+describe.each(Object.entries(KEYS_BY_COMMAND_TYPE))(
+  'Default fallback for %s',
+  (commandType, expectedKey) => {
+    it(`should render default text for ${commandType} when result is missing`, () => {
+      const command = {
+        id: 'cmd-1',
+        commandType: commandType,
+        params: {
+          moduleId: 'module-id',
+        },
+      }
+      render(command)
+      screen.getByText(expectedKey)
+    })
+  }
+)

package/src/organisms/CommandText/useCommandTextString/utils/commandText/__tests__/getPipettingCommandText.test.tsx

@@ -0,0 +1,188 @@
+import { useTranslation } from 'react-i18next'
+import { screen } from '@testing-library/react'
+import { beforeEach, describe, it, vi } from 'vitest'
+
+import { getLabwareDefURI } from '@opentrons/shared-data'
+
+import { i18n } from '../../../../../../i18n'
+import { renderWithProviders } from '../../../../../../testing/utils'
+import { getAddressableAreaDisplayName } from '../../getAddressableAreaDisplayName'
+import { getFinalMoveToAddressableAreaCmd } from '../../getFinalAddressableAreaCmd'
+import { getFinalLabwareLocation } from '../../getFinalLabwareLocation'
+import { getLabwareDefinitionsFromCommands } from '../../getLabwareDefinitionsFromCommands'
+import { getLabwareDisplayLocation } from '../../getLabwareDisplayLocation'
+import { getLabwareName } from '../../getLabwareName'
+import { getLoadedLabware } from '../../getLoadedLabware'
+import { getWellRange } from '../../getWellRange'
+import { getPipettingCommandText } from '../getPipettingCommandText'
+
+vi.mock('@opentrons/shared-data')
+vi.mock('../../getFinalLabwareLocation')
+vi.mock('../../getWellRange')
+vi.mock('../../getLabwareDefinitionsFromCommands')
+vi.mock('../../getFinalAddressableAreaCmd')
+vi.mock('../../getAddressableAreaDisplayName')
+vi.mock('../../getLabwareName')
+vi.mock('../../getLabwareDisplayLocation')
+vi.mock('../../getLoadedLabware')
+
+const baseCommandData = {
+  allRunDefs: {},
+  robotType: 'OT-2',
+  commandTextData: {
+    commands: [],
+    labware: [],
+    modules: [],
+    pipettes: [{ id: 'pipette-1', pipetteName: 'p300_single' }],
+  },
+} as any
+
+function TestWrapper({ command }: { command: any }): JSX.Element {
+  const { t } = useTranslation('protocol_command_text')
+  const text = getPipettingCommandText({
+    command,
+    ...baseCommandData,
+    t,
+  })
+
+  return <div>{text}</div>
+}
+
+const render = (command: any) => {
+  return renderWithProviders(<TestWrapper command={command} />, {
+    i18nInstance: i18n,
+  })
+}
+
+describe('getPipettingCommandText', () => {
+  beforeEach(() => {
+    vi.mocked(getLabwareDefURI).mockImplementation((def: any) => def.uri)
+    vi.mocked(getFinalLabwareLocation).mockReturnValue('slot-1' as any)
+    vi.mocked(getWellRange).mockReturnValue('A1')
+    vi.mocked(getLabwareDefinitionsFromCommands).mockReturnValue([
+      { uri: 'tiprack-uri', parameters: { isTiprack: true } },
+      { uri: 'plate-uri', parameters: { isTiprack: false } },
+    ] as any)
+    vi.mocked(getLabwareName).mockReturnValue('Test Labware')
+    vi.mocked(getLoadedLabware).mockImplementation(
+      (labware, id) =>
+        ({
+          definitionUri: id === 'tiprack-id' ? 'tiprack-uri' : 'plate-uri',
+        } as any)
+    )
+    vi.mocked(getLabwareDisplayLocation).mockReturnValue('Slot 1')
+    vi.mocked(getFinalMoveToAddressableAreaCmd).mockReturnValue({
+      id: 'cmd-1',
+      commandType: 'moveToAddressableArea',
+    } as any)
+    vi.mocked(getAddressableAreaDisplayName).mockReturnValue('Fixed Trash')
+  })
+
+  it('should render aspirate command text correctly', () => {
+    const command = {
+      id: 'cmd-1',
+      commandType: 'aspirate',
+      params: {
+        labwareId: 'labware-1',
+        wellName: 'A1',
+        volume: 100,
+        flowRate: 150,
+      },
+    }
+
+    render(command)
+    screen.getByText(
+      /Aspirating 100 µL from well A1 of Test Labware in Slot 1 at 150 µL\/sec/
+    )
+  })
+
+  it('should render dispense command text correctly', () => {
+    const command = {
+      id: 'cmd-1',
+      commandType: 'dispense',
+      params: {
+        labwareId: 'labware-1',
+        wellName: 'A1',
+        volume: 100,
+        flowRate: 150,
+      },
+    }
+
+    render(command)
+    screen.getByText(
+      /Dispensing 100 µL into well A1 of Test Labware in Slot 1 at 150 µL\/sec/
+    )
+  })
+
+  it('should render dispense with push out command text correctly', () => {
+    const command = {
+      id: 'cmd-1',
+      commandType: 'dispense',
+      params: {
+        labwareId: 'labware-1',
+        wellName: 'A1',
+        volume: 100,
+        flowRate: 150,
+        pushOut: 10,
+      },
+    }
+
+    render(command)
+    screen.getByText(
+      /Dispensing 100 µL into well A1 of Test Labware in Slot 1 at 150 µL\/sec and pushing out 10 µL/
+    )
+  })
+
+  it('should render pickup tip command text correctly', () => {
+    const command = {
+      id: 'cmd-1',
+      commandType: 'pickUpTip',
+      params: {
+        labwareId: 'tiprack-id',
+        wellName: 'A1',
+        pipetteId: 'pipette-1',
+      },
+    }
+
+    render(command)
+    screen.getByText(/Picking up tip\(s\) from A1 of Test Labware in Slot 1/)
+  })
+
+  it('should render drop tip in tiprack command text correctly', () => {
+    const command = {
+      id: 'cmd-1',
+      commandType: 'dropTip',
+      params: {
+        labwareId: 'tiprack-id',
+        wellName: 'A1',
+      },
+    }
+
+    render(command)
+    screen.getByText(/Returning tip to A1 of Test Labware in Slot 1/)
+  })
+
+  it('should render drop tip in place command text correctly if there is an addressable area name', () => {
+    const command = {
+      id: 'cmd-1',
+      commandType: 'dropTipInPlace',
+      params: {},
+    }
+
+    render(command)
+    screen.getByText('Dropping tip in Fixed Trash')
+  })
+
+  it('should render drop tip in place command text correctly if there is not an addressable area name', () => {
+    const command = {
+      id: 'cmd-1',
+      commandType: 'dropTipInPlace',
+      params: {},
+    }
+
+    vi.mocked(getFinalMoveToAddressableAreaCmd).mockReturnValue(null)
+
+    render(command)
+    screen.getByText('Dropping tip in place')
+  })
+})