@opentrons/shared-data 0.0.0-alpha.2

package/js/__tests__/labwareDefSchemaV2.test.ts

@@ -0,0 +1,298 @@
+import path from 'path'
+import glob from 'glob'
+import Ajv from 'ajv'
+
+import schema from '../../labware/schemas/2.json'
+import type { LabwareDefinition2, LabwareWell } from '../types'
+
+const definitionsDir = path.join(__dirname, '../../labware/definitions/2')
+const fixturesDir = path.join(__dirname, '../../labware/fixtures/2')
+const globPattern = '**/*.json'
+
+// JSON Schema definition & setup
+const ajv = new Ajv({ allErrors: true, jsonPointers: true })
+const validate = ajv.compile(schema)
+
+const generateStandardWellNames = (
+  rowCount: number,
+  columnCount: number
+): Set<string> => {
+  const result = new Set<string>()
+
+  for (let column = 0; column < columnCount; column++) {
+    for (let row = 0; row < rowCount; row++) {
+      const columnName = (column + 1).toString()
+      const rowName = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'[row]
+      result.add(rowName + columnName)
+    }
+  }
+
+  return result
+}
+
+const standard24WellNames = generateStandardWellNames(4, 6)
+const standard96WellNames = generateStandardWellNames(8, 12)
+const standard384WellNames = generateStandardWellNames(16, 24)
+
+// Wells whose tops lie above the labware's zDimension.
+// These are known bugs in the labware definition. See Jira RSS-202.
+const expectedWellsHigherThanZDimension: Record<string, Set<string>> = {
+  'geb_96_tiprack_10ul/1.json': standard96WellNames,
+  'opentrons_24_aluminumblock_generic_2ml_screwcap/1.json': standard24WellNames,
+  'opentrons_24_tuberack_eppendorf_2ml_safelock_snapcap/1.json': standard24WellNames,
+  'opentrons_96_aluminumblock_generic_pcr_strip_200ul/1.json': standard96WellNames,
+  'opentrons_96_filtertiprack_200ul/1.json': standard96WellNames,
+  'opentrons_96_tiprack_300ul/1.json': standard96WellNames,
+}
+
+// Wells whose tops do not lie exactly at the labware's zDimension.
+//
+// There are legitimate reasons for this to happen, but it can also be a dangerous bug
+// in the labware definition. So if it happens, it needs to be justified here.
+const expectedWellsNotMatchingZDimension: Record<string, Set<string>> = {
+  ...expectedWellsHigherThanZDimension,
+
+  // These height mismatches are legitimate.
+  // These tube racks simultaneously hold tubes of different heights.
+  // The labware's zDimension should match the height of the taller tubes,
+  // not the shorter tubes listed here.
+  'opentrons_10_tuberack_falcon_4x50ml_6x15ml_conical/1.json': new Set([
+    'A3',
+    'B3',
+    'A4',
+    'B4',
+  ]),
+  'opentrons_10_tuberack_falcon_4x50ml_6x15ml_conical_acrylic/1.json': new Set([
+    'A3',
+    'B3',
+    'A4',
+    'B4',
+  ]),
+  'opentrons_10_tuberack_nest_4x50ml_6x15ml_conical/1.json': new Set([
+    'A3',
+    'B3',
+    'A4',
+    'B4',
+  ]),
+
+  // These height mismatches are legitimate. The zDimension should match the taller side.
+  'opentrons_calibrationblock_short_side_left/1.json': new Set(['A1']),
+  'opentrons_calibrationblock_short_side_right/1.json': new Set(['A2']),
+
+  // These height mismatches need to be investigated. See Jira RSS-202.
+  // Each one should either be explained here or marked as a known bug.
+  'nest_1_reservoir_195ml/1.json': new Set(['A1']),
+  'nest_1_reservoir_195ml/2.json': new Set(['A1']),
+  'opentrons_40_aluminumblock_eppendorf_24x2ml_safelock_snapcap_generic_16x0.2ml_pcr_strip/1.json': new Set(
+    [
+      'A3',
+      'B3',
+      'C3',
+      'D3',
+      'A4',
+      'B4',
+      'C4',
+      'D4',
+      'A5',
+      'B5',
+      'C5',
+      'D5',
+      'A6',
+      'B6',
+      'C6',
+      'D6',
+      'A7',
+      'B7',
+      'C7',
+      'D7',
+      'A8',
+      'B8',
+      'C8',
+      'D8',
+    ]
+  ),
+  'opentrons_96_flat_bottom_adapter_nest_wellplate_200ul_flat/1.json': standard96WellNames,
+  'opentrons_96_pcr_adapter_nest_wellplate_100ul_pcr_full_skirt/1.json': standard96WellNames,
+  'opentrons_universal_flat_adapter_corning_384_wellplate_112ul_flat/1.json': standard384WellNames,
+}
+
+const filterWells = (
+  labwareDef: LabwareDefinition2,
+  predicate: (wellDef: LabwareWell) => boolean
+): Set<string> => {
+  return new Set(
+    Object.entries(labwareDef.wells)
+      .filter(([wellName, wellDef]) => predicate(wellDef))
+      .map(([wellName, wellDef]) => wellName)
+  )
+}
+
+const getWellsNotMatchingZDimension = (
+  labwareDef: LabwareDefinition2
+): Set<string> => {
+  return filterWells(labwareDef, wellDef => {
+    const absDifference = Math.abs(
+      wellDef.depth + wellDef.z - labwareDef.dimensions.zDimension
+    )
+    return absDifference > 0.000001 // Tolerate floating point rounding errors.
+  })
+}
+
+const getWellsHigherThanZDimension = (
+  labwareDef: LabwareDefinition2
+): Set<string> => {
+  return filterWells(labwareDef, wellDef => {
+    const difference =
+      wellDef.depth + wellDef.z - labwareDef.dimensions.zDimension
+    return difference > 0.000001 // Tolerate floating point rounding errors.
+  })
+}
+
+const expectGroupsFollowConvention = (
+  labwareDef: LabwareDefinition2,
+  filename: string
+): void => {
+  test(`${filename} should not contain "groups.brand.brand" that matches the top-level "brand.brand"`, () => {
+    const topLevelBrand = labwareDef.brand
+
+    labwareDef.groups.forEach(group => {
+      expect(group.brand?.brand).not.toEqual(topLevelBrand)
+    })
+  })
+
+  test(`${filename} should not specify certain fields in 'groups' if it is a reservoir or wellPlate`, () => {
+    const { displayCategory } = labwareDef.metadata
+    const noGroupsMetadataAllowed =
+      displayCategory === 'reservoir' || displayCategory === 'wellPlate'
+
+    if (noGroupsMetadataAllowed) {
+      labwareDef.groups.forEach(group => {
+        /* eslint-disable jest/no-conditional-expect */
+        expect(group.brand).toBe(undefined)
+        expect(group.metadata.displayName).toBe(undefined)
+        expect(group.metadata.displayCategory).toBe(undefined)
+      })
+    }
+  })
+}
+
+test('fail on bad labware', () => {
+  const badDef = {
+    metadata: { name: 'bad' },
+    ordering: ['A1'],
+    // array of strings not array of arrays
+    wells: {},
+  }
+  const valid = validate(badDef)
+  const validationErrors = validate.errors
+
+  expect(
+    validationErrors?.find(err => err.dataPath === '/ordering/0')
+  ).toMatchObject({
+    message: 'should be array',
+  })
+  expect(valid).toBe(false)
+})
+
+describe('test schemas of all opentrons definitions', () => {
+  const labwarePaths = glob.sync(globPattern, { cwd: definitionsDir })
+
+  beforeAll(() => {
+    // Make sure definitions path didn't break, which would give you false positives
+    expect(labwarePaths.length).toBeGreaterThan(0)
+  })
+
+  labwarePaths.forEach(labwarePath => {
+    const filename = path.parse(labwarePath).base
+    const fullLabwarePath = path.join(definitionsDir, labwarePath)
+    const labwareDef = require(fullLabwarePath) as LabwareDefinition2
+
+    it(`${filename} validates against schema`, () => {
+      const valid = validate(labwareDef)
+      const validationErrors = validate.errors
+      expect(validationErrors).toBe(null)
+      expect(valid).toBe(true)
+    })
+
+    it(`file name matches version: ${labwarePath}`, () => {
+      expect(`${labwareDef.version}`).toEqual(path.basename(filename, '.json'))
+    })
+
+    it(`parent dir matches loadName: ${labwarePath}`, () => {
+      expect(labwareDef.parameters.loadName).toEqual(
+        path.basename(path.dirname(labwarePath))
+      )
+    })
+
+    it(`namespace is "opentrons": ${labwarePath}`, () => {
+      expect(labwareDef.namespace).toEqual('opentrons')
+    })
+
+    if (labwareDef.parameters.loadName !== 'nest_96_wellplate_2ml_deep') {
+      // TODO(IL, 2020-06-22): make nest_96_wellplate_2ml_deep confirm to groups convention
+      expectGroupsFollowConvention(labwareDef, labwarePath)
+    }
+  })
+})
+
+describe('test that the dimensions in all opentrons definitions make sense', () => {
+  const labwarePaths = glob.sync('**/*.json', { cwd: definitionsDir })
+
+  beforeAll(() => {
+    // Make sure definitions path didn't break, which would give you false positives
+    expect(labwarePaths.length).toBeGreaterThan(0)
+  })
+
+  describe.each(labwarePaths)('%s', labwarePath => {
+    const fullLabwarePath = path.join(definitionsDir, labwarePath)
+    const labwareDef = require(fullLabwarePath) as LabwareDefinition2
+
+    const expectedWellsNotMatching =
+      expectedWellsNotMatchingZDimension[labwarePath] ?? new Set()
+    it(`has the expected ${expectedWellsNotMatching.size} wells not matching the labware's zDimension`, () => {
+      const wellsNotMatching = getWellsNotMatchingZDimension(labwareDef)
+      expect(wellsNotMatching).toEqual(expectedWellsNotMatching)
+    })
+
+    const expectedWellsHigher =
+      expectedWellsHigherThanZDimension[labwarePath] ?? new Set()
+    it(`has the expected ${expectedWellsHigher.size} wells above the labware's zDimension`, () => {
+      const wellsHigher = getWellsHigherThanZDimension(labwareDef)
+      expect(wellsHigher).toEqual(expectedWellsHigher)
+    })
+  })
+})
+
+describe('test schemas of all v2 labware fixtures', () => {
+  const labwarePaths = glob.sync(globPattern, { cwd: fixturesDir })
+
+  beforeAll(() => {
+    // Make sure fixtures path didn't break, which would give you false positives
+    expect(labwarePaths.length).toBeGreaterThan(0)
+  })
+
+  labwarePaths.forEach(labwarePath => {
+    const filename = path.parse(labwarePath).base
+    const fullLabwarePath = path.join(fixturesDir, labwarePath)
+    const labwareDef = require(fullLabwarePath) as LabwareDefinition2
+
+    it(`${filename} validates against schema`, () => {
+      const valid = validate(labwareDef)
+      const validationErrors = validate.errors
+      expect(validationErrors).toBe(null)
+      expect(valid).toBe(true)
+    })
+
+    it(`fixture file name matches loadName: ${labwarePath}`, () => {
+      expect(labwareDef.parameters.loadName).toEqual(
+        path.basename(filename, '.json')
+      )
+    })
+
+    it(`namespace is "fixture": ${labwarePath}`, () => {
+      expect(labwareDef.namespace).toEqual('fixture')
+    })
+
+    expectGroupsFollowConvention(labwareDef, filename)
+  })
+})

