@opentrons/shared-data 0.1.2-alpha.0 → 0.1.2-alpha.1

package/js/getLabware.ts

@@ -0,0 +1,145 @@
+import mapValues from 'lodash/mapValues'
+
+import {
+  FIXED_TRASH_RENDER_HEIGHT,
+  OPENTRONS_LABWARE_NAMESPACE,
+  SLOT_RENDER_HEIGHT,
+} from './constants'
+
+import type {
+  LabwareDefinition1,
+  LabwareDefinition2,
+  WellDefinition,
+} from './types'
+
+// do not list in any "available labware" UI.
+// TODO(mc, 2019-12-3): how should this correspond to RETIRED_LABWARE?
+// see shared-data/js/helpers/index.js
+export const LABWAREV2_DO_NOT_LIST = [
+  // Labware definitions only used for back-compat with legacy v1 defs:
+  'opentrons_40_aluminumblock_eppendorf_24x2ml_safelock_snapcap_generic_16x0.2ml_pcr_strip',
+  'opentrons_24_tuberack_eppendorf_2ml_safelock_snapcap_acrylic',
+  'opentrons_24_tuberack_generic_0.75ml_snapcap_acrylic',
+  'opentrons_10_tuberack_falcon_4x50ml_6x15ml_conical_acrylic',
+  'tipone_96_tiprack_200ul',
+  'eppendorf_96_tiprack_1000ul_eptips',
+  'eppendorf_96_tiprack_10ul_eptips',
+  // Replaced by opentrons_96_wellplate_200ul_pcr_full_skirt
+  // (https://opentrons.atlassian.net/browse/RLAB-230):
+  'armadillo_96_wellplate_200ul_pcr_full_skirt',
+  'opentrons_96_pcr_adapter_armadillo_wellplate_200ul',
+  // Special labware that users probably shouldn't know about or load:
+  // these all should eventually be given a new namespace like "opentrons-internal"
+  // so that they can be filtered out by namespace rather than a block list like this
+  'opentrons_1_trash_850ml_fixed',
+  'opentrons_1_trash_1100ml_fixed',
+  'opentrons_1_trash_3200ml_fixed',
+  'opentrons_calibrationblock_short_side_left',
+  'opentrons_calibrationblock_short_side_right',
+  'opentrons_calibration_adapter_heatershaker_module',
+  'opentrons_calibration_adapter_temperature_module',
+  'opentrons_calibration_adapter_thermocycler_module',
+  'opentrons_ot3_96_tiprack_20ul',
+  'opentrons_ot3_96_tiprack_200ul',
+  'opentrons_ot3_96_tiprack_1000ul',
+  'opentrons_ot3_96_tiprack_50ul',
+]
+// NOTE(sa, 2020-7-14): in PD we do not want to list calibration blocks
+// but we still might want the rest of the labware in LABWAREV2_DO_NOT_LIST
+// because of legacy protocols that might use them
+export const PD_DO_NOT_LIST = [
+  'opentrons_calibrationblock_short_side_left',
+  'opentrons_calibrationblock_short_side_right',
+  'opentrons_96_aluminumblock_biorad_wellplate_200ul',
+  'opentrons_96_aluminumblock_nest_wellplate_100ul',
+]
+
+export function getIsLabwareV1Tiprack(def: LabwareDefinition1): boolean {
+  return Boolean(def?.metadata?.isTiprack)
+}
+
+export function getIsTiprack(labwareDef: LabwareDefinition2): boolean {
+  return labwareDef.parameters.isTiprack
+}
+
+// NOTE: these labware definitions in _SHORT_MM_LABWARE_DEF_LOADNAMES
+// were written in "short mm" = 0.5mm, but
+// we will write all future definitions in actual mm.
+// These allowed labware also have engage heights measured from home switch
+// instead of from labware bottom, which is why we add ENGAGE_HEIGHT_OFFSET.
+//
+// Ideally instead of using this allow-list, we would publish a new version
+// of these definitions with corrected labware heights. However, we don't
+// support labware versioning well enough yet.
+const _SHORT_MM_LABWARE_DEF_LOADNAMES = [
+  'biorad_96_wellplate_200ul_pcr',
+  'nest_96_wellplate_100ul_pcr_full_skirt',
+  'usascientific_96_wellplate_2.4ml_deep',
+]
+
+// offset added to parameters.magneticModuleEngageHeight to convert older labware
+// definitions from "distance from home switch" to "distance from labware bottom"
+// Note: this is in actual mm, not "short mm" :)
+const ENGAGE_HEIGHT_OFFSET = -4
+
+export function getLabwareDefaultEngageHeight(
+  labwareDef: LabwareDefinition2
+): number | null {
+  const rawEngageHeight: number | null | undefined =
+    labwareDef.parameters.magneticModuleEngageHeight
+
+  if (
+    labwareDef.namespace === OPENTRONS_LABWARE_NAMESPACE &&
+    _SHORT_MM_LABWARE_DEF_LOADNAMES.includes(labwareDef.parameters.loadName)
+  ) {
+    return rawEngageHeight == null
+      ? null
+      : rawEngageHeight / 2 + ENGAGE_HEIGHT_OFFSET
+  }
+
+  return rawEngageHeight == null ? null : rawEngageHeight
+}
+
+/* Render Helpers */
+// NOTE: this doesn't account for the differing footprints of labware
+// the fixed trash render height is the first bandaid to partially
+// mend this, but overall the labware definitions in shared-data are
+// insufficient to render labware at the resolution we'd like to
+// achieve going forward.
+// TODO: BC 2019-02-28 The height constants used here should be replaced with the heights
+// in the dimensions field of the corresponding labware in definitions
+const _getSvgYValueForWell = (
+  def: LabwareDefinition1,
+  wellDef: WellDefinition
+): number => {
+  const labwareName = def.metadata.name
+  const renderHeight =
+    labwareName === 'fixed-trash'
+      ? FIXED_TRASH_RENDER_HEIGHT
+      : SLOT_RENDER_HEIGHT
+  return renderHeight - wellDef.y
+}
+
+/** For display. Flips Y axis to match SVG, applies offset to wells */
+export function getWellPropsForSVGLabwareV1(
+  def: LabwareDefinition1
+): Record<string, WellDefinition> {
+  const wellDefs = def && def.wells
+  // Most labware defs have a weird offset,
+  // but tips are mostly OK.
+  // This is a HACK to make the offset less "off"
+  const isTiprack = getIsLabwareV1Tiprack(def)
+  let xCorrection = 0
+  let yCorrection = 0
+
+  if (!isTiprack) {
+    xCorrection = 1
+    yCorrection = -3
+  }
+
+  return mapValues(wellDefs, (wellDef: WellDefinition) => ({
+    ...wellDef,
+    x: wellDef.x + xCorrection,
+    y: _getSvgYValueForWell(def, wellDef) + yCorrection,
+  }))
+}

