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

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

@@ -1,165 +0,0 @@
-// json protocol file validator tests
-import fixtureV1JsonProtocol from '../../../protocol/fixtures/1/simple.json'
-import fixtureV3JsonProtocol from '../../../protocol/fixtures/3/simple.json'
-import fixtureV4JsonProtocol from '../../../protocol/fixtures/4/simpleV4.json'
-import fixtureV5JsonProtocol from '../../../protocol/fixtures/5/simpleV5.json'
-import {
-  fileExtensionIsPython,
-  fileExtensionIsJson,
-  fileExtensionIsZip,
-  validateJsonProtocolFileContents,
-  parseProtocolData,
-} from '../parseProtocolData'
-
-describe('validateJsonProtocolFileContents', () => {
-  let handleError: jest.MockedFunction<any>
-  // beforeAll
-
-  beforeEach(() => {
-    handleError = jest.fn()
-  })
-
-  afterEach(() => {
-    jest.resetAllMocks()
-  })
-
-  it(`should validate schemaV3 JSON protocol`, () => {
-    const data = validateJsonProtocolFileContents(
-      JSON.stringify(fixtureV3JsonProtocol)
-    )
-    expect(data).toStrictEqual(fixtureV3JsonProtocol)
-  })
-
-  it(`should validate schemaV4 JSON protocol`, () => {
-    const data = validateJsonProtocolFileContents(
-      JSON.stringify(fixtureV4JsonProtocol)
-    )
-    expect(data).toStrictEqual(fixtureV4JsonProtocol)
-  })
-
-  it(`should validate schemaV5 JSON protocol`, () => {
-    const data = validateJsonProtocolFileContents(
-      JSON.stringify(fixtureV5JsonProtocol)
-    )
-    expect(data).toStrictEqual(fixtureV5JsonProtocol)
-  })
-
-  it('should call handleError with INVALID_FILE_TYPE if empty json', () => {
-    validateJsonProtocolFileContents('[]', handleError)
-    expect(handleError).toBeCalledWith('INVALID_JSON_FILE', {
-      rawError: expect.any(Error),
-    })
-  })
-
-  it('should call handleError with INVALID_JSON_FILE if json does not validate against schema', () => {
-    validateJsonProtocolFileContents(
-      JSON.stringify(fixtureV1JsonProtocol),
-      handleError
-    )
-    expect(handleError).toBeCalledWith('INVALID_JSON_FILE', {
-      schemaErrors: expect.any(Array),
-    })
-  })
-
-  it('should call handleError with INVALID_JSON_FILE if json is not parseable', () => {
-    const parseSpy = jest.spyOn(JSON, 'parse')
-    parseSpy.mockImplementation(() => {
-      throw new Error('not parseable as JSON')
-    })
-    validateJsonProtocolFileContents('[]', handleError)
-    expect(handleError).toBeCalledWith('INVALID_JSON_FILE', {
-      rawError: expect.any(Error),
-    })
-    parseSpy.mockRestore()
-  })
-})
-
-describe('file extension validators', () => {
-  describe('fileExtensionIsPython', () => {
-    it(`should return true if file name ends in .py`, () => {
-      expect(fileExtensionIsPython('foo.py')).toBe(true)
-    })
-    it(`should return false if file name ends in anything other than .py`, () => {
-      expect(fileExtensionIsPython('foo.json')).toBe(false)
-      expect(fileExtensionIsPython('foo.zip')).toBe(false)
-      expect(fileExtensionIsPython('foo.pie')).toBe(false)
-    })
-  })
-  describe('fileExtensionIsJson', () => {
-    it(`should return true if file name ends in .json`, () => {
-      expect(fileExtensionIsJson('foo.json')).toBe(true)
-    })
-    it(`should return false if file name ends in anything other than .json`, () => {
-      expect(fileExtensionIsJson('foo.py')).toBe(false)
-      expect(fileExtensionIsJson('foo.zip')).toBe(false)
-      expect(fileExtensionIsJson('foo.pie')).toBe(false)
-    })
-  })
-  describe('fileExtensionIsZip', () => {
-    it(`should return true if file name ends in .zip`, () => {
-      expect(fileExtensionIsZip('foo.zip')).toBe(true)
-    })
-    it(`should return false if file name ends in anything other than .zip`, () => {
-      expect(fileExtensionIsZip('foo.py')).toBe(false)
-      expect(fileExtensionIsZip('foo.json')).toBe(false)
-      expect(fileExtensionIsZip('foo.pie')).toBe(false)
-    })
-  })
-  describe('fileIsBinary', () => {
-    it(`should return true if file name ends in .zip`, () => {
-      expect(fileExtensionIsZip('foo.zip')).toBe(true)
-    })
-    it(`should return false if file name ends in anything other than .zip`, () => {
-      expect(fileExtensionIsZip('foo.py')).toBe(false)
-      expect(fileExtensionIsZip('foo.json')).toBe(false)
-      expect(fileExtensionIsZip('foo.pie')).toBe(false)
-    })
-  })
-})
-
-describe('parseProtocolData', () => {
-  let handleError: jest.MockedFunction<any>
-  beforeEach(() => {
-    handleError = jest.fn()
-  })
-
-  afterEach(() => {
-    jest.resetAllMocks()
-  })
-
-  it(`should return null if not JSON and metadata not given`, () => {
-    const contents = 'from math import sqrt'
-    const pythonFile = new File([contents], 'foo.py')
-    expect(parseProtocolData(pythonFile, contents)).toBe(null)
-  })
-  it(`should return metadata if not JSON and metadata is given`, () => {
-    const contents = 'from math import sqrt'
-    const pythonFile = new File([contents], 'foo.py')
-    const metadata = {
-      'protocol-name': 'Foo Extraction',
-      author: 'Dr. Bar Baz',
-    } as any
-    expect(
-      parseProtocolData(pythonFile, contents, handleError, metadata)
-    ).toStrictEqual({ metadata })
-  })
-  it(`should return JSON protocol file if valid json protocol given`, () => {
-    const contents = JSON.stringify(fixtureV5JsonProtocol)
-    const jsonFile = new File([contents], 'valid.json')
-    expect(parseProtocolData(jsonFile, contents, handleError)).toStrictEqual(
-      fixtureV5JsonProtocol
-    )
-  })
-  it(`should call handleError if given JSON protocol not valid`, () => {
-    const contents = JSON.stringify(fixtureV1JsonProtocol)
-    const jsonFile = new File([contents], 'invalid.json')
-    expect(parseProtocolData(jsonFile, contents, handleError)).toBe(null)
-    expect(handleError).toHaveBeenCalled()
-  })
-  it(`should call handleError if given invalid file extension`, () => {
-    const contents = JSON.stringify(fixtureV1JsonProtocol)
-    const jsonFile = new File([contents], 'invalid.foobar')
-    expect(parseProtocolData(jsonFile, contents, handleError)).toBe(null)
-    expect(handleError).toHaveBeenCalledWith('INVALID_FILE_TYPE')
-  })
-})

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

