@opentrons/shared-data 0.0.1-alpha.20 → 0.0.1-alpha.21

package/js/getLabware.ts

@@ -1,154 +0,0 @@
-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 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

@@ -1,29 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,84 +0,0 @@
-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

@@ -1,87 +0,0 @@
-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

@@ -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')
-  })
-})