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

package/js/__tests__/deckSchemas.test.ts

@@ -0,0 +1,87 @@
+/** Ensure that the deck schema itself functions as intended,
+ *  and that all v4 protocol fixtures will validate */
+import Ajv from 'ajv'
+import path from 'path'
+import glob from 'glob'
+
+import deckSchema from '../../deck/schemas/3.json'
+import deckSchemaV4 from '../../deck/schemas/4.json'
+
+const fixtureGlob = path.join(__dirname, '../../deck/fixtures/3/*.json')
+const defGlob = path.join(__dirname, '../../deck/definitions/3/*.json')
+const defV4Glob = path.join(__dirname, '../../deck/definitions/4/*.json')
+
+const ajv = new Ajv({ allErrors: true, jsonPointers: true })
+
+const validateSchema = ajv.compile(deckSchema)
+const validateSchemaV4 = ajv.compile(deckSchemaV4)
+
+describe('validate v3 deck defs and fixtures', () => {
+  const fixtures = glob.sync(fixtureGlob)
+
+  fixtures.forEach(fixturePath => {
+    const fixtureDef = require(fixturePath)
+
+    it('fixture validates against schema', () => {
+      const valid = validateSchema(fixtureDef)
+      const validationErrors = validateSchema.errors
+
+      if (validationErrors) {
+        console.log(
+          path.parse(fixturePath).base +
+            ' ' +
+            JSON.stringify(validationErrors, null, 4)
+        )
+      }
+
+      expect(validationErrors).toBe(null)
+      expect(valid).toBe(true)
+    })
+  })
+
+  const defs = glob.sync(defGlob)
+
+  defs.forEach(defPath => {
+    const deckDef = require(defPath)
+
+    it('deck validates against v3 schema', () => {
+      const valid = validateSchema(deckDef)
+      const validationErrors = validateSchema.errors
+
+      if (validationErrors) {
+        console.log(
+          path.parse(defPath).base +
+            ' ' +
+            JSON.stringify(validationErrors, null, 4)
+        )
+      }
+
+      expect(validationErrors).toBe(null)
+      expect(valid).toBe(true)
+    })
+  })
+})
+
+describe('validate v4 deck defs', () => {
+  const defs = glob.sync(defV4Glob)
+
+  defs.forEach(defPath => {
+    const deckDef = require(defPath)
+
+    it('deck validates against v4 schema', () => {
+      const valid = validateSchemaV4(deckDef)
+      const validationErrors = validateSchemaV4.errors
+
+      if (validationErrors) {
+        console.log(
+          path.parse(defPath).base +
+            ' ' +
+            JSON.stringify(validationErrors, null, 4)
+        )
+      }
+
+      expect(validationErrors).toBe(null)
+      expect(valid).toBe(true)
+    })
+  })
+})

package/js/__tests__/errors.test.js

@@ -0,0 +1,21 @@
+// tests for error accessors
+
+import { getError } from '../errors'
+
+import errorDefinitions from '@opentrons/shared-data/errors/definitions/1/errors.json'
+
+Object.keys(errorDefinitions.codes).forEach(errorCode =>
+  describe(`error ${errorCode} accessors`, () => {
+    it('should be accessible', () => {
+      const errorData = getError(errorCode)
+      expect(errorData).not.toBeNull()
+      expect(errorCode).toMatch(
+        new RegExp(`^${errorData.category.codePrefix}.*$`)
+      )
+    })
+  })
+)
+
+describe('accessor should handle missing error codes', () =>
+  it('should return null for a missing error', () =>
+    expect(getError('aaaaa this isnt real')).toBeNull()))

package/js/__tests__/getAreSlotsAdjacent.test.ts