package/js/__tests__/moduleAccessors.test.ts

@@ -0,0 +1,50 @@
+import {
+  getModuleDef2,
+  getModuleType,
+  getModuleDisplayName,
+  normalizeModuleModel,
+} from '../modules'
+
+import {
+  MODULE_MODELS,
+  MODULE_TYPES,
+  TEMPDECK,
+  MAGDECK,
+  THERMOCYCLER,
+  MAGNETIC_MODULE_V1,
+  TEMPERATURE_MODULE_V1,
+  THERMOCYCLER_MODULE_V1,
+} from '../constants'
+
+describe('all valid models work', () => {
+  MODULE_MODELS.forEach(model => {
+    const loadedDef = getModuleDef2(model)
+
+    it('ensure valid models load', () => {
+      expect(loadedDef).not.toBeNull()
+      expect(loadedDef?.model).toEqual(model)
+    })
+
+    it('valid models have valid module types', () => {
+      expect(getModuleType(model)).toEqual(loadedDef.moduleType)
+      expect(MODULE_TYPES).toContain(getModuleType(model))
+    })
+
+    it('valid modules have display names that match the def', () => {
+      expect(getModuleDisplayName(model)).toEqual(loadedDef.displayName)
+    })
+  })
+})
+
+describe('legacy models work too', () => {
+  const legacyEquivs = [
+    [TEMPDECK, TEMPERATURE_MODULE_V1],
+    [MAGDECK, MAGNETIC_MODULE_V1],
+    [THERMOCYCLER, THERMOCYCLER_MODULE_V1],
+  ] as const
+
+  legacyEquivs.forEach(([legacy, modern]) => {
+    const fromLegacy = normalizeModuleModel(legacy)
+    expect(fromLegacy).toEqual(modern)
+  })
+})