package/js/gripper.ts

@@ -0,0 +1,29 @@
+import gripperV1 from '../gripper/definitions/1/gripperV1.json'
+import gripperV1_1 from '../gripper/definitions/1/gripperV1.1.json'
+import gripperV1_2 from '../gripper/definitions/1/gripperV1.2.json'
+
+import { GRIPPER_V1, GRIPPER_V1_1, GRIPPER_V1_2 } from './constants'
+
+import type { GripperModel, GripperDefinition } from './types'
+
+export const getGripperDef = (
+  gripperModel: GripperModel
+): GripperDefinition => {
+  switch (gripperModel) {
+    case GRIPPER_V1:
+      return gripperV1 as GripperDefinition
+    case GRIPPER_V1_1:
+      return gripperV1_1 as GripperDefinition
+    case GRIPPER_V1_2:
+      return gripperV1_2 as GripperDefinition
+    default:
+      console.warn(
+        `Could not find a gripper with model ${gripperModel}, falling back to most recent definition: ${GRIPPER_V1_1}`
+      )
+      return gripperV1_1 as GripperDefinition
+  }
+}
+
+export function getGripperDisplayName(gripperModel: GripperModel): string {
+  return getGripperDef(gripperModel).displayName
+}

package/js/helpers/__tests__/getAdapterName.test.ts