@@ -1,108 +0,0 @@
-// volume helpers tests
-import * as helpers from '..'
-
-interface BaseSpec<T extends (...args: any) => any> {
-  name: string
-  func: T
-  input: Parameters<T>
-  expected: ReturnType<T>
-}
-
-type GetDisplayVolumeSpec = BaseSpec<typeof helpers.getDisplayVolume>
-
-type GetAsciiVolumeUnitsSpec = BaseSpec<typeof helpers.getAsciiVolumeUnits>
-
-type EnsureVolumeUnitsSpec = BaseSpec<typeof helpers.ensureVolumeUnits>
-
-type TestSpec =
-  | GetDisplayVolumeSpec
-  | GetAsciiVolumeUnitsSpec
-  | EnsureVolumeUnitsSpec
-
-describe('volume helpers', () => {
-  const SPECS: TestSpec[] = [
-    {
-      name: 'getDisplayVolume outputs µL string by default',
-      func: helpers.getDisplayVolume,
-      input: [380],
-      expected: '380',
-    },
-    {
-      name: 'getDisplayVolume converts to mL',
-      func: helpers.getDisplayVolume,
-      input: [4200, 'mL'],
-      expected: '4.2',
-    },
-    {
-      name: 'getDisplayVolume converts to L',
-      func: helpers.getDisplayVolume,
-      input: [800000, 'L'],
-      expected: '0.8',
-    },
-    {
-      name: 'getDisplayVolume can round to fixed digits',
-      func: helpers.getDisplayVolume,
-      input: [123456789, 'L', 3],
-      expected: '123.457',
-    },
-    {
-      name: 'getAsciiVolumeUnits converts µL to uL',
-      func: helpers.getAsciiVolumeUnits,
-      input: ['µL'],
-      expected: 'uL',
-    },
-    {
-      name: 'getAsciiVolumeUnits leaves mL alone',
-      func: helpers.getAsciiVolumeUnits,
-      input: ['mL'],
-      expected: 'mL',
-    },
-    {
-      name: 'getAsciiVolumeUnits leaves L alone',
-      func: helpers.getAsciiVolumeUnits,
-      input: ['L'],
-      expected: 'L',
-    },
-    {
-      name: 'ensureVolumeUnits converts undefined to µL',
-      func: helpers.ensureVolumeUnits,
-      input: [undefined],
-      expected: 'µL',
-    },
-    {
-      name: 'ensureVolumeUnits converts uL to µL',
-      func: helpers.ensureVolumeUnits,
-      input: ['uL'],
-      expected: 'µL',
-    },
-    {
-      name: 'ensureVolumeUnits leaves mL alone',
-      func: helpers.ensureVolumeUnits,
-      input: ['mL'],
-      expected: 'mL',
-    },
-    {
-      name: 'ensureVolumeUnits leaves L alone',
-      func: helpers.ensureVolumeUnits,
-      input: ['L'],
-      expected: 'L',
-    },
-    {
-      name: 'ensureVolumeUnits converts ml to mL',
-      func: helpers.ensureVolumeUnits,
-      input: ['ml'],
-      expected: 'mL',
-    },
-    {
-      name: 'ensureVolumeUnits leaves l to L',
-      func: helpers.ensureVolumeUnits,
-      input: ['l'],
-      expected: 'L',
-    },
-  ]
-
-  SPECS.forEach(s => {
-    // @ts-expect-error(mc, 2021-04-27): rewrite as regular tests
-    it(`should ${s.name}`, () => expect(s.func(...s.input)).toEqual(s.expected))
-  })
-})

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