package/js/__tests__/moduleSpecsSchema.test.ts

@@ -0,0 +1,77 @@
+import Ajv from 'ajv'
+import moduleSpecsSchemaV1 from '../../module/schemas/1.json'
+import moduleSpecsV1 from '../../module/definitions/1.json'
+import moduleSpecsSchemaV2 from '../../module/schemas/2.json'
+import moduleSpecsSchemaV3 from '../../module/schemas/3.json'
+import path from 'path'
+import glob from 'glob'
+
+const ajv = new Ajv({ allErrors: true, jsonPointers: true })
+const validateModuleSpecsV1 = ajv.compile(moduleSpecsSchemaV1)
+const validateModuleSpecsV2 = ajv.compile(moduleSpecsSchemaV2)
+const validateModuleSpecsV3 = ajv.compile(moduleSpecsSchemaV3)
+
+const V2_DEFS_GLOB_PATTERN = '../../module/definitions/2/*.json'
+const V3_DEFS_GLOB_PATTERN = '../../module/definitions/3/*.json'
+
+const GLOB_OPTIONS = { cwd: __dirname, absolute: true }
+
+const V2_MODULE_PATHS = glob.sync(V2_DEFS_GLOB_PATTERN, GLOB_OPTIONS)
+const V3_MODULE_PATHS = glob.sync(V3_DEFS_GLOB_PATTERN, GLOB_OPTIONS)
+
+describe('validate all module specs with schema', () => {
+  beforeAll(() => {
+    expect(V2_MODULE_PATHS).not.toHaveLength(0)
+    expect(V3_MODULE_PATHS).not.toHaveLength(0)
+  })
+
+  it('ensure V1 module specs match the V1 JSON schema', () => {
+    const valid = validateModuleSpecsV1(moduleSpecsV1)
+    const validationErrors = validateModuleSpecsV1.errors
+
+    expect(validationErrors).toBe(null)
+    expect(valid).toBe(true)
+  })
+
+  V2_MODULE_PATHS.forEach(modulePath => {
+    const filename = path.parse(modulePath).name
+    const moduleDef = require(modulePath)
+
+    it(`${filename} validates against schema`, () => {
+      const valid = validateModuleSpecsV2(moduleDef)
+      const validationErrors = validateModuleSpecsV2.errors
+
+      expect(validationErrors).toBe(null)
+      expect(valid).toBe(true)
+    })
+  })
+
+  V3_MODULE_PATHS.forEach(modulePath => {
+    const filename = path.parse(modulePath).name
+    const moduleDef = require(modulePath)
+
+    it(`validates ${filename} against schema`, () => {
+      const valid = validateModuleSpecsV3(moduleDef)
+      const validationErrors = validateModuleSpecsV3.errors
+
+      expect(validationErrors).toBe(null)
+      expect(valid).toBe(true)
+    })
+  })
+
+  it('validate each module specs model matches its filename', () => {
+    V2_MODULE_PATHS.forEach(modulePath => {
+      const filename = path.parse(modulePath).name
+      const moduleDef = require(modulePath)
+
+      expect(moduleDef.model).toEqual(filename)
+    })
+
+    V3_MODULE_PATHS.forEach(modulePath => {
+      const filename = path.parse(modulePath).name
+      const moduleDef = require(modulePath)
+
+      expect(moduleDef.model).toEqual(filename)
+    })
+  })
+})