@@ -0,0 +1,31 @@
+import { getAdapterName } from '../index'
+
+describe('getAdapterName', () => {
+  it(`should return the PCR adapter name`, () => {
+    expect(
+      getAdapterName(
+        'opentrons_96_pcr_adapter_nest_wellplate_100ul_pcr_full_skirt'
+      )
+    ).toEqual('PCR Adapter')
+  })
+  it(`should return the Deep well adapter name`, () => {
+    expect(
+      getAdapterName('opentrons_96_deep_well_adapter_nest_wellplate_2ml_deep')
+    ).toEqual('Deep Well Adapter')
+  })
+  it(`should return the 96 flat bottom adapter name`, () => {
+    expect(
+      getAdapterName(
+        'opentrons_96_flat_bottom_adapter_nest_wellplate_200ul_flat'
+      )
+    ).toEqual('96 Flat Bottom Adapter')
+  })
+  it(`should return universal flat adapter name when loadname is not 1 of the 3 specified loadnames`, () => {
+    expect(
+      getAdapterName(
+        'opentrons_universal_flat_adapter_corning_384_wellplate_112ul_flat'
+      )
+    ).toEqual('Universal Flat Adapter')
+    expect(getAdapterName('random labware')).toEqual('Universal Flat Adapter')
+  })
+})

package/js/helpers/__tests__/getDeckDefFromLoadedLabware.test.ts

@@ -0,0 +1,12 @@
+import ot2DeckDef from '../../../deck/definitions/4/ot2_standard.json'
+import ot3DeckDef from '../../../deck/definitions/4/ot3_standard.json'
+import { getDeckDefFromRobotType } from '..'
+
+describe('getDeckDefFromRobotType', () => {
+  it('should return an OT-2 deck when the protocol is for an OT-2', () => {
+    expect(getDeckDefFromRobotType('OT-2 Standard')).toBe(ot2DeckDef)
+  })
+  it('should return an OT-3 deck when the protocol is for an OT-3', () => {
+    expect(getDeckDefFromRobotType('OT-3 Standard')).toBe(ot3DeckDef)
+  })
+})

package/js/helpers/__tests__/getSimplestFlexDeckConfig.test.ts

