@opentrons/shared-data 0.0.0-alpha.2

package/js/getLabware.ts

@@ -0,0 +1,162 @@
+import assert from 'assert'
+import mapValues from 'lodash/mapValues'
+// TODO: Ian 2019-06-04 remove the shared-data build process for labware v1
+import definitions from '../build/labware.json'
+
+import {
+  FIXED_TRASH_RENDER_HEIGHT,
+  OPENTRONS_LABWARE_NAMESPACE,
+  SLOT_RENDER_HEIGHT,
+} from './constants'
+
+import type {
+  LabwareDefinition1,
+  LabwareDefinition2,
+  WellDefinition,
+} from './types'
+
+assert(
+  definitions && Object.keys(definitions).length > 0,
+  'Expected v1 labware defs. Something went wrong with shared-data/build/labware.json'
+)
+
+// 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 getLabwareV1Def(
+  labwareName: string
+): LabwareDefinition1 | null | undefined {
+  const labware: LabwareDefinition1 | null | undefined =
+    // @ts-expect-error(mc, 2021-04-27): make lookup more strict or remove v1 defs entirely
+    definitions[labwareName]
+  return labware
+}
+
+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__/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]]
+          )
+        })
+      })
+    })
+  })
+})

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

@@ -0,0 +1,165 @@
+// 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')
+  })
+})