@opentrons/shared-data 0.0.0-alpha.14

package/js/__tests__/protocolSchemaV4.test.ts

@@ -0,0 +1,137 @@
+/** Ensure that protocol schema v4 definition 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 omit from 'lodash/omit'
+
+import protocolSchema from '../../protocol/schemas/4.json'
+import labwareV2Schema from '../../labware/schemas/2.json'
+import simpleV4Fixture from '../../protocol/fixtures/4/simpleV4.json'
+
+const fixturesGlobPath = path.join(
+  __dirname,
+  '../../protocol/fixtures/4/**/*.json'
+)
+
+const protocolFixtures = glob.sync(fixturesGlobPath)
+const ajv = new Ajv({ allErrors: true, jsonPointers: true })
+
+// v4 protocol schema contains reference to v2 labware schema, so give AJV access to it
+ajv.addSchema(labwareV2Schema)
+
+const validateProtocol = ajv.compile(protocolSchema)
+
+describe('validate v4 protocol fixtures under JSON schema', () => {
+  protocolFixtures.forEach(protocolPath => {
+    it(path.basename(protocolPath), () => {
+      const protocol = require(protocolPath)
+
+      const valid = validateProtocol(protocol)
+      const validationErrors = validateProtocol.errors
+
+      if (validationErrors) {
+        console.log(JSON.stringify(validationErrors, null, 4))
+      }
+
+      expect(validationErrors).toBe(null)
+      expect(valid).toBe(true)
+    })
+  })
+})
+
+describe('ensure bad protocol data fails validation', () => {
+  it('$otSharedSchema is required to be "#/protocol/schemas/4"', () => {
+    expect(validateProtocol(omit(simpleV4Fixture, '$otSharedSchema'))).toBe(
+      false
+    )
+    expect(
+      validateProtocol({
+        ...simpleV4Fixture,
+        $otSharedSchema: '#/protocol/schemas/5',
+      })
+    ).toBe(false)
+  })
+
+  it('schemaVersion is required to be 4', () => {
+    expect(validateProtocol(omit(simpleV4Fixture, 'schemaVersion'))).toBe(false)
+    expect(validateProtocol({ ...simpleV4Fixture, schemaVersion: 3 })).toBe(
+      false
+    )
+  })
+
+  it('reject bad values in "pipettes" objects', () => {
+    const badPipettes = {
+      missingKeys: {},
+      missingName: { mount: 'left' },
+      missingMount: { name: 'pipetteName' },
+      badMount: { mount: 'blah', name: 'pipetteName' },
+      hasAdditionalProperties: {
+        mount: 'left',
+        name: 'pipetteName',
+        blah: 'blah',
+      },
+    }
+
+    Object.entries(badPipettes).forEach(([pipetteId, pipette]) => {
+      expect(
+        validateProtocol({
+          ...simpleV4Fixture,
+          pipettes: {
+            ...simpleV4Fixture.pipettes,
+            [pipetteId]: pipette,
+          },
+        })
+      ).toBe(false)
+    })
+  })
+
+  it('reject bad values in "labware" objects', () => {
+    const badLabware = {
+      noSlot: { definitionId: 'defId' },
+      noDefId: { slot: '1' },
+      hasAdditionalProperties: {
+        slot: '1',
+        definitionId: 'defId',
+        blah: 'blah',
+      },
+    }
+
+    Object.entries(badLabware).forEach(([labwareId, labware]) => {
+      expect(
+        validateProtocol({
+          ...simpleV4Fixture,
+          labware: {
+            ...simpleV4Fixture.labware,
+            [labwareId]: labware,
+          },
+        })
+      ).toBe(false)
+    })
+  })
+
+  it('reject bad values in "modules" objects', () => {
+    const badModules = {
+      badModuleType: { slot: '1', moduleType: 'fake' },
+      noSlot: { moduleType: 'thermocycler' },
+      noModuleType: { slot: '1' },
+      hasAdditionalProperties: {
+        slot: '1',
+        moduleType: 'thermocycler',
+        blah: 'blah',
+      },
+    }
+
+    Object.entries(badModules).forEach(([moduleId, module]) => {
+      expect(
+        validateProtocol({
+          ...simpleV4Fixture,
+          modules: {
+            ...simpleV4Fixture.modules,
+            [moduleId]: module,
+          },
+        })
+      ).toBe(false)
+    })
+  })
+})

package/js/__tests__/protocolSchemaV5.test.ts