@@ -1,352 +0,0 @@
-import pipetteNameSpecsFixtures from '../../../pipette/fixtures/name/pipetteNameSpecFixtures.json'
-import fixture_12_trough from '../../../labware/fixtures/2/fixture_12_trough.json'
-import fixture_96_plate from '../../../labware/fixtures/2/fixture_96_plate.json'
-import fixture_384_plate from '../../../labware/fixtures/2/fixture_384_plate.json'
-import fixture_overlappy_wellplate from '../../../labware/fixtures/2/fixture_overlappy_wellplate.json'
-import { makeWellSetHelpers } from '../wellSets'
-import { findWellAt } from '../getWellNamePerMultiTip'
-import { get96Channel384WellPlateWells, orderWells } from '..'
-
-import type { LabwareDefinition2, PipetteNameSpecs } from '../../types'
-import type { WellSetHelpers } from '../wellSets'
-
-const fixtureP10Single = pipetteNameSpecsFixtures.p10_single as PipetteNameSpecs
-const fixtureP10Multi = pipetteNameSpecsFixtures.p10_multi as PipetteNameSpecs
-const fixtureP100096 = (pipetteNameSpecsFixtures.p1000_96 as any) as PipetteNameSpecs
-const fixture12Trough = fixture_12_trough as LabwareDefinition2
-const fixture96Plate = fixture_96_plate as LabwareDefinition2
-const fixture384Plate = fixture_384_plate as LabwareDefinition2
-const fixtureOverlappyWellplate = fixture_overlappy_wellplate as LabwareDefinition2
-const EIGHT_CHANNEL = 8
-const NINETY_SIX_CHANNEL = 96
-const wellsForReservoir = [
-  'A1',
-  'A2',
-  'A3',
-  'A4',
-  'A5',
-  'A6',
-  'A7',
-  'A8',
-  'A9',
-  'A10',
-  'A11',
-  'A12',
-]
-
-const wellsFor96WellPlate = [
-  'A1',
-  'B1',
-  'C1',
-  'D1',
-  'E1',
-  'F1',
-  'G1',
-  'H1',
-  'A2',
-  'B2',
-  'C2',
-  'D2',
-  'E2',
-  'F2',
-  'G2',
-  'H2',
-  'A3',
-  'B3',
-  'C3',
-  'D3',
-  'E3',
-  'F3',
-  'G3',
-  'H3',
-  'A4',
-  'B4',
-  'C4',
-  'D4',
-  'E4',
-  'F4',
-  'G4',
-  'H4',
-  'A5',
-  'B5',
-  'C5',
-  'D5',
-  'E5',
-  'F5',
-  'G5',
-  'H5',
-  'A6',
-  'B6',
-  'C6',
-  'D6',
-  'E6',
-  'F6',
-  'G6',
-  'H6',
-  'A7',
-  'B7',
-  'C7',
-  'D7',
-  'E7',
-  'F7',
-  'G7',
-  'H7',
-  'A8',
-  'B8',
-  'C8',
-  'D8',
-  'E8',
-  'F8',
-  'G8',
-  'H8',
-  'A9',
-  'B9',
-  'C9',
-  'D9',
-  'E9',
-  'F9',
-  'G9',
-  'H9',
-  'A10',
-  'B10',
-  'C10',
-  'D10',
-  'E10',
-  'F10',
-  'G10',
-  'H10',
-  'A11',
-  'B11',
-  'C11',
-  'D11',
-  'E11',
-  'F11',
-  'G11',
-  'H11',
-  'A12',
-  'B12',
-  'C12',
-  'D12',
-  'E12',
-  'F12',
-  'G12',
-  'H12',
-]
-
-describe('findWellAt', () => {
-  it('should determine if given (x, y) is within a rectangular well', () => {
-    const def: any = {
-      wells: {
-        A1: {
-          shape: 'rectangular',
-          x: 200,
-          y: 200,
-          xDimension: 10,
-          yDimension: 10,
-        },
-      },
-    }
-    const middle = findWellAt(def, 200, 200)
-    expect(middle).toBe('A1')
-
-    const insideCornerNE = findWellAt(def, 200 - 4, 200 + 4)
-    expect(insideCornerNE).toEqual('A1')
-
-    // exactly at an edge doesn't count
-    const exactlyOnCornerNE = findWellAt(def, 200 - 5, 200 + 5)
-    expect(exactlyOnCornerNE).toBeUndefined()
-
-    const exactlyOnWEdge = findWellAt(def, 200, 200 - 5)
-    expect(exactlyOnWEdge).toBeUndefined()
-
-    const justOutsideToEast = findWellAt(def, 200 + 5.1, 200)
-    expect(justOutsideToEast).toBeUndefined()
-  })
-
-  it('should determine if given (x, y) is within a circular well', () => {
-    const def: any = {
-      wells: {
-        A1: {
-          shape: 'circular',
-          x: 200,
-          y: 200,
-          diameter: 10,
-        },
-      },
-    }
-    const middle = findWellAt(def, 200, 200)
-    expect(middle).toBe('A1')
-
-    const inside = findWellAt(def, 200 - 1, 200 + 1)
-    expect(inside).toEqual('A1')
-
-    // exactly at an edge doesn't count
-    const exactlyOnWEdge = findWellAt(def, 200, 200 - 5)
-    expect(exactlyOnWEdge).toBeUndefined()
-
-    const justOutsideToEast = findWellAt(def, 200 + 5.1, 200)
-    expect(justOutsideToEast).toBeUndefined()
-  })
-})
-describe('canPipetteUseLabware', () => {
-  let canPipetteUseLabware: WellSetHelpers['canPipetteUseLabware']
-
-  beforeEach(() => {
-    const helpers = makeWellSetHelpers()
-    canPipetteUseLabware = helpers.canPipetteUseLabware
-  })
-
-  it('returns false when wells are too close together for multi channel pipettes', () => {
-    const labwareDef = fixtureOverlappyWellplate
-    const pipette = fixtureP10Multi
-    const pipette96 = fixtureP100096
-
-    expect(canPipetteUseLabware(pipette, labwareDef)).toBe(false)
-    expect(canPipetteUseLabware(pipette96, labwareDef)).toBe(false)
-  })
-
-  it('returns true when pipette is single channel', () => {
-    const labwareDef = fixtureOverlappyWellplate
-    const pipette = fixtureP10Single
-
-    expect(canPipetteUseLabware(pipette, labwareDef)).toBe(true)
-  })
-})
-
-describe('getWellSetForMultichannel (integration test)', () => {
-  let getWellSetForMultichannel: WellSetHelpers['getWellSetForMultichannel']
-
-  beforeEach(() => {
-    const helpers = makeWellSetHelpers()
-    getWellSetForMultichannel = helpers.getWellSetForMultichannel
-  })
-
-  it('96-flat', () => {
-    const labwareDef = fixture96Plate
-
-    expect(getWellSetForMultichannel(labwareDef, 'A1', EIGHT_CHANNEL)).toEqual([
-      'A1',
-      'B1',
-      'C1',
-      'D1',
-      'E1',
-      'F1',
-      'G1',
-      'H1',
-    ])
-
-    expect(getWellSetForMultichannel(labwareDef, 'B1', EIGHT_CHANNEL)).toEqual([
-      'A1',
-      'B1',
-      'C1',
-      'D1',
-      'E1',
-      'F1',
-      'G1',
-      'H1',
-    ])
-
-    expect(getWellSetForMultichannel(labwareDef, 'H1', EIGHT_CHANNEL)).toEqual([
-      'A1',
-      'B1',
-      'C1',
-      'D1',
-      'E1',
-      'F1',
-      'G1',
-      'H1',
-    ])
-
-    expect(getWellSetForMultichannel(labwareDef, 'A2', EIGHT_CHANNEL)).toEqual([
-      'A2',
-      'B2',
-      'C2',
-      'D2',
-      'E2',
-      'F2',
-      'G2',
-      'H2',
-    ])
-
-    //  96-channel
-    expect(
-      getWellSetForMultichannel(labwareDef, 'A1', NINETY_SIX_CHANNEL)
-    ).toEqual(wellsFor96WellPlate)
-  })
-
-  it('invalid well', () => {
-    const labwareDef = fixture96Plate
-
-    expect(
-      getWellSetForMultichannel(labwareDef, 'A13', EIGHT_CHANNEL)
-    ).toBeFalsy()
-  })
-
-  it('trough-12row', () => {
-    const labwareDef = fixture12Trough
-
-    expect(getWellSetForMultichannel(labwareDef, 'A1', EIGHT_CHANNEL)).toEqual([
-      'A1',
-      'A1',
-      'A1',
-      'A1',
-      'A1',
-      'A1',
-      'A1',
-      'A1',
-    ])
-
-    expect(getWellSetForMultichannel(labwareDef, 'A2', EIGHT_CHANNEL)).toEqual([
-      'A2',
-      'A2',
-      'A2',
-      'A2',
-      'A2',
-      'A2',
-      'A2',
-      'A2',
-    ])
-
-    //  96-channel
-    expect(
-      getWellSetForMultichannel(labwareDef, 'A1', NINETY_SIX_CHANNEL)
-    ).toEqual(wellsForReservoir)
-  })
-
-  it('384-plate', () => {
-    const labwareDef = fixture384Plate
-    const well96Channel = 'A1'
-    const all384Wells = orderWells(labwareDef.ordering, 't2b', 'l2r')
-    const ninetySixChannelWells = get96Channel384WellPlateWells(
-      all384Wells,
-      well96Channel
-    )
-
-    expect(getWellSetForMultichannel(labwareDef, 'C1', EIGHT_CHANNEL)).toEqual([
-      'A1',
-      'C1',
-      'E1',
-      'G1',
-      'I1',
-      'K1',
-      'M1',
-      'O1',
-    ])
-
-    expect(getWellSetForMultichannel(labwareDef, 'F2', EIGHT_CHANNEL)).toEqual([
-      'B2',
-      'D2',
-      'F2',
-      'H2',
-      'J2',
-      'L2',
-      'N2',
-      'P2',
-    ])
-
-    //  96-channel
-    expect(
-      getWellSetForMultichannel(labwareDef, well96Channel, NINETY_SIX_CHANNEL)
-    ).toEqual(ninetySixChannelWells)
-  })
-})

