@toa.io/norm 0.2.1-dev.1

package/test/component/expand.fixtures.js

@@ -0,0 +1,137 @@
+'use strict'
+
+const source = {
+  entity: {
+    schema: {
+      properties: {
+        foo: 'string'
+      }
+    },
+    storage: 'mongodb'
+  },
+  bridge: 'node',
+  operations: {
+    add: {
+      bridge: 'node',
+      bindings: ['amqp'],
+      input: {
+        properties: {
+          foo: 'integer',
+          bar: {
+            type: 'array',
+            items: {
+              properties: {
+                baz: 'string'
+              }
+            }
+          }
+        }
+      },
+      output: {
+        properties: {
+          foo: 'integer',
+          bar: {
+            type: 'array',
+            items: {
+              properties: {
+                baz: 'string'
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  events: {
+    happened: {
+      bridge: 'node',
+      binding: 'amqp'
+    }
+  },
+  receivers: {
+    one: 'transit',
+    two: {
+      binding: 'amqp',
+      bridge: 'node',
+      transition: 'transit'
+    }
+  }
+}
+
+const target = {
+  entity: {
+    schema: {
+      type: 'object',
+      properties: {
+        foo: {
+          type: 'string'
+        }
+      }
+    },
+    storage: '@toa.io/storages.mongodb'
+  },
+  bridge: '@toa.io/bridges.node',
+  operations: {
+    add: {
+      bridge: '@toa.io/bridges.node',
+      bindings: ['@toa.io/bindings.amqp'],
+      input: {
+        type: 'object',
+        properties: {
+          foo: {
+            type: 'integer'
+          },
+          bar: {
+            type: 'array',
+            items: {
+              type: 'object',
+              properties: {
+                baz: {
+                  type: 'string'
+                }
+              }
+            }
+          }
+        }
+      },
+      output: {
+        type: 'object',
+        properties: {
+          foo: {
+            type: 'integer'
+          },
+          bar: {
+            type: 'array',
+            items: {
+              type: 'object',
+              properties: {
+                baz: {
+                  type: 'string'
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  events: {
+    happened: {
+      bridge: '@toa.io/bridges.node',
+      binding: '@toa.io/bindings.amqp'
+    }
+  },
+  receivers: {
+    one: {
+      transition: 'transit'
+    },
+    two: {
+      bridge: '@toa.io/bridges.node',
+      binding: '@toa.io/bindings.amqp',
+      transition: 'transit'
+    }
+  }
+}
+
+exports.source = source
+exports.target = target

package/test/component/expand.test.js

@@ -0,0 +1,17 @@
+'use strict'
+
+const clone = require('clone-deep')
+
+const { expand } = require('../../src/.component')
+const fixtures = require('./expand.fixtures')
+
+let source
+
+beforeEach(() => {
+  source = clone(fixtures.source)
+})
+
+it('should expand', () => {
+  expand(source)
+  expect(source).toMatchObject(fixtures.target)
+})

package/test/component/normalize.fixtures.js

@@ -0,0 +1,22 @@
+'use strict'
+
+const { generate } = require('randomstring')
+
+const operations = {
+  path: __dirname,
+  bindings: ['foo', 'bar'],
+  'bindings@local': ['foo'],
+  operations: {
+    add: {}
+  },
+  extensions: {
+    '@toa.io/extensions.exposition': {
+      ['/' + generate()]: ['add']
+    },
+    './dummies/extension': {
+      ok: true
+    }
+  }
+}
+
+exports.operations = operations

package/test/component/normalize.test.js

@@ -0,0 +1,45 @@
+'use strict'
+
+const { dirname } = require('node:path')
+const clone = require('clone-deep')
+
+const { normalize } = require('../../src/.component')
+const fixtures = require('./normalize.fixtures')
+
+let manifest
+
+beforeEach(() => {
+  manifest = clone(fixtures.operations)
+})
+
+describe('environment', () => {
+  it('should convolve with environment argument', () => {
+    normalize(manifest, 'local')
+    expect(manifest.operations.add.bindings).toStrictEqual(['foo'])
+  })
+})
+
+describe('operations', () => {
+  it('should set default bindings', () => {
+    normalize(manifest)
+
+    expect(manifest.operations.add.bindings).toStrictEqual(manifest.bindings)
+  })
+})
+
+describe('extensions', () => {
+  it('should resolve absolute references', () => {
+    const origins = manifest.extensions['@toa.io/extensions.origins']
+    const path = dirname(require.resolve('@toa.io/extensions.origins/package.json'))
+
+    normalize(manifest)
+
+    expect(manifest.extensions[path]).toStrictEqual(origins)
+  })
+
+  it('should throw if manifest is undefined', () => {
+    manifest.extensions['./dummies/extension'].ok = false
+
+    expect(() => normalize(manifest)).toThrow(/didn't return manifest/)
+  })
+})

package/test/component/validate.fixtures.js

@@ -0,0 +1,58 @@
+'use strict'
+
+const ok = {
+  namespace: 'foo',
+  name: 'bar',
+  entity: {
+    storage: 'whatever',
+    schema: {
+      properties: {
+        name: {
+          type: 'string',
+          minLength: 1,
+          maxLength: 128
+        }
+      }
+    }
+  },
+  operations: {
+    get: {
+      type: 'observation',
+      scope: 'objects',
+      bridge: 'whatever',
+      bindings: ['@toa.io/bindings.http']
+    },
+    add: {
+      type: 'transition',
+      concurrency: 'none',
+      scope: 'object',
+      bridge: 'whatever',
+      bindings: ['@toa.io/bindings.http', '@toa.io/bindings.amqp']
+    },
+    set: {
+      type: 'assignment',
+      scope: 'changeset',
+      bridge: 'whatever',
+      bindings: ['@toa.io/bindings.http', '@toa.io/bindings.amqp']
+    }
+  },
+  events: {
+    created: {
+      bridge: 'whatever',
+      path: '/somewhere',
+      conditioned: true,
+      subjective: false,
+      binding: '@toa.io/bindings.amqp'
+    }
+  },
+  receivers: {
+    'foo.bar.happened': {
+      transition: 'add',
+      bridge: 'whatever',
+      binding: 'amqp',
+      path: '/somewhere'
+    }
+  }
+}
+
+exports.ok = ok

package/test/component/validate.test.js

@@ -0,0 +1,250 @@
+// noinspection JSUnresolvedVariable
+
+'use strict'
+
+const clone = require('clone-deep')
+
+const { validate } = require('../../src/.component')
+const fixtures = require('./validate.fixtures')
+
+let manifest
+
+beforeEach(() => {
+  manifest = clone(fixtures.ok)
+})
+
+it('should be ok', () => {
+  expect(() => validate(manifest)).not.toThrow()
+})
+
+it('should provide error', () => {
+  manifest.foo = 'bar'
+
+  expect(() => validate(manifest)).toThrow(/must NOT have additional property/)
+})
+
+it('should not have additional properties', () => {
+  manifest.foo = 'bar'
+
+  expect(() => validate(manifest)).toThrow(/must NOT have additional property/)
+})
+
+describe('namespace', () => {
+  it('should match token pattern', () => {
+    manifest.namespace = '1'
+    expect(() => validate(manifest)).toThrow(/must match pattern/)
+
+    manifest.namespace = 'foo_'
+    expect(() => validate(manifest)).toThrow(/must match pattern/)
+
+    manifest.namespace = 'foo-'
+    expect(() => validate(manifest)).toThrow(/must match pattern/)
+
+    manifest.namespace = 'foo-BAR'
+    expect(() => validate(manifest)).not.toThrow()
+
+    manifest.namespace = 'foo_bar'
+    expect(() => validate(manifest)).not.toThrow()
+
+    manifest.namespace = 'FooBar12'
+    expect(() => validate(manifest)).not.toThrow()
+  })
+
+  it('should forbid \'system\' namespace', () => {
+    manifest.namespace = 'system'
+    expect(() => validate(manifest)).toThrow(/must NOT be valid/)
+  })
+
+  it('should forbid \'default\' namespace', () => {
+    manifest.namespace = 'default'
+    expect(() => validate(manifest)).toThrow(/must NOT be valid/)
+  })
+})
+
+describe('name', () => {
+  it('should be optional', () => {
+    delete manifest.name
+    expect(() => validate(manifest)).not.toThrow()
+  })
+})
+
+describe('entity', () => {
+  it('should be optional', () => {
+    delete manifest.entity
+    expect(() => validate(manifest)).not.toThrow()
+  })
+
+  it('should be object', () => {
+    manifest.entity = 'foo'
+    expect(() => validate(manifest)).toThrow(/must be object/)
+  })
+
+  it('should not have additional properties', () => {
+    manifest.entity.foo = 'bar'
+    expect(() => validate(manifest)).toThrow(/must NOT have additional property/)
+  })
+
+  describe('schema', () => {
+    it('should be required', () => {
+      delete manifest.entity.schema
+      expect(() => validate(manifest)).toThrow(/must have required property/)
+    })
+
+    it('should be JSON schema object', () => {
+      manifest.entity.schema = { properties: { foo: 'bar' } }
+      expect(() => validate(manifest)).toThrow()
+    })
+
+    it('should be JSON schema object of type object', () => {
+      manifest.entity.schema = { type: 'integer' }
+      expect(() => validate(manifest)).toThrow(/must be equal to constant 'object'/)
+
+      manifest.entity.schema = {}
+      validate(manifest)
+      expect(manifest.entity.schema.type).toBe('object')
+    })
+
+    it('should forbid additional properties', () => {
+      manifest.entity.schema = { additionalProperties: true }
+      expect(() => validate(manifest)).toThrow(/must be equal to constant 'false'/)
+
+      manifest.entity.schema = {}
+      validate(manifest)
+      expect(manifest.entity.schema.additionalProperties).toBe(false)
+    })
+
+    it('should have property names matching token pattern', () => {
+      manifest.entity.schema.properties._foo = { type: 'string' }
+      expect(() => validate(manifest)).toThrow(/pattern/)
+    })
+
+    it('should allow default id', () => {
+      manifest.entity.schema.properties.id = { type: 'string', pattern: '^[a-fA-F0-9]+$' }
+      expect(() => validate(manifest)).not.toThrow()
+    })
+  })
+
+  describe('initialized', () => {
+    it('should provide default', () => {
+      expect(() => validate(manifest)).not.toThrow()
+      expect(manifest.entity.initialized).toBe(false)
+    })
+  })
+})
+
+describe('bindings', () => {
+  it('should be array of unique strings', () => {
+    manifest.bindings = 'oops'
+    expect(() => validate(manifest)).toThrow(/must be array/)
+
+    manifest.bindings = ['oops', 'oops']
+    expect(() => validate(manifest)).toThrow(/duplicate items/)
+
+    manifest.bindings = ['oops', {}]
+    expect(() => validate(manifest)).toThrow(/must be string/)
+  })
+
+  it('should forbid explicit loop', () => {
+    manifest.bindings = ['@toa.io/bindings.loop']
+    expect(() => validate(manifest)).toThrow(/must NOT be valid/)
+  })
+})
+
+describe('operations', () => {
+  it('should be object', () => {
+    manifest.operations.get = 'bar'
+    expect(() => validate(manifest)).toThrow(/must be object/)
+  })
+
+  it('should not have additional properties', () => {
+    manifest.operations.get.foo = 'bar'
+    expect(() => validate(manifest)).toThrow(/additional property/)
+  })
+
+  it('should have type (transition or observation)', () => {
+    delete manifest.operations.get.type
+    expect(() => validate(manifest)).toThrow()
+
+    manifest.operations.get.type = 'foo'
+    expect(() => validate(manifest)).toThrow(/one of the allowed values/)
+  })
+
+  it('should forbid explicit loop', () => {
+    manifest.operations.get.bindings = ['@toa.io/bindings.loop']
+    expect(() => validate(manifest)).toThrow(/must NOT be valid/)
+  })
+
+  it('should forbid query: false for observations', () => {
+    manifest.operations.get.query = false
+    expect(() => validate(manifest)).toThrow(/must NOT be valid/)
+  })
+
+  describe('scope', () => {
+    it('should have scope', () => {
+      delete manifest.operations.get.scope
+      expect(() => validate(manifest)).toThrow(/required property/)
+    })
+
+    it('should allow only entity or set for observations', () => {
+      manifest.operations.get.scope = 'changeset'
+      expect(() => validate(manifest)).toThrow(/allowed values/)
+    })
+
+    it('should allow only entity for transitions', () => {
+      manifest.operations.add.scope = 'changeset'
+      expect(() => validate(manifest)).toThrow(/allowed values/)
+
+      manifest.operations.add.scope = 'set'
+      expect(() => validate(manifest)).toThrow(/allowed values/)
+    })
+
+    it('should allow only changeset for assignments', () => {
+      manifest.operations.set.scope = 'changeset'
+      expect(() => validate(manifest)).not.toThrow()
+
+      manifest.operations.set.scope = 'set'
+      expect(() => validate(manifest)).toThrow(/allowed values/)
+    })
+  })
+
+  describe('concurrency', () => {
+    it('should be required for transitions', () => {
+      delete manifest.operations.add.concurrency
+      expect(() => validate(manifest)).toThrow(/required property/)
+    })
+
+    it('should throw for observations, assignments', () => {
+      manifest.operations.get.concurrency = 'none'
+      expect(() => validate(manifest)).toThrow()
+      delete manifest.operations.get.concurrency
+
+      manifest.operations.set.concurrency = 'none'
+      expect(() => validate(manifest)).toThrow()
+    })
+  })
+
+  describe('input, output', () => {
+    it('should be schema', () => {
+      manifest.operations.get.input = { properties: { foo: 'bar' } }
+      expect(() => validate(manifest)).toThrow()
+
+      delete manifest.operations.get.input
+      manifest.operations.get.output = { properties: { foo: 'bar' } }
+      expect(() => validate(manifest)).toThrow()
+    })
+  })
+})
+
+describe('receivers', () => {
+  it('should throw if transition points to undefined transition', () => {
+    manifest.receivers['foo.bar.happened'].transition = 'not-exists'
+
+    expect(() => validate(manifest)).toThrow(/refers to undefined transition/)
+  })
+
+  it('should throw if transition points to non transition', () => {
+    manifest.receivers['foo.bar.happened'].transition = 'get'
+
+    expect(() => validate(manifest)).toThrow(/refers to non-transition/)
+  })
+})

package/test/context/complete.fixtures.js

@@ -0,0 +1,59 @@
+'use strict'
+
+const component = (id) => {
+  const [namespace, name] = id.split('.')
+
+  return {
+    namespace,
+    name,
+    version: '0.0.0',
+    locator: {
+      namespace,
+      name,
+      id,
+      label: `${namespace}-${name}`
+    }
+  }
+}
+
+const context = {
+  runtime: '0.0.0',
+  name: 'test',
+  description: 'context fixture',
+  version: '0.0.0',
+  packages: 'namespaces/**/*',
+  registry: 'localhost:5000',
+  components: [
+    component('a.b'),
+    component('b.a'),
+    component('d.a'),
+    component('d.b'),
+    component('d.c')
+  ],
+  compositions: [
+    {
+      name: 'foo',
+      components: [component('a.b'), component('b.a')]
+    },
+    {
+      name: 'bar',
+      components: [component('d.c'), component('a.b')]
+    }
+  ]
+}
+
+/** @type {Array<toa.norm.context.Composition>} */
+const compositions = [
+  ...context.compositions,
+  {
+    name: 'd-a',
+    components: [component('d.a')]
+  },
+  {
+    name: 'd-b',
+    components: [component('d.b')]
+  }
+]
+
+exports.context = context
+exports.compositions = compositions

package/test/context/complete.test.js

@@ -0,0 +1,31 @@
+'use strict'
+
+const clone = require('clone-deep')
+
+const { complete } = require('../../src/.context')
+const fixtures = require('./complete.fixtures')
+
+/** @type {toa.norm.Context} */
+let context
+
+beforeEach(() => {
+  context = clone(fixtures.context)
+  complete(context)
+})
+
+it('should complete compositions', () => {
+  expect(context.compositions.length).toEqual(fixtures.compositions.length)
+  expect(context.compositions).toEqual(expect.arrayContaining(fixtures.compositions))
+})
+
+it('should create if compositions are not set', () => {
+  context.compositions = undefined
+
+  const compositions = context.components.map((component) => ({
+    name: component.locator.label,
+    components: [component]
+  }))
+
+  expect(() => complete(context)).not.toThrow()
+  expect(context.compositions).toStrictEqual(compositions)
+})

package/test/context/dereference.fixtures.js

@@ -0,0 +1,60 @@
+'use strict'
+
+const clone = require('clone-deep')
+
+/**
+ * @param id {string}
+ * @return {toa.norm.component.Declaration}
+ */
+const component = (id) => {
+  const [namespace, name] = id.split('.')
+
+  return {
+    namespace,
+    name,
+    version: '0.0.0',
+    locator: {
+      namespace,
+      name,
+      id,
+      label: `${namespace}-${name}`
+    },
+    entity: null
+  }
+}
+
+const context = {
+  name: 'test',
+  description: 'context fixture',
+  version: '0.0.0',
+  runtime: '0.0.0',
+  packages: 'namespaces/**/*',
+  registry: 'localhost:5000',
+  components: [component('a.b'), component('b.a'), component('d.c')],
+  compositions: [
+    {
+      name: 'foo',
+      components: ['a.b', 'b.a']
+    },
+    {
+      name: 'bar',
+      components: ['d.c', 'a.b']
+    }
+  ]
+}
+
+const expected = clone(context)
+
+expected.compositions = [
+  {
+    name: 'foo',
+    components: [component('a.b'), component('b.a')]
+  },
+  {
+    name: 'bar',
+    components: [component('d.c'), component('a.b')]
+  }
+]
+
+exports.context = context
+exports.expected = expected

package/test/context/dereference.test.js

@@ -0,0 +1,24 @@
+'use strict'
+
+const clone = require('clone-deep')
+
+const { dereference } = require('../../src/.context')
+const fixtures = require('./dereference.fixtures')
+
+/** @type {toa.norm.Context} */
+let context
+
+beforeAll(() => {
+  context = clone(fixtures.context)
+  dereference(context)
+})
+
+it('should dereference', () => {
+  expect(context).toEqual(expect.objectContaining(fixtures.expected))
+})
+
+it('should not throw on empty compositions', () => {
+  context.compositions = undefined
+
+  expect(() => dereference(context)).not.toThrow()
+})