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

package/js/__tests__/protocolSchemaV4.test.ts

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

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

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

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

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

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

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

@@ -1,34 +0,0 @@
-// 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}.*$`))
-      })
-    }
-  ))