@@ -0,0 +1,176 @@
+import {
+  FLEX_SIMPLEST_DECK_CONFIG_PROTOCOL_SPEC,
+  getSimplestDeckConfigForProtocol,
+} from '../getSimplestFlexDeckConfig'
+
+import type { RunTimeCommand } from '../../../protocol'
+import type { CompletedProtocolAnalysis } from '../../types'
+
+const RUN_TIME_COMMAND_STUB_MIXIN: Pick<
+  RunTimeCommand,
+  'id' | 'createdAt' | 'startedAt' | 'completedAt' | 'status'
+> = {
+  id: 'fake_id',
+  createdAt: 'fake_createdAt',
+  startedAt: 'fake_startedAt',
+  completedAt: 'fake_createdAt',
+  status: 'succeeded',
+}
+
+describe('getSimplestDeckConfigForProtocol', () => {
+  it('returns simplest deck if no commands alter addressable areas', () => {
+    expect(getSimplestDeckConfigForProtocol(null)).toEqual(
+      FLEX_SIMPLEST_DECK_CONFIG_PROTOCOL_SPEC
+    )
+  })
+  it('returns staging area fixtures if commands address column 4 areas', () => {
+    const cutoutConfigs = getSimplestDeckConfigForProtocol(({
+      commands: [
+        {
+          ...RUN_TIME_COMMAND_STUB_MIXIN,
+          commandType: 'loadLabware',
+          params: {
+            loadName: 'fake_load_name',
+            location: { slotName: 'A4' },
+            version: 1,
+            namespace: 'fake_namespace',
+          },
+        },
+        {
+          ...RUN_TIME_COMMAND_STUB_MIXIN,
+          commandType: 'loadLabware',
+          params: {
+            loadName: 'fake_load_name',
+            location: { slotName: 'B4' },
+            version: 1,
+            namespace: 'fake_namespace',
+          },
+        },
+        {
+          ...RUN_TIME_COMMAND_STUB_MIXIN,
+          commandType: 'loadLabware',
+          params: {
+            loadName: 'fake_load_name',
+            location: { slotName: 'C4' },
+            version: 1,
+            namespace: 'fake_namespace',
+          },
+        },
+        {
+          ...RUN_TIME_COMMAND_STUB_MIXIN,
+          commandType: 'loadLabware',
+          params: {
+            loadName: 'fake_load_name',
+            location: { slotName: 'D4' },
+            version: 1,
+            namespace: 'fake_namespace',
+          },
+        },
+      ],
+      labware: [],
+    } as unknown) as CompletedProtocolAnalysis)
+    expect(cutoutConfigs).toEqual([
+      ...FLEX_SIMPLEST_DECK_CONFIG_PROTOCOL_SPEC.slice(0, 8),
+      {
+        cutoutId: 'cutoutA3',
+        cutoutFixtureId: 'stagingAreaRightSlot',
+        requiredAddressableAreas: ['A4'],
+      },
+      {
+        cutoutId: 'cutoutB3',
+        cutoutFixtureId: 'stagingAreaRightSlot',
+        requiredAddressableAreas: ['B4'],
+      },
+      {
+        cutoutId: 'cutoutC3',
+        cutoutFixtureId: 'stagingAreaRightSlot',
+        requiredAddressableAreas: ['C4'],
+      },
+      {
+        cutoutId: 'cutoutD3',
+        cutoutFixtureId: 'stagingAreaRightSlot',
+        requiredAddressableAreas: ['D4'],
+      },
+    ])
+  })
+  it('returns simplest cutout fixture where many are possible', () => {
+    const cutoutConfigs = getSimplestDeckConfigForProtocol(({
+      commands: [
+        {
+          ...RUN_TIME_COMMAND_STUB_MIXIN,
+          commandType: 'moveLabware',
+          params: {
+            newLocation: { addressableAreaName: 'gripperWasteChute' },
+            labwareId: 'fake_labwareId',
+            strategy: 'usingGripper',
+          },
+        },
+      ],
+      labware: [],
+    } as unknown) as CompletedProtocolAnalysis)
+    expect(cutoutConfigs).toEqual([
+      ...FLEX_SIMPLEST_DECK_CONFIG_PROTOCOL_SPEC.slice(0, 11),
+      {
+        cutoutId: 'cutoutD3',
+        cutoutFixtureId: 'wasteChuteRightAdapterNoCover',
+        requiredAddressableAreas: ['gripperWasteChute'],
+      },
+    ])
+  })
+  it('returns compatible cutout fixture where multiple addressable requirements present', () => {
+    const cutoutConfigs = getSimplestDeckConfigForProtocol(({
+      commands: [
+        {
+          ...RUN_TIME_COMMAND_STUB_MIXIN,
+          commandType: 'moveLabware',
+          params: {
+            newLocation: { addressableAreaName: 'gripperWasteChute' },
+            labwareId: 'fake_labwareId',
+            strategy: 'usingGripper',
+          },
+        },
+        {
+          ...RUN_TIME_COMMAND_STUB_MIXIN,
+          commandType: 'moveLabware',
+          params: {
+            newLocation: { addressableAreaName: 'D4' },
+            labwareId: 'fake_labwareId',
+            strategy: 'usingGripper',
+          },
+        },
+      ],
+      labware: [],
+    } as unknown) as CompletedProtocolAnalysis)
+    expect(cutoutConfigs).toEqual([
+      ...FLEX_SIMPLEST_DECK_CONFIG_PROTOCOL_SPEC.slice(0, 11),
+      {
+        cutoutId: 'cutoutD3',
+        cutoutFixtureId: 'stagingAreaSlotWithWasteChuteRightAdapterNoCover',
+        requiredAddressableAreas: ['gripperWasteChute', 'D4'],
+      },
+    ])
+  })
+  it('returns deck with trash in A3 when legacy trash labware is present', () => {
+    const cutoutConfigs = getSimplestDeckConfigForProtocol(({
+      commands: [],
+      labware: [
+        {
+          id: 'trash_id',
+          definitionUri: 'opentrons/opentrons_1_trash_3200ml_fixed/1',
+          displayName: 'Trash',
+          loadName: 'opentrons_1_trash_3200ml_fixed',
+          location: { slotName: 'A3' },
+        },
+      ],
+    } as unknown) as CompletedProtocolAnalysis)
+    expect(cutoutConfigs).toEqual([
+      ...FLEX_SIMPLEST_DECK_CONFIG_PROTOCOL_SPEC.slice(0, 8),
+      {
+        cutoutId: 'cutoutA3',
+        cutoutFixtureId: 'trashBinAdapter',
+        requiredAddressableAreas: ['movableTrashA3'],
+      },
+      ...FLEX_SIMPLEST_DECK_CONFIG_PROTOCOL_SPEC.slice(9),
+    ])
+  })
+})

package/js/helpers/__tests__/getVectorDifference.test.ts