@@ -0,0 +1,137 @@
+/** Ensure that protocol schema v5 definition itself functions as intended,
+ *  and that all v5 protocol fixtures will validate */
+import Ajv from 'ajv'
+import path from 'path'
+import glob from 'glob'
+import omit from 'lodash/omit'
+
+import protocolSchema from '../../protocol/schemas/5.json'
+import labwareV2Schema from '../../labware/schemas/2.json'
+import simpleV5Fixture from '../../protocol/fixtures/5/simpleV5.json'
+
+const fixturesGlobPath = path.join(
+  __dirname,
+  '../../protocol/fixtures/5/**/*.json'
+)
+
+const protocolFixtures = glob.sync(fixturesGlobPath)
+const ajv = new Ajv({ allErrors: true, jsonPointers: true })
+
+// v5 protocol schema contains reference to v2 labware schema, so give AJV access to it
+ajv.addSchema(labwareV2Schema)
+
+const validateProtocol = ajv.compile(protocolSchema)
+
+describe('validate v5 protocol fixtures under JSON schema', () => {
+  protocolFixtures.forEach(protocolPath => {
+    it(path.basename(protocolPath), () => {
+      const protocol = require(protocolPath)
+
+      const valid = validateProtocol(protocol)
+      const validationErrors = validateProtocol.errors
+
+      if (validationErrors) {
+        console.log(JSON.stringify(validationErrors, null, 4))
+      }
+
+      expect(validationErrors).toBe(null)
+      expect(valid).toBe(true)
+    })
+  })
+})
+
+describe('ensure bad protocol data fails validation', () => {
+  it('$otSharedSchema is required to be "#/protocol/schemas/5"', () => {
+    expect(validateProtocol(omit(simpleV5Fixture, '$otSharedSchema'))).toBe(
+      false
+    )
+    expect(
+      validateProtocol({
+        ...simpleV5Fixture,
+        $otSharedSchema: '#/protocol/schemas/6',
+      })
+    ).toBe(false)
+  })
+
+  it('schemaVersion is required to be 5', () => {
+    expect(validateProtocol(omit(simpleV5Fixture, 'schemaVersion'))).toBe(false)
+    expect(validateProtocol({ ...simpleV5Fixture, schemaVersion: 3 })).toBe(
+      false
+    )
+  })
+
+  it('reject bad values in "pipettes" objects', () => {
+    const badPipettes = {
+      missingKeys: {},
+      missingName: { mount: 'left' },
+      missingMount: { name: 'pipetteName' },
+      badMount: { mount: 'blah', name: 'pipetteName' },
+      hasAdditionalProperties: {
+        mount: 'left',
+        name: 'pipetteName',
+        blah: 'blah',
+      },
+    }
+
+    Object.entries(badPipettes).forEach(([pipetteId, pipette]) => {
+      expect(
+        validateProtocol({
+          ...simpleV5Fixture,
+          pipettes: {
+            ...simpleV5Fixture.pipettes,
+            [pipetteId]: pipette,
+          },
+        })
+      ).toBe(false)
+    })
+  })
+
+  it('reject bad values in "labware" objects', () => {
+    const badLabware = {
+      noSlot: { definitionId: 'defId' },
+      noDefId: { slot: '1' },
+      hasAdditionalProperties: {
+        slot: '1',
+        definitionId: 'defId',
+        blah: 'blah',
+      },
+    }
+
+    Object.entries(badLabware).forEach(([labwareId, labware]) => {
+      expect(
+        validateProtocol({
+          ...simpleV5Fixture,
+          labware: {
+            ...simpleV5Fixture.labware,
+            [labwareId]: labware,
+          },
+        })
+      ).toBe(false)
+    })
+  })
+
+  it('reject bad values in "modules" objects', () => {
+    const badModules = {
+      badModuleType: { slot: '1', moduleType: 'fake' },
+      noSlot: { moduleType: 'thermocycler' },
+      noModuleType: { slot: '1' },
+      hasAdditionalProperties: {
+        slot: '1',
+        moduleType: 'thermocycler',
+        blah: 'blah',
+      },
+    }
+
+    Object.entries(badModules).forEach(([moduleId, module]) => {
+      expect(
+        validateProtocol({
+          ...simpleV5Fixture,
+          modules: {
+            ...simpleV5Fixture.modules,
+            [moduleId]: module,
+          },
+        })
+      ).toBe(false)
+    })
+  })
+})

package/js/__tests__/protocolSchemaV6.test.ts