@@ -0,0 +1,128 @@
+import {
+  getAreSlotsAdjacent,
+  getAreSlotsHorizontallyAdjacent,
+  getAreSlotsVerticallyAdjacent,
+} from '../helpers'
+
+describe('getAreSlotsHorizontallyAdjacent', () => {
+  it('should return false if a slots are falsey', () => {
+    expect(getAreSlotsHorizontallyAdjacent(null, null)).toBe(false)
+    expect(getAreSlotsHorizontallyAdjacent()).toBe(false)
+    expect(getAreSlotsHorizontallyAdjacent('1')).toBe(false)
+    expect(getAreSlotsHorizontallyAdjacent(null, '1')).toBe(false)
+    expect(getAreSlotsHorizontallyAdjacent('1', null)).toBe(false)
+  })
+  it('should return false if called with a non numerical slot', () => {
+    expect(getAreSlotsHorizontallyAdjacent('1', 'not a numerical slot')).toBe(
+      false
+    )
+  })
+  it('should return false if called with a slot that is larger than the number of slots in the deck def', () => {
+    expect(getAreSlotsHorizontallyAdjacent('1', '12')).toBe(false) // trash slot does not count
+    expect(getAreSlotsHorizontallyAdjacent('1', '13')).toBe(false)
+  })
+  it('should return false if the slots vertically adjacent', () => {
+    expect(getAreSlotsHorizontallyAdjacent('1', '4')).toBe(false)
+    expect(getAreSlotsHorizontallyAdjacent('2', '5')).toBe(false)
+    expect(getAreSlotsHorizontallyAdjacent('3', '6')).toBe(false)
+  })
+  it('should return false if slots are horizontal but separated by a slot', () => {
+    expect(getAreSlotsHorizontallyAdjacent('1', '3')).toBe(false)
+    expect(getAreSlotsHorizontallyAdjacent('4', '6')).toBe(false)
+    expect(getAreSlotsHorizontallyAdjacent('7', '9')).toBe(false)
+  })
+  it('should return true if the slots horizontally adjacent', () => {
+    expect(getAreSlotsHorizontallyAdjacent('1', '2')).toBe(true)
+    expect(getAreSlotsHorizontallyAdjacent('2', '3')).toBe(true)
+    expect(getAreSlotsHorizontallyAdjacent('4', '5')).toBe(true)
+    expect(getAreSlotsHorizontallyAdjacent('5', '6')).toBe(true)
+    expect(getAreSlotsHorizontallyAdjacent('7', '8')).toBe(true)
+    expect(getAreSlotsHorizontallyAdjacent('8', '9')).toBe(true)
+    expect(getAreSlotsHorizontallyAdjacent('8', '9')).toBe(true)
+    expect(getAreSlotsHorizontallyAdjacent('10', '11')).toBe(true)
+  })
+})
+describe('getAreSlotsVerticallyAdjacent', () => {
+  it('should return false if a slots are falsey', () => {
+    expect(getAreSlotsVerticallyAdjacent(null, null)).toBe(false)
+    expect(getAreSlotsVerticallyAdjacent()).toBe(false)
+    expect(getAreSlotsVerticallyAdjacent('1')).toBe(false)
+    expect(getAreSlotsVerticallyAdjacent(null, '1')).toBe(false)
+    expect(getAreSlotsVerticallyAdjacent('1', null)).toBe(false)
+  })
+  it('should return false if called with a non numerical slot', () => {
+    expect(getAreSlotsVerticallyAdjacent('1', 'not a numerical slot')).toBe(
+      false
+    )
+  })
+  it('should return false if called with a slot that is larger than the number of slots in the deck def', () => {
+    expect(getAreSlotsVerticallyAdjacent('1', '12')).toBe(false) // trash slot does not count
+    expect(getAreSlotsVerticallyAdjacent('1', '13')).toBe(false)
+  })
+  it('should return false if the slots horizontally adjacent', () => {
+    expect(getAreSlotsVerticallyAdjacent('1', '2')).toBe(false)
+    expect(getAreSlotsVerticallyAdjacent('2', '3')).toBe(false)
+    expect(getAreSlotsVerticallyAdjacent('4', '5')).toBe(false)
+  })
+  it('should return false if slots are vetical but separated by a slot', () => {
+    expect(getAreSlotsVerticallyAdjacent('1', '7')).toBe(false)
+    expect(getAreSlotsVerticallyAdjacent('2', '8')).toBe(false)
+    expect(getAreSlotsVerticallyAdjacent('3', '9')).toBe(false)
+  })
+  it('should return true if the slots vertically adjacent', () => {
+    expect(getAreSlotsVerticallyAdjacent('1', '4')).toBe(true)
+    expect(getAreSlotsVerticallyAdjacent('2', '5')).toBe(true)
+    expect(getAreSlotsVerticallyAdjacent('3', '6')).toBe(true)
+    expect(getAreSlotsVerticallyAdjacent('4', '7')).toBe(true)
+    expect(getAreSlotsVerticallyAdjacent('5', '8')).toBe(true)
+    expect(getAreSlotsVerticallyAdjacent('6', '9')).toBe(true)
+    expect(getAreSlotsVerticallyAdjacent('7', '10')).toBe(true)
+    expect(getAreSlotsVerticallyAdjacent('8', '11')).toBe(true)
+  })
+})
+describe('getAreSlotsAdjacent', () => {
+  it('should return false if a slots are falsey', () => {
+    expect(getAreSlotsAdjacent(null, null)).toBe(false)
+    expect(getAreSlotsAdjacent()).toBe(false)
+    expect(getAreSlotsAdjacent('1')).toBe(false)
+    expect(getAreSlotsAdjacent(null, '1')).toBe(false)
+    expect(getAreSlotsAdjacent('1', null)).toBe(false)
+  })
+  it('should return false if called with a non numerical slot', () => {
+    expect(getAreSlotsAdjacent('1', 'not a numerical slot')).toBe(false)
+  })
+  it('should return false if called with a slot that is larger than the number of slots in the deck def', () => {
+    expect(getAreSlotsAdjacent('1', '12')).toBe(false) // trash slot does not count
+    expect(getAreSlotsAdjacent('1', '13')).toBe(false)
+  })
+  it('should return false if slots are horizontal but separated by a slot', () => {
+    expect(getAreSlotsHorizontallyAdjacent('1', '3')).toBe(false)
+    expect(getAreSlotsHorizontallyAdjacent('4', '6')).toBe(false)
+    expect(getAreSlotsHorizontallyAdjacent('7', '9')).toBe(false)
+  })
+  it('should return false if slots are vetical but separated by a slot', () => {
+    expect(getAreSlotsAdjacent('1', '7')).toBe(false)
+    expect(getAreSlotsAdjacent('2', '8')).toBe(false)
+    expect(getAreSlotsAdjacent('3', '9')).toBe(false)
+  })
+  it('should return true if the slots adjacent', () => {
+    // horizontally
+    expect(getAreSlotsHorizontallyAdjacent('1', '2')).toBe(true)
+    expect(getAreSlotsHorizontallyAdjacent('2', '3')).toBe(true)
+    expect(getAreSlotsHorizontallyAdjacent('4', '5')).toBe(true)
+    expect(getAreSlotsHorizontallyAdjacent('5', '6')).toBe(true)
+    expect(getAreSlotsHorizontallyAdjacent('7', '8')).toBe(true)
+    expect(getAreSlotsHorizontallyAdjacent('8', '9')).toBe(true)
+    expect(getAreSlotsHorizontallyAdjacent('8', '9')).toBe(true)
+    expect(getAreSlotsHorizontallyAdjacent('10', '11')).toBe(true)
+    // vertically
+    expect(getAreSlotsAdjacent('1', '4')).toBe(true)
+    expect(getAreSlotsAdjacent('2', '5')).toBe(true)
+    expect(getAreSlotsAdjacent('3', '6')).toBe(true)
+    expect(getAreSlotsAdjacent('4', '7')).toBe(true)
+    expect(getAreSlotsAdjacent('5', '8')).toBe(true)
+    expect(getAreSlotsAdjacent('6', '9')).toBe(true)
+    expect(getAreSlotsAdjacent('7', '10')).toBe(true)
+    expect(getAreSlotsAdjacent('8', '11')).toBe(true)
+  })
+})