package/js/__tests__/pipetteSchemaV2.test.ts

@@ -0,0 +1,107 @@
+import Ajv from 'ajv'
+import glob from 'glob'
+import path from 'path'
+
+import liquidSpecsSchema from '../../pipette/schemas/2/pipetteLiquidPropertiesSchema.json'
+import geometrySpecsSchema from '../../pipette/schemas/2/pipetteGeometrySchema.json'
+import generalSpecsSchema from '../../pipette/schemas/2/pipettePropertiesSchema.json'
+
+const allGeometryDefinitions = path.join(
+  __dirname,
+  '../../pipette/definitions/2/geometry/**/**/*.json'
+)
+
+const allGeneralDefinitions = path.join(
+  __dirname,
+  '../../pipette/definitions/2/general/**/**/*.json'
+)
+
+const allLiquidDefinitions = path.join(
+  __dirname,
+  '../../pipette/definitions/2/liquid/**/**/*.json'
+)
+
+const ajv = new Ajv({ allErrors: true, jsonPointers: true })
+
+const validateLiquidSpecs = ajv.compile(liquidSpecsSchema)
+const validateGeometrySpecs = ajv.compile(geometrySpecsSchema)
+const validateGeneralSpecs = ajv.compile(generalSpecsSchema)
+
+describe('test schema against all liquid specs definitions', () => {
+  const liquidPaths = glob.sync(allLiquidDefinitions)
+  // Make sure definitions path didn't break, which would give you false positives
+  expect(liquidPaths.length).toBeGreaterThan(0)
+
+  liquidPaths.forEach(liquidPath => {
+    const liquidDef = require(liquidPath)
+
+    it(`${liquidPath} validates against schema`, () => {
+      const valid = validateLiquidSpecs(liquidDef)
+      const validationErrors = validateLiquidSpecs.errors
+      expect(validationErrors).toBe(null)
+      expect(valid).toBe(true)
+    })
+
+    it(`parent dir matches a liquid class: ${liquidPath}`, () => {
+      expect(['default', 'lowVolumeDefault']).toContain(
+        path.basename(path.dirname(liquidPath))
+      )
+    })
+
+    it(`second parent dir matches pipette model: ${liquidPath}`, () => {
+      expect(['p10', 'p20', 'p50', 'p300', 'p1000']).toContain(
+        path.basename(path.dirname(path.dirname(liquidPath)))
+      )
+    })
+  })
+})
+
+describe('test schema against all geometry specs definitions', () => {
+  const geometryPaths = glob.sync(allGeometryDefinitions)
+  // Make sure definitions path didn't break, which would give you false positives
+  expect(geometryPaths.length).toBeGreaterThan(0)
+  geometryPaths.forEach(geometryPath => {
+    const geometryDef = require(geometryPath)
+    const geometryParentDir = path.dirname(geometryPath)
+
+    it(`${geometryPath} validates against schema`, () => {
+      const valid = validateGeometrySpecs(geometryDef)
+      const validationErrors = validateGeometrySpecs.errors
+      expect(validationErrors).toBe(null)
+      expect(valid).toBe(true)
+    })
+
+    it(`parent dir matches pipette model: ${geometryPath}`, () => {
+      expect(['p10', 'p20', 'p50', 'p300', 'p1000']).toContain(
+        path.basename(path.dirname(geometryPath))
+      )
+    })
+
+    it(`parent directory contains a gltf file: ${geometryPath}`, () => {
+      const gltf_file = glob.sync(path.join(geometryParentDir, '*.gltf'))
+      expect(gltf_file.length).toBeGreaterThan(0)
+      expect(gltf_file).toBeDefined()
+    })
+  })
+})
+
+describe('test schema against all general specs definitions', () => {
+  const generalPaths = glob.sync(allGeneralDefinitions)
+  expect(generalPaths.length).toBeGreaterThan(0)
+
+  generalPaths.forEach(generalPath => {
+    it(`${generalPath} validates against schema`, () => {
+      const generalDef = require(generalPath)
+      const valid = validateGeneralSpecs(generalDef)
+      const validationErrors = validateGeneralSpecs.errors
+      expect(validationErrors).toBe(null)
+      expect(valid).toBe(true)
+    })
+
+    it(`parent dir matches pipette model: ${generalPath}`, () => {
+      expect(['p10', 'p20', 'p50', 'p300', 'p1000']).toContain(
+        path.basename(path.dirname(generalPath))
+      )
+    })
+  })
+})