@@ -0,0 +1,132 @@
+/** Ensure that protocol schema v6 definition itself functions as intended,
+ *  and that all v6 protocol fixtures will validate */
+import Ajv from 'ajv'
+import path from 'path'
+import glob from 'glob'
+import omit from 'lodash/omit'
+
+import protocolSchema from '../../protocol/schemas/6.json'
+import labwareV2Schema from '../../labware/schemas/2.json'
+import simpleV6Fixture from '../../protocol/fixtures/6/simpleV6.json'
+
+const fixturesGlobPath = path.join(
+  __dirname,
+  '../../protocol/fixtures/6/**/*.json'
+)
+
+const protocolFixtures = glob.sync(fixturesGlobPath)
+const ajv = new Ajv({ allErrors: true, jsonPointers: true })
+
+// v6 protocol schema contains reference to v2 labware schema, so give AJV access to it
+ajv.addSchema(labwareV2Schema)
+
+const validateProtocol = ajv.compile(protocolSchema)
+
+describe('validate v6 protocol fixtures under JSON schema', () => {
+  protocolFixtures.forEach(protocolPath => {
+    it(path.basename(protocolPath), () => {
+      const protocol = require(protocolPath)
+
+      const valid = validateProtocol(protocol)
+      const validationErrors = validateProtocol.errors
+
+      if (validationErrors) {
+        console.log(JSON.stringify(validationErrors, null, 4))
+      }
+
+      expect(validationErrors).toBe(null)
+      expect(valid).toBe(true)
+    })
+  })
+})
+
+describe('ensure bad protocol data fails validation', () => {
+  it('$otSharedSchema is required to be "#/protocol/schemas/6"', () => {
+    expect(validateProtocol(omit(simpleV6Fixture, '$otSharedSchema'))).toBe(
+      false
+    )
+    expect(
+      validateProtocol({
+        ...simpleV6Fixture,
+        $otSharedSchema: '#/protocol/schemas/3',
+      })
+    ).toBe(false)
+  })
+
+  it('schemaVersion is required to be 6', () => {
+    expect(validateProtocol(omit(simpleV6Fixture, 'schemaVersion'))).toBe(false)
+    expect(validateProtocol({ ...simpleV6Fixture, schemaVersion: 3 })).toBe(
+      false
+    )
+  })
+
+  it('reject bad values in "pipettes" objects', () => {
+    const badPipettes = {
+      missingKeys: {},
+      missingName: { mount: 'left' },
+      hasAdditionalProperties: {
+        mount: 'left',
+        name: 'pipetteName',
+        blah: 'blah',
+      },
+    }
+
+    Object.entries(badPipettes).forEach(([pipetteId, pipette]) => {
+      expect(
+        validateProtocol({
+          ...simpleV6Fixture,
+          pipettes: {
+            ...simpleV6Fixture.pipettes,
+            [pipetteId]: pipette,
+          },
+        })
+      ).toBe(false)
+    })
+  })
+
+  it('reject bad values in "labware" objects', () => {
+    const badLabware = {
+      noDefId: { displayName: 'myLabware' },
+      hasAdditionalProperties: {
+        slot: '1',
+        definitionId: 'defId',
+        blah: 'blah',
+      },
+    }
+
+    Object.entries(badLabware).forEach(([labwareId, labware]) => {
+      expect(
+        validateProtocol({
+          ...simpleV6Fixture,
+          labware: {
+            ...simpleV6Fixture.labware,
+            [labwareId]: labware,
+          },
+        })
+      ).toBe(false)
+    })
+  })
+
+  it('reject bad values in "modules" objects', () => {
+    const badModules = {
+      noModel: { moduleType: 'thermocycler' },
+      hasAdditionalProperties: {
+        model: 'thermocycler',
+        slot: '1',
+        blah: 'blah',
+      },
+    }
+
+    Object.entries(badModules).forEach(([moduleId, module]) => {
+      expect(
+        validateProtocol({
+          ...simpleV6Fixture,
+          modules: {
+            ...simpleV6Fixture.modules,
+            [moduleId]: module,
+          },
+        })
+      ).toBe(false)
+    })
+  })
+})

package/js/__tests__/protocolSchemaV7.test.ts