package/js/__tests__/getWellNamePerMultiTip.test.ts

@@ -0,0 +1,162 @@
+import fixture_trash from '@opentrons/shared-data/labware/fixtures/2/fixture_trash.json'
+import fixture_96_plate from '@opentrons/shared-data/labware/fixtures/2/fixture_96_plate.json'
+import fixture_384_plate from '@opentrons/shared-data/labware/fixtures/2/fixture_384_plate.json'
+import fixture_12_trough from '@opentrons/shared-data/labware/fixtures/2/fixture_12_trough.json'
+import fixture_24_tuberack from '@opentrons/shared-data/labware/fixtures/2/fixture_24_tuberack.json'
+
+import { getWellNamePerMultiTip } from '../helpers/getWellNamePerMultiTip'
+
+import type { LabwareDefinition2 } from '../types'
+
+const fixtureTrash = fixture_trash as LabwareDefinition2
+const fixture96Plate = fixture_96_plate as LabwareDefinition2
+const fixture384Plate = fixture_384_plate as LabwareDefinition2
+const fixture12Trough = fixture_12_trough as LabwareDefinition2
+const fixture24Tuberack = fixture_24_tuberack as LabwareDefinition2
+const EIGHT_CHANNEL = 8
+
+describe('96 plate', () => {
+  const labware = fixture96Plate
+
+  it('A1 => column 1', () => {
+    expect(getWellNamePerMultiTip(labware, 'A1', EIGHT_CHANNEL)).toEqual([
+      'A1',
+      'B1',
+      'C1',
+      'D1',
+      'E1',
+      'F1',
+      'G1',
+      'H1',
+    ])
+  })
+
+  it('A2 => column 2', () => {
+    expect(getWellNamePerMultiTip(labware, 'A2', EIGHT_CHANNEL)).toEqual([
+      'A2',
+      'B2',
+      'C2',
+      'D2',
+      'E2',
+      'F2',
+      'G2',
+      'H2',
+    ])
+  })
+
+  it('B1 => null (cannot access with 8-channel)', () => {
+    expect(getWellNamePerMultiTip(labware, 'B1', EIGHT_CHANNEL)).toEqual(null)
+  })
+})
+
+describe('384 plate', () => {
+  const labware = fixture384Plate
+
+  it('A1 => column 1 ACEGIKMO', () => {
+    expect(getWellNamePerMultiTip(labware, 'A1', EIGHT_CHANNEL)).toEqual([
+      'A1',
+      'C1',
+      'E1',
+      'G1',
+      'I1',
+      'K1',
+      'M1',
+      'O1',
+    ])
+  })
+
+  it('A2 => column 2 ACEGIKMO', () => {
+    expect(getWellNamePerMultiTip(labware, 'A2', EIGHT_CHANNEL)).toEqual([
+      'A2',
+      'C2',
+      'E2',
+      'G2',
+      'I2',
+      'K2',
+      'M2',
+      'O2',
+    ])
+  })
+
+  it('B1 => column 1 BDFHJLNP', () => {
+    expect(getWellNamePerMultiTip(labware, 'B1', EIGHT_CHANNEL)).toEqual([
+      'B1',
+      'D1',
+      'F1',
+      'H1',
+      'J1',
+      'L1',
+      'N1',
+      'P1',
+    ])
+  })
+
+  it('C1 => null (cannot access with 8-channel)', () => {
+    expect(getWellNamePerMultiTip(labware, 'C1', EIGHT_CHANNEL)).toEqual(null)
+  })
+})
+
+describe('Fixed trash', () => {
+  const labware = fixtureTrash
+
+  it('A1 => all tips in A1', () => {
+    expect(getWellNamePerMultiTip(labware, 'A1', EIGHT_CHANNEL)).toEqual([
+      'A1',
+      'A1',
+      'A1',
+      'A1',
+      'A1',
+      'A1',
+      'A1',
+      'A1',
+    ])
+  })
+
+  it('A2 => null (well does not exist)', () => {
+    expect(getWellNamePerMultiTip(labware, 'A2', EIGHT_CHANNEL)).toEqual(null)
+  })
+})
+
+describe('tube rack 2mL', () => {
+  const labware = fixture24Tuberack
+
+  it('tube rack 2mL not accessible by 8-channel (return null)', () => {
+    ;['A1', 'A2', 'B1', 'B2'].forEach(well => {
+      expect(getWellNamePerMultiTip(labware, well, EIGHT_CHANNEL)).toEqual(null)
+    })
+  })
+})
+
+describe('12 channel trough', () => {
+  const labware = fixture12Trough
+
+  it('A1 => all tips in A1', () => {
+    expect(getWellNamePerMultiTip(labware, 'A1', EIGHT_CHANNEL)).toEqual([
+      'A1',
+      'A1',
+      'A1',
+      'A1',
+      'A1',
+      'A1',
+      'A1',
+      'A1',
+    ])
+  })
+
+  it('A2 => all tips in A2', () => {
+    expect(getWellNamePerMultiTip(labware, 'A2', EIGHT_CHANNEL)).toEqual([
+      'A2',
+      'A2',
+      'A2',
+      'A2',
+      'A2',
+      'A2',
+      'A2',
+      'A2',
+    ])
+  })
+
+  it('B1 => null (well does not exist)', () => {
+    expect(getWellNamePerMultiTip(labware, 'B1', EIGHT_CHANNEL)).toEqual(null)
+  })
+})

