@opentrons/shared-data 0.0.1-alpha.20 → 0.1.0-alpha.0

package/js/__tests__/deckSchemas.test.ts

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

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

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

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

@@ -1,37 +0,0 @@
-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',
-]
-
-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

@@ -1,82 +0,0 @@
-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)
-    })
-  })
-})