@@ -0,0 +1,64 @@
+/** Ensure that protocol schema v7 definition itself functions as intended,
+ *  and that all v7 protocol fixtures will validate */
+import Ajv from 'ajv'
+import path from 'path'
+import glob from 'glob'
+import omit from 'lodash/omit'
+
+import protocolSchema from '../../protocol/schemas/7.json'
+import labwareV2Schema from '../../labware/schemas/2.json'
+import commandV7Schema from '../../command/schemas/7.json'
+import simpleV7Fixture from '../../protocol/fixtures/7/simpleV7.json'
+
+const fixturesGlobPath = path.join(
+  __dirname,
+  '../../protocol/fixtures/7/**/*.json'
+)
+
+const protocolFixtures = glob.sync(fixturesGlobPath)
+const ajv = new Ajv({ allErrors: true, jsonPointers: true })
+
+// v7 protocol schema contains reference to v2 labware schema, and v7 command schema, so give AJV access to it
+ajv.addSchema(labwareV2Schema)
+ajv.addSchema(commandV7Schema)
+
+const validateProtocol = ajv.compile(protocolSchema)
+
+describe('validate v7 protocol fixtures under JSON schema', () => {
+  protocolFixtures.forEach(protocolPath => {
+    it(path.basename(protocolPath), () => {
+      const protocol = require(protocolPath)
+
+      const valid = validateProtocol(protocol)
+      const validationErrors = validateProtocol.errors
+
+      if (validationErrors) {
+        console.log(JSON.stringify(validationErrors, null, 4))
+      }
+
+      expect(validationErrors).toBe(null)
+      expect(valid).toBe(true)
+    })
+  })
+})
+
+describe('ensure bad protocol data fails validation', () => {
+  it('$otSharedSchema is required to be "#/protocol/schemas/7"', () => {
+    expect(validateProtocol(omit(simpleV7Fixture, '$otSharedSchema'))).toBe(
+      false
+    )
+    expect(
+      validateProtocol({
+        ...simpleV7Fixture,
+        $otSharedSchema: '#/protocol/schemas/3',
+      })
+    ).toBe(false)
+  })
+
+  it('schemaVersion is required to be 7', () => {
+    expect(validateProtocol(omit(simpleV7Fixture, 'schemaVersion'))).toBe(false)
+    expect(validateProtocol({ ...simpleV7Fixture, schemaVersion: 3 })).toBe(
+      false
+    )
+  })
+})

package/js/__tests__/protocolValidation.test.ts

@@ -0,0 +1,83 @@
+/** Ensure that we can parse all our fixture json protocols, which also
+ * ensures that our protocol schemas are correct */
+import path from 'path'
+import glob from 'glob'
+import { validate } from '../protocols'
+import { omit } from 'lodash'
+
+const relRoot = path.join(__dirname, '../../protocol/fixtures/')
+
+const protocolFixtures4 = glob.sync(
+  path.join(__dirname, '../../protocol/fixtures/4/*.json')
+)
+const protocolFixtures5 = glob.sync(
+  path.join(__dirname, '../../protocol/fixtures/5/*.json')
+)
+const protocolFixtures6 = glob.sync(
+  path.join(__dirname, '../../protocol/fixtures/6/*.json')
+)
+const protocolFixtures7 = glob.sync(
+  path.join(__dirname, '../../protocol/fixtures/7/*.json')
+)
+const protocolFixtures8 = glob.sync(
+  path.join(__dirname, '../../protocol/fixtures/8/*.json')
+)
+
+describe('check that all fixtures can validate', () => {
+  const protocolPaths = [
+    ...protocolFixtures4,
+    ...protocolFixtures5,
+    ...protocolFixtures6,
+    ...protocolFixtures7,
+    ...protocolFixtures8,
+  ]
+  protocolPaths.forEach(protocolPath =>
+    it(`${path.relative(relRoot, protocolPath)}`, () => {
+      const protocol = require(protocolPath)
+      return validate(protocol)
+    })
+  )
+})
+
+describe('test that mutating v8 fixtures causes failure', () => {
+  const base = require('../../protocol/fixtures/8/simpleV8.json')
+  it('should fail validation with no schema spec', () => {
+    const mangled = omit(base, '$otSharedSchema')
+    expect.assertions(1)
+    return expect(validate(mangled)).rejects.toMatchObject([
+      { keyword: 'Invalid protocol schema requested' },
+    ])
+  })
+  it('should fail validation with a schema spec from the future', () => {
+    const mangled = { ...base, $otSharedSchema: 'opentronsProtocolSchemaV9' }
+    expect.assertions(1)
+    return expect(validate(mangled)).rejects.toMatchObject([
+      { keyword: 'Invalid protocol schema requested' },
+    ])
+  })
+  it('should fail validation with a mangled schema spec', () => {
+    const mangled = { ...base, $otSharedSchema: 'asdhasda' }
+    expect.assertions(1)
+    return expect(validate(mangled)).rejects.toMatchObject([
+      { keyword: 'Invalid protocol schema requested' },
+    ])
+  })
+  it('should fail validation with a mangled command schema spec', () => {
+    const mangled = { ...base, commandSchemaId: 'asdasd' }
+    return expect(validate(mangled)).rejects.toMatchObject([
+      { keyword: 'Invalid command schema requested' },
+    ])
+  })
+  it('should fail validation with a mangled liquid schema spec', () => {
+    const mangled = { ...base, liquidSchemaId: 'asdhasdas' }
+    return expect(validate(mangled)).rejects.toMatchObject([
+      { keyword: 'Invalid liquid schema requested' },
+    ])
+  })
+  it('should fail validation with a mangled command annotation schema spec', () => {
+    const mangled = { ...base, commandAnnotationSchemaId: 'asdasd' }
+    return expect(validate(mangled)).rejects.toMatchObject([
+      { keyword: 'Invalid command annotation schema requested' },
+    ])
+  })
+})