package/js/__tests__/labwareDefQuirks.test.ts

@@ -0,0 +1,38 @@
+import path from 'path'
+import glob from 'glob'
+
+const definitionsGlobPath = path.join(
+  __dirname,
+  '../../labware/definitions/2/**/*.json'
+)
+
+const EXPECTED_VALID_QUIRKS = [
+  'centerMultichannelOnWells',
+  'touchTipDisabled',
+  'fixedTrash',
+  'gripperIncompatible',
+  'tiprackAdapterFor96Channel',
+]
+
+describe('check quirks for all labware defs', () => {
+  const labwarePaths = glob.sync(definitionsGlobPath)
+
+  beforeAll(() => {
+    // Make sure definitions path didn't break, which would give you false positives
+    expect(labwarePaths.length).toBeGreaterThan(0)
+  })
+
+  labwarePaths.forEach(labwarePath => {
+    const defname = path.basename(path.dirname(labwarePath))
+
+    it(`${defname} has valid quirks`, () => {
+      const labwareDef = require(labwarePath)
+
+      const quirks = labwareDef.parameters.quirks || []
+      // we want to test that the quirks in the def are a subset of validQuirks,
+      // whereas arrayContaining tests that the expected value is a subset of
+      // the value under test. Unfortunately that means we have to do it backwards
+      expect(EXPECTED_VALID_QUIRKS).toEqual(expect.arrayContaining(quirks))
+    })
+  })
+})