package/js/__tests__/pipetteSpecSchemas.test.ts

@@ -0,0 +1,48 @@
+import Ajv from 'ajv'
+import nameSpecsSchema from '../../pipette/schemas/1/pipetteNameSpecsSchema.json'
+import modelSpecsSchema from '../../pipette/schemas/1/pipetteModelSpecsSchema.json'
+import pipetteNameSpecs from '../../pipette/definitions/1/pipetteNameSpecs.json'
+import pipetteModelSpecs from '../../pipette/definitions/1/pipetteModelSpecs.json'
+
+const ajv = new Ajv({ allErrors: true, jsonPointers: true })
+
+const validateNameSpecs = ajv.compile(nameSpecsSchema)
+const validateModelSpecs = ajv.compile(modelSpecsSchema)
+
+describe('validate pipette specs with JSON schemas', () => {
+  it('ensure all pipette *NAME* specs match name JSON schema', () => {
+    const valid = validateNameSpecs(pipetteNameSpecs)
+    const validationErrors = validateNameSpecs.errors
+
+    if (validationErrors) {
+      console.log(JSON.stringify(validationErrors, null, 4))
+    }
+
+    expect(validationErrors).toBe(null)
+    expect(valid).toBe(true)
+  })
+
+  it('ensure all pipette *MODEL* specs match model JSON schema', () => {
+    const valid = validateModelSpecs(pipetteModelSpecs)
+    const validationErrors = validateModelSpecs.errors
+
+    if (validationErrors) {
+      console.log(JSON.stringify(validationErrors, null, 4))
+    }
+
+    expect(validationErrors).toBe(null)
+    expect(valid).toBe(true)
+  })
+})
+
+describe('model -> name referencing', () => {
+  it('ensure all pipette model specs reference a valid pipette name', () => {
+    const modelConfigs = Object.values(pipetteModelSpecs.config)
+    const nameKeys = Object.keys(pipetteNameSpecs)
+
+    modelConfigs.forEach(config => {
+      const nameForVersion = config.name
+      expect(nameKeys).toContain(nameForVersion)
+    })
+  })
+})