@@ -0,0 +1,25 @@
+import { getVectorDifference } from '../getVectorDifference'
+
+describe('getVectorDifference', () => {
+  it(`should calculate difference betwen pointA and pointB with integer values`, () => {
+    expect(
+      getVectorDifference({ x: 1, y: 2, z: 3 }, { x: 1, y: 2, z: 3 })
+    ).toEqual({ x: 0, y: 0, z: 0 })
+  })
+  it(`should calculate difference betwen pointA and pointB with decimal values`, () => {
+    expect(
+      getVectorDifference(
+        { x: 1.0, y: 2.0, z: 3.0 },
+        { x: 1.0, y: 2.0, z: 3.0 }
+      )
+    ).toEqual({ x: 0, y: 0, z: 0 })
+  })
+  it(`should calculate difference betwen pointA and pointB with mix of negative and positive`, () => {
+    expect(
+      getVectorDifference(
+        { x: -1.0, y: -2.0, z: -3.0 },
+        { x: 1.0, y: 2.0, z: 3.0 }
+      )
+    ).toEqual({ x: -2, y: -4, z: -6 })
+  })
+})

package/js/helpers/__tests__/getVectorSum.test.ts

@@ -0,0 +1,21 @@
+import { getVectorSum } from '../getVectorSum'
+
+describe('getVectorSum', () => {
+  it(`should calculate sum betwen pointA and pointB with integer values`, () => {
+    expect(getVectorSum({ x: 1, y: 2, z: 3 }, { x: 1, y: 2, z: 3 })).toEqual({
+      x: 2,
+      y: 4,
+      z: 6,
+    })
+  })
+  it(`should calculate sum betwen pointA and pointB with decimal values`, () => {
+    expect(
+      getVectorSum({ x: 1.0, y: 2.0, z: 3.0 }, { x: 1.0, y: 2.0, z: 3.0 })
+    ).toEqual({ x: 2, y: 4, z: 6 })
+  })
+  it(`should calculate sum betwen pointA and pointB with mix of negative and positive`, () => {
+    expect(
+      getVectorSum({ x: -1.0, y: -2.0, z: -3.0 }, { x: 1.0, y: 2.0, z: 3.0 })
+    ).toEqual({ x: 0, y: 0, z: 0 })
+  })
+})

package/js/helpers/__tests__/labwareInference.test.ts

@@ -0,0 +1,84 @@
+import { getIfConsistent, getSpacingIfUniform } from '../labwareInference'
+
+describe('getSpacingIfUniform', () => {
+  const testCases = [
+    {
+      testLabel: '1 well case: return 0',
+      wells: [{ x: 10 }],
+      expected: 0,
+    },
+    {
+      testLabel: '2 well case',
+      wells: [{ x: 10 }, { x: 20 }],
+      expected: 10,
+    },
+    {
+      testLabel:
+        '2 well case with overlapping wells (eg, single-column labware): return 0',
+      wells: [{ x: 10 }, { x: 10 }],
+      expected: 0,
+    },
+    {
+      testLabel: '3 well case',
+      wells: [{ x: 0 }, { x: 25 }, { x: 50 }],
+      expected: 25,
+    },
+    {
+      testLabel:
+        '3 well case with overlapping wells (eg, single-column labware): return 0',
+      wells: [{ x: 10 }, { x: 10 }, { x: 10 }],
+      expected: 0,
+    },
+    {
+      testLabel: '3 well case: out of order is non-uniform, return null',
+      wells: [{ x: 50 }, { x: 0 }, { x: 25 }],
+      expected: null,
+    },
+    {
+      testLabel: '3 well case: non-uniform with some duplicate values',
+      wells: [
+        { x: 0 },
+        { x: 25 },
+        { x: 25, spam: 'spam' },
+        { x: 50 },
+        { x: 50, foo: 'foo' },
+      ],
+      expected: 25,
+    },
+    {
+      testLabel: 'returns null if wells have irregular spacing',
+      wells: [{ x: 10 }, { x: 20 }, { x: 21 }],
+      expected: null,
+    },
+    {
+      testLabel: 'returns 0 with no wells',
+      wells: [],
+      expected: 0,
+    },
+  ]
+  testCases.forEach(({ wells, expected, testLabel }) =>
+    it(testLabel, () =>
+      expect(getSpacingIfUniform(wells as any[], 'x')).toBe(expected)
+    )
+  )
+})
+
+describe('getIfConsistent', () => {
+  it('deep equal', () => {
+    const items = [
+      { a: 123, b: [1, 2, [3]] },
+      { a: 123, b: [1, 2, [3]] },
+      { a: 123, b: [1, 2, [3]] },
+    ]
+    expect(getIfConsistent(items)).toEqual(items[0])
+  })
+
+  it('deep difference', () => {
+    const items = [
+      { a: 123, b: [1, 2, [3]] },
+      { a: 123, b: [1, 2, [999999]] },
+      { a: 123, b: [1, 2, [3]] },
+    ]
+    expect(getIfConsistent(items)).toBe(null)
+  })
+})