package/js/helpers/get96Channel384WellPlateWells.ts

@@ -1,44 +0,0 @@
-//  TODO(jr, 10/19/23): should extend getWellNamePerMultiTip to use similar math for 96-channel and 384 well plates
-//  instead of special casing using this util
-export function get96Channel384WellPlateWells(
-  all384Wells: string[],
-  well: string
-): string[] {
-  const totalWells = 96 * 2 //  multiplying 2 because we will remove either odd or even numbers
-
-  const filterWellsFor96Channel = (start: number, isOdd: boolean): string[] => {
-    const filteredWells: string[] = []
-    let count = start
-    for (let i = 0; i < totalWells; i++) {
-      if (count < all384Wells.length) {
-        const well = all384Wells[count]
-        const numberFromWell = well.match(/\d+/)
-        if (numberFromWell) {
-          const number = parseInt(numberFromWell[0])
-          if ((number % 2 === 1 && isOdd) || (number % 2 === 0 && !isOdd)) {
-            filteredWells.push(well)
-          }
-        }
-        count += 2
-      } else {
-        break
-      }
-    }
-    return filteredWells
-  }
-
-  const allSetsOfWells = [
-    filterWellsFor96Channel(0, true),
-    filterWellsFor96Channel(1, true),
-    filterWellsFor96Channel(0, false),
-    filterWellsFor96Channel(1, false),
-  ]
-
-  for (const wells of allSetsOfWells) {
-    if (wells.includes(well)) {
-      return wells
-    }
-  }
-
-  return []
-}