package/js/__tests__/pipettes.test.ts

@@ -0,0 +1,58 @@
+// tests for pipette info accessors in `shared-data/js/pipettes.js`
+import { getPipetteNameSpecs, getPipetteModelSpecs } from '../pipettes'
+
+const PIPETTE_NAMES = [
+  'p10_single',
+  'p50_single',
+  'p300_single',
+  'p1000_single',
+  'p10_multi',
+  'p50_multi',
+  'p300_multi',
+] as const
+
+const PIPETTE_MODELS = [
+  'p10_single_v1',
+  'p10_single_v1.3',
+  'p10_single_v1.4',
+  'p10_single_v1.5',
+  'p10_multi_v1',
+  'p10_multi_v1.3',
+  'p10_multi_v1.4',
+  'p10_multi_v1.5',
+  'p50_single_v1',
+  'p50_single_v1.3',
+  'p50_single_v1.4',
+  'p50_multi_v1',
+  'p50_multi_v1.3',
+  'p50_multi_v1.4',
+  'p50_multi_v1.5',
+  'p300_single_v1',
+  'p300_single_v1.3',
+  'p300_single_v1.4',
+  'p300_single_v1.5',
+  'p300_multi_v1',
+  'p300_multi_v1.3',
+  'p300_multi_v1.4',
+  'p300_multi_v1.5',
+  'p1000_single_v1',
+  'p1000_single_v1.3',
+  'p1000_single_v1.4',
+  'p1000_single_v1.5',
+] as const
+
+describe('pipette data accessors', () => {
+  describe('getPipetteNameSpecs', () => {
+    PIPETTE_NAMES.forEach(name =>
+      it(`name ${name} snapshot`, () =>
+        expect(getPipetteNameSpecs(name)).toMatchSnapshot())
+    )
+  })
+
+  describe('getPipetteModelSpecs', () => {
+    PIPETTE_MODELS.forEach(model =>
+      it(`model ${model} snapshot`, () =>
+        expect(getPipetteModelSpecs(model)).toMatchSnapshot())
+    )
+  })
+})