package/js/__tests__/sortWells.test.ts

@@ -0,0 +1,40 @@
+import { sortWells } from '../helpers'
+
+describe('sortWells', () => {
+  it('single letters', () => {
+    const input = ['A12', 'A2', 'B1', 'B12', 'A1']
+    const expected = ['A1', 'B1', 'A2', 'A12', 'B12']
+    const result = [...input].sort(sortWells)
+    expect(result).toEqual(expected)
+  })
+
+  // just in case we get a 1536-well plate
+  it('double letters', () => {
+    const input = [
+      'AB12',
+      'A12',
+      'B12',
+      'Z12',
+      'AA12',
+      'AB1',
+      'Z1',
+      'A1',
+      'B1',
+      'AA1',
+    ]
+    const expected = [
+      'A1',
+      'B1',
+      'Z1',
+      'AA1',
+      'AB1',
+      'A12',
+      'B12',
+      'Z12',
+      'AA12',
+      'AB12',
+    ]
+    const result = [...input].sort(sortWells)
+    expect(result).toEqual(expected)
+  })
+})

package/js/__tests__/splitWellsOnColumn.test.ts

@@ -0,0 +1,21 @@
+import { splitWellsOnColumn } from '../helpers'
+
+describe('test splitWellsOnColumn', () => {
+  it('empty array', () => {
+    expect(splitWellsOnColumn([])).toEqual([])
+  })
+
+  it('one value', () => {
+    expect(splitWellsOnColumn(['A1'])).toEqual([['A1']])
+  })
+
+  it('sort multi-digit wels', () => {
+    expect(splitWellsOnColumn(['A1', 'B2', 'C2', 'D3', 'X10', 'X11'])).toEqual([
+      ['A1'],
+      ['B2', 'C2'],
+      ['D3'],
+      ['X10'],
+      ['X11'],
+    ])
+  })
+})

package/js/__tests__/validateErrors.test.js

@@ -0,0 +1,34 @@
+// Tests for error data validation
+
+import Ajv from 'ajv'
+
+import errorDefinitions from '@opentrons/shared-data/errors/definitions/1/errors.json'
+import errorSchema from '@opentrons/shared-data/errors/schemas/1.json'
+
+describe('error data should match error schema', () => {
+  it('error schema should match', () => {
+    const ajv = new Ajv({ allErrors: true })
+    const validator = ajv.compile(errorSchema)
+    const valid = validator(errorDefinitions)
+    const validationFailures = validator.errors
+    if (validationFailures) {
+      console.log(
+        'errors.json does not follow its schema',
+        JSON.stringify(validationFailures, null, 4)
+      )
+    }
+    expect(valid).toBe(true)
+    expect(validationFailures).toBeNull()
+  })
+})
+
+describe('error code unschemad requirements should match', () =>
+  Object.entries(errorDefinitions.codes).forEach(
+    ([errorCode, { category: errorCategory }]) => {
+      it(`error code ${errorCode} category is correct`, () => {
+        const categoryObj = errorDefinitions.categories[errorCategory] ?? null
+        expect(categoryObj).not.toBeNull()
+        expect(errorCode).toMatch(new RegExp(`^${categoryObj.codePrefix}.*$`))
+      })
+    }
+  ))