package/js/helpers/__tests__/orderWells.test.ts

@@ -0,0 +1,87 @@
+import { orderWells } from '../orderWells'
+import type { WellOrderOption } from '../orderWells'
+
+describe('orderWells', () => {
+  const orderTuples: Array<[WellOrderOption, WellOrderOption]> = [
+    ['t2b', 'l2r'],
+    ['t2b', 'r2l'],
+    ['b2t', 'l2r'],
+    ['b2t', 'r2l'],
+    ['l2r', 't2b'],
+    ['l2r', 'b2t'],
+    ['r2l', 't2b'],
+    ['r2l', 'b2t'],
+  ]
+
+  describe('regular labware', () => {
+    const regularOrdering = [
+      ['A1', 'B1'],
+      ['A2', 'B2'],
+    ]
+    const regularAnswerMap: Record<
+      WellOrderOption,
+      Partial<Record<WellOrderOption, string[]>>
+    > = {
+      t2b: {
+        l2r: ['A1', 'B1', 'A2', 'B2'],
+        r2l: ['A2', 'B2', 'A1', 'B1'],
+      },
+      b2t: {
+        l2r: ['B1', 'A1', 'B2', 'A2'],
+        r2l: ['B2', 'A2', 'B1', 'A1'],
+      },
+      l2r: {
+        t2b: ['A1', 'A2', 'B1', 'B2'],
+        b2t: ['B1', 'B2', 'A1', 'A2'],
+      },
+      r2l: {
+        t2b: ['A2', 'A1', 'B2', 'B1'],
+        b2t: ['B2', 'B1', 'A2', 'A1'],
+      },
+    }
+    orderTuples.forEach(tuple => {
+      it(`first ${tuple[0]} then ${tuple[1]}`, () => {
+        expect(orderWells(regularOrdering, ...tuple)).toEqual(
+          regularAnswerMap[tuple[0]][tuple[1]]
+        )
+      })
+    })
+    describe('irregular labware', () => {
+      const irregularOrdering = [
+        ['A1', 'B1'],
+        ['A2', 'B2', 'C2'],
+        ['A3'],
+        ['A4', 'B4', 'C4', 'D4'],
+      ]
+      const irregularAnswerMap: Record<
+        WellOrderOption,
+        Partial<Record<WellOrderOption, string[]>>
+      > = {
+        t2b: {
+          l2r: ['A1', 'B1', 'A2', 'B2', 'C2', 'A3', 'A4', 'B4', 'C4', 'D4'],
+          r2l: ['A4', 'B4', 'C4', 'D4', 'A3', 'A2', 'B2', 'C2', 'A1', 'B1'],
+        },
+        b2t: {
+          l2r: ['B1', 'A1', 'C2', 'B2', 'A2', 'A3', 'D4', 'C4', 'B4', 'A4'],
+          r2l: ['D4', 'C4', 'B4', 'A4', 'A3', 'C2', 'B2', 'A2', 'B1', 'A1'],
+        },
+        l2r: {
+          t2b: ['A1', 'A2', 'A3', 'A4', 'B1', 'B2', 'B4', 'C2', 'C4', 'D4'],
+          b2t: ['D4', 'C2', 'C4', 'B1', 'B2', 'B4', 'A1', 'A2', 'A3', 'A4'],
+        },
+        r2l: {
+          t2b: ['A4', 'A3', 'A2', 'A1', 'B4', 'B2', 'B1', 'C4', 'C2', 'D4'],
+          b2t: ['D4', 'C4', 'C2', 'B4', 'B2', 'B1', 'A4', 'A3', 'A2', 'A1'],
+        },
+      }
+
+      orderTuples.forEach(tuple => {
+        it(`first ${tuple[0]} then ${tuple[1]}`, () => {
+          expect(orderWells(irregularOrdering, ...tuple)).toEqual(
+            irregularAnswerMap[tuple[0]][tuple[1]]
+          )
+        })
+      })
+    })
+  })
+})