package/js/__tests__/labwareDefSchemaV1.test.ts

@@ -0,0 +1,82 @@
+import path from 'path'
+import glob from 'glob'
+import Ajv from 'ajv'
+
+import { labwareSchemaV1 } from '../schema'
+import type { LabwareDefinition1 } from '../types'
+
+const DEFINITIONS_GLOB_PATTERN = '../../labware/definitions/1/*.json'
+const GLOB_OPTIONS = { absolute: true, cwd: __dirname }
+
+// JSON Schema defintion & setup
+const ajv = new Ajv({ allErrors: true, jsonPointers: true })
+const validate = ajv.compile(labwareSchemaV1)
+
+describe('test the schema against a minimalist fixture', () => {
+  it('...', () => {
+    const minimalLabwareDef = {
+      metadata: { name: 'test-labware', format: 'trough' },
+      ordering: [['A1']],
+      wells: {
+        A1: {
+          depth: 40,
+          height: 40,
+          length: 70,
+          'total-liquid-volume': 22000,
+          width: 7,
+          x: 10.84,
+          y: 7.75,
+          z: 0,
+        },
+      },
+    }
+    const valid = validate(minimalLabwareDef)
+    const validationErrors = validate.errors
+
+    expect(validationErrors).toBe(null)
+    expect(valid).toBe(true)
+  })
+
+  it('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 definitions', () => {
+  const labwarePaths = glob.sync(DEFINITIONS_GLOB_PATTERN, GLOB_OPTIONS)
+
+  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).name
+    const labwareDef = require(labwarePath) as LabwareDefinition1
+
+    it(filename, () => {
+      const valid = validate(labwareDef)
+      const validationErrors = validate.errors
+      expect(validationErrors).toBe(null)
+      expect(valid).toBe(true)
+    })
+
+    it(`file name matches metadata.name: ${filename}`, () => {
+      expect(labwareDef.metadata.name).toEqual(filename)
+    })
+  })
+})