@toa.io/norm 1.0.0-alpha.32 → 1.0.0-alpha.320

package/test/component/validate.test.js

@@ -1,11 +1,10 @@
-// noinspection JSUnresolvedVariable
+import { describe, it, beforeEach } from 'node:test'
+import assert from 'node:assert/strict'
 
-'use strict'
+import clone from 'clone-deep'
 
-const clone = require('clone-deep')
-
-const { validate } = require('../../src/.component')
-const fixtures = require('./validate.fixtures')
+import { validate } from '../../src/.component/index.js'
+import * as fixtures from './validate.fixtures.js'
 
 let manifest
 
@@ -13,249 +12,412 @@ beforeEach(() => {
   manifest = clone(fixtures.ok)
 })
 
-it('should be ok', () => {
-  expect(() => validate(manifest)).not.toThrow()
+it('should be ok', async () => {
+  await assert.doesNotReject(validate(manifest))
 })
 
-it('should provide error', () => {
+it('should provide error', async () => {
   manifest.foo = 'bar'
 
-  expect(() => validate(manifest)).toThrow(/must NOT have additional property/)
+  await assert.rejects(validate(manifest))
 })
 
-it('should not have additional properties', () => {
+it('should not have additional properties', async () => {
   manifest.foo = 'bar'
 
-  expect(() => validate(manifest)).toThrow(/must NOT have additional property/)
+  await assert.rejects(validate(manifest))
 })
 
 describe('namespace', () => {
-  it('should match token pattern', () => {
+  it('should match token pattern', async () => {
     manifest.namespace = '1'
-    expect(() => validate(manifest)).toThrow(/must match pattern/)
+    await assert.rejects(validate(manifest), (error) =>
+      /must match pattern/.test(error.message)
+    )
 
     manifest.namespace = 'foo_'
-    expect(() => validate(manifest)).toThrow(/must match pattern/)
+    await assert.rejects(validate(manifest), (error) =>
+      /must match pattern/.test(error.message)
+    )
 
     manifest.namespace = 'foo_bar'
-    expect(() => validate(manifest)).toThrow(/must match pattern/)
+    await assert.rejects(validate(manifest), (error) =>
+      /must match pattern/.test(error.message)
+    )
 
     manifest.namespace = 'foo-'
-    expect(() => validate(manifest)).toThrow(/must match pattern/)
+    await assert.rejects(validate(manifest), (error) =>
+      /must match pattern/.test(error.message)
+    )
 
     manifest.namespace = 'foo-bar'
-    expect(() => validate(manifest)).toThrow('must match pattern')
+    await assert.rejects(validate(manifest), (error) =>
+      /must match pattern/.test(error.message)
+    )
 
     manifest.namespace = 'FooBar12'
-    expect(() => validate(manifest)).not.toThrow()
+    await assert.doesNotReject(validate(manifest))
   })
 
-  it('should forbid \'system\' namespace', () => {
+  it("should forbid 'system' namespace", async () => {
     manifest.namespace = 'system'
-    expect(() => validate(manifest)).toThrow(/must NOT be valid/)
-  })
-
-  it('should set `default` namespace', async () => {
-    delete manifest.namespace
-
-    expect(() => validate(manifest)).not.toThrow()
-    expect(manifest.namespace).toStrictEqual('default')
+    await assert.rejects(validate(manifest), (error) =>
+      /must NOT be valid/.test(error.message)
+    )
   })
 })
 
 describe('name', () => {
-  it('should be optional', () => {
+  it('should be optional', async () => {
     delete manifest.name
-    expect(() => validate(manifest)).not.toThrow()
+    await assert.doesNotReject(validate(manifest))
   })
 })
 
 describe('entity', () => {
-  it('should be optional', () => {
+  it('should be optional', async () => {
     delete manifest.entity
-    expect(() => validate(manifest)).not.toThrow()
+    await assert.doesNotReject(validate(manifest))
   })
 
-  it('should be object', () => {
+  it('should be object', async () => {
     manifest.entity = 'foo'
-    expect(() => validate(manifest)).toThrow(/must be object/)
+    await assert.rejects(validate(manifest), (error) =>
+      /must be object/.test(error.message)
+    )
   })
 
-  it('should not have additional properties', () => {
+  it('should not have additional properties', async () => {
     manifest.entity.foo = 'bar'
-    expect(() => validate(manifest)).toThrow(/must NOT have additional property/)
+    await assert.rejects(validate(manifest))
   })
 
-  describe('schema', () => {
-    it('should be required', () => {
-      delete manifest.entity.schema
-      expect(() => validate(manifest)).toThrow(/must have required property/)
+  describe('properties', () => {
+    it('should be required', async () => {
+      delete manifest.entity.properties
+      await assert.rejects(validate(manifest))
     })
 
-    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 be JSON schemas', async () => {
+      manifest.entity.properties.foo = 'bar'
+      await assert.rejects(validate(manifest))
     })
 
-    it('should have property names matching token pattern', () => {
-      manifest.entity.schema.properties._foo = { type: 'string' }
-      expect(() => validate(manifest)).toThrow(/pattern/)
+    it('should have names matching token pattern', async () => {
+      manifest.entity.properties._foo = { type: 'string' }
+      await assert.rejects(validate(manifest), (error) => /pattern/.test(error.message))
     })
 
-    it('should allow default id', () => {
-      manifest.entity.schema.properties.id = {
+    it('should allow own id', async () => {
+      manifest.entity.properties.id = {
         type: 'string',
         pattern: '^[a-fA-F0-9]+$'
       }
-      expect(() => validate(manifest)).not.toThrow()
+      await assert.doesNotReject(validate(manifest))
+    })
+
+    it('should not declare TRAILERS', async () => {
+      manifest.entity.properties.TRAILERS = { type: 'object' }
+      await assert.rejects(validate(manifest), (error) =>
+        /System property 'TRAILERS' cannot be declared/.test(error.message)
+      )
     })
   })
 
-  describe('associated', () => {
-    it('should provide default', () => {
-      expect(() => validate(manifest)).not.toThrow()
-      expect(manifest.entity.associated).toBe(false)
+  describe('required', () => {
+    it('should name declared properties', async () => {
+      manifest.entity.required = ['name']
+      await assert.doesNotReject(validate(manifest))
+
+      manifest.entity.required = ['nope']
+      await assert.rejects(validate(manifest), (error) =>
+        /requires property 'nope'/.test(error.message)
+      )
+    })
+  })
+
+  describe('blank', () => {
+    it('should name declared properties', async () => {
+      manifest.entity.blank = { name: 'whatever' }
+      await assert.doesNotReject(validate(manifest))
+
+      manifest.entity.blank = { nope: 1 }
+      await assert.rejects(validate(manifest), (error) =>
+        /names property 'nope'/.test(error.message)
+      )
+    })
+
+    it('should not name a system property', async () => {
+      manifest.entity.blank = { VERSION: 1 }
+      await assert.rejects(validate(manifest), (error) =>
+        /must NOT be valid/.test(error.message)
+      )
+    })
+
+    it('should not name TRAILERS', async () => {
+      manifest.entity.blank = { TRAILERS: {} }
+      await assert.rejects(validate(manifest), (error) =>
+        /must NOT be valid/.test(error.message)
+      )
     })
   })
 })
 
 describe('bindings', () => {
-  it('should be array of unique strings', () => {
+  it('should be array of unique strings', async () => {
     manifest.bindings = 'oops'
-    expect(() => validate(manifest)).toThrow(/must be array/)
+    await assert.rejects(validate(manifest), (error) =>
+      /must be array/.test(error.message)
+    )
 
     manifest.bindings = ['oops', 'oops']
-    expect(() => validate(manifest)).toThrow(/duplicate items/)
+    await assert.rejects(validate(manifest), (error) =>
+      /duplicate items/.test(error.message)
+    )
 
     manifest.bindings = ['oops', {}]
-    expect(() => validate(manifest)).toThrow(/must be string/)
+    await assert.rejects(validate(manifest), (error) =>
+      /must be string/.test(error.message)
+    )
   })
 
-  it('should forbid explicit loop', () => {
+  it('should forbid explicit loop', async () => {
     manifest.bindings = ['@toa.io/bindings.loop']
-    expect(() => validate(manifest)).toThrow(/must NOT be valid/)
+    await assert.rejects(validate(manifest), (error) =>
+      /must NOT be valid/.test(error.message)
+    )
   })
 })
 
 describe('operations', () => {
-  it('should be object', () => {
+  it('should be object', async () => {
     manifest.operations.get = 'bar'
-    expect(() => validate(manifest)).toThrow(/must be object/)
+    await assert.rejects(validate(manifest), (error) =>
+      /must be object/.test(error.message)
+    )
   })
 
-  it('should not have additional properties', () => {
+  it('should not have additional properties', async () => {
     manifest.operations.get.foo = 'bar'
-    expect(() => validate(manifest)).toThrow(/additional property/)
+    await assert.rejects(validate(manifest))
   })
 
-  it('should have type (transition or observation)', () => {
+  it('should have type (transition or observation)', async () => {
     delete manifest.operations.get.type
-    expect(() => validate(manifest)).toThrow()
+    await assert.rejects(validate(manifest))
 
     manifest.operations.get.type = 'foo'
-    expect(() => validate(manifest)).toThrow(/one of the allowed values/)
+    await assert.rejects(validate(manifest), (error) =>
+      /one of the allowed values/.test(error.message)
+    )
   })
 
-  it('should forbid explicit loop', () => {
+  it('should forbid explicit loop', async () => {
     manifest.operations.get.bindings = ['@toa.io/bindings.loop']
-    expect(() => validate(manifest)).toThrow(/must NOT be valid/)
+    await assert.rejects(validate(manifest), (error) =>
+      /must NOT be valid/.test(error.message)
+    )
   })
 
-  it('should forbid query: false for observations', () => {
+  it('should forbid query: false for observations', async () => {
     manifest.operations.get.query = false
-    expect(() => validate(manifest)).toThrow(/must NOT be valid/)
+    await assert.rejects(validate(manifest), (error) =>
+      /must NOT be valid/.test(error.message)
+    )
   })
 
-  it.each([
-    ['computation', 'compute'],
-    ['effect', 'affect']
-  ])('should set query: false for %s', async (_, operation) => {
-    validate(manifest)
+  for (const [_, operation] of [['computation', 'compute']])
+    it(`should set query: false for ${_}`, async () => {
+      validate(manifest)
 
-    expect(manifest.operations[operation].query).toBe(false)
-  })
+      assert.strictEqual(manifest.operations[operation].query, false)
+    })
 
   describe('scope', () => {
-    it('should have scope', () => {
+    it('should have scope', async () => {
       delete manifest.operations.get.scope
-      expect(() => validate(manifest)).toThrow(/required property/)
+      await assert.rejects(validate(manifest), (error) =>
+        /required property/.test(error.message)
+      )
     })
 
-    it('should allow only entity or set for observations', () => {
+    it('should allow only entity or set for observations', async () => {
       manifest.operations.get.scope = 'changeset'
-      expect(() => validate(manifest)).toThrow(/allowed values/)
+      await assert.rejects(validate(manifest), (error) =>
+        /allowed values/.test(error.message)
+      )
     })
 
-    it('should allow only entity for transitions', () => {
+    it('should allow only entity for transitions', async () => {
       manifest.operations.add.scope = 'changeset'
-      expect(() => validate(manifest)).toThrow(/allowed values/)
+      await assert.rejects(validate(manifest), (error) =>
+        /allowed values/.test(error.message)
+      )
 
       manifest.operations.add.scope = 'set'
-      expect(() => validate(manifest)).toThrow(/allowed values/)
+      await assert.rejects(validate(manifest), (error) =>
+        /allowed values/.test(error.message)
+      )
     })
 
-    it('should allow only changeset for assignments', () => {
+    it('should refuse the names the scopes had before `entry` and `entries`', async () => {
+      for (const scope of ['object', 'objects']) {
+        manifest.operations.get.scope = scope
+        await assert.rejects(validate(manifest), (error) => /allowed values/.test(error.message))
+      }
+    })
+
+    it('should allow only changeset for assignments', async () => {
       manifest.operations.set.scope = 'changeset'
-      expect(() => validate(manifest)).not.toThrow()
+      await assert.doesNotReject(validate(manifest))
 
       manifest.operations.set.scope = 'set'
-      expect(() => validate(manifest)).toThrow(/allowed values/)
+      await assert.rejects(validate(manifest), (error) =>
+        /allowed values/.test(error.message)
+      )
+    })
+  })
+
+  describe('once', () => {
+    it('should be true, false or a number of seconds', async () => {
+      for (const once of [true, false, 600, 86400]) {
+        manifest.operations.add.once = once
+        await assert.doesNotReject(validate(manifest), `once: ${once}`)
+      }
+    })
+
+    it('should stay true rather than be coerced into a number', async () => {
+      manifest.operations.add.once = true
+      await validate(manifest)
+
+      assert.strictEqual(manifest.operations.add.once, true)
+    })
+
+    it('should not be a window shorter than ten minutes', async () => {
+      manifest.operations.add.once = 599
+      await assert.rejects(validate(manifest), (error) => /must be >= 600/.test(error.message))
+    })
+
+    it('should not be a fraction of a second', async () => {
+      manifest.operations.add.once = 600.5
+      await assert.rejects(validate(manifest))
+    })
+
+    it('should throw for an operation that takes none', async () => {
+      manifest.operations.get.once = 600
+      await assert.rejects(validate(manifest))
     })
   })
 
   describe('concurrency', () => {
-    it('should be required for transitions', () => {
+    it('should be required for transitions', async () => {
       delete manifest.operations.add.concurrency
-      expect(() => validate(manifest)).toThrow(/required property/)
+      await assert.rejects(validate(manifest), (error) =>
+        /required property/.test(error.message)
+      )
     })
 
-    it('should throw for observations, assignments', () => {
+    it('should throw for observations, assignments', async () => {
       manifest.operations.get.concurrency = 'none'
-      expect(() => validate(manifest)).toThrow()
+      await assert.rejects(validate(manifest))
       delete manifest.operations.get.concurrency
 
       manifest.operations.set.concurrency = 'none'
-      expect(() => validate(manifest)).toThrow()
+      await assert.rejects(validate(manifest))
     })
   })
 
   describe('input, output', () => {
-    it('should be schema', () => {
+    it('should be schema', async () => {
       manifest.operations.get.input = { properties: { foo: 'bar' } }
-      expect(() => validate(manifest)).toThrow()
+      await assert.rejects(validate(manifest))
 
       delete manifest.operations.get.input
       manifest.operations.get.output = { properties: { foo: 'bar' } }
-      expect(() => validate(manifest)).toThrow()
+      await assert.rejects(validate(manifest))
     })
   })
 })
 
 describe('receivers', () => {
-  it('should throw if transition points to undefined operation', () => {
+  it('should throw if transition points to undefined operation', async () => {
     manifest.receivers['foo.bar.happened'].operation = 'notExists'
 
-    expect(() => validate(manifest)).toThrow(/refers to undefined operation/)
+    await assert.rejects(validate(manifest), (error) =>
+      /refers to undefined operation/.test(error.message)
+    )
   })
 
-  it('should throw if transition points to observation', () => {
+  it('should throw if transition points to observation', async () => {
     manifest.receivers['foo.bar.happened'].operation = 'get'
 
-    expect(() => validate(manifest)).toThrow(/one of the allowed types/)
+    await assert.rejects(validate(manifest), (error) =>
+      /of the allowed types/.test(error.message)
+    )
   })
 
   it('should throw if source has a name `context`', async () => {
     manifest.receivers['foo.bar.happened'].source = 'context'
 
-    expect(() => validate(manifest)).toThrow(/must NOT be valid/)
+    await assert.rejects(validate(manifest), (error) =>
+      /must NOT be valid/.test(error.message)
+    )
+  })
+})
+
+describe('stateful', () => {
+  it('should be allowed on an operation', async () => {
+    const [operation] = Object.values(manifest.operations)
+
+    operation.stateful = true
+
+    await assert.doesNotReject(validate(manifest))
+  })
+
+  it('should be a boolean', async () => {
+    const [operation] = Object.values(manifest.operations)
+
+    operation.stateful = 'yes'
+
+    await assert.rejects(validate(manifest), (error) => /must be boolean/.test(error.message))
+  })
+})
+
+describe('stream', () => {
+  beforeEach(() => {
+    manifest.operations.read = {
+      type: 'computation',
+      scope: 'none',
+      query: false,
+      bridge: 'whatever',
+      bindings: ['@toa.io/bindings.amqp'],
+      stream: 'content'
+    }
+  })
+
+  it('should reject an operation whose bindings carry no stream', async () => {
+    await assert.rejects(validate(manifest), (error) =>
+      /takes a stream, which none of its bindings carries/.test(error.message)
+    )
+  })
+
+  it('should accept an operation served where it is composed', async () => {
+    manifest.operations.read.bindings = []
+
+    await assert.doesNotReject(validate(manifest))
+  })
+
+  it('should accept an operation bound to a binding that carries a stream', async () => {
+    manifest.operations.read.bindings = ['@toa.io/bindings.http']
+
+    await assert.doesNotReject(validate(manifest))
+  })
+
+  it('should reject a transition that takes a stream', async () => {
+    manifest.operations.add.stream = 'content'
+
+    await assert.rejects(validate(manifest), (error) =>
+      /must be equal to one of the allowed values/.test(error.message)
+    )
   })
 })

package/test/context/complete.fixtures.js

@@ -1,5 +1,3 @@
-'use strict'
-
 const component = (id) => {
   const [namespace, name] = id.split('.')
 
@@ -16,12 +14,11 @@ const component = (id) => {
   }
 }
 
-const context = {
+export const context = {
   runtime: '0.0.0',
   name: 'test',
   description: 'context fixture',
   version: '0.0.0',
-  packages: 'namespaces/**/*',
   registry: 'localhost:5000',
   components: [
     component('a.b'),
@@ -43,7 +40,7 @@ const context = {
 }
 
 /** @type {Array<toa.norm.context.Composition>} */
-const compositions = [
+export const compositions = [
   ...context.compositions,
   {
     name: 'd-a',
@@ -54,6 +51,3 @@ const compositions = [
     components: [component('d.b')]
   }
 ]
-
-exports.context = context
-exports.compositions = compositions

package/test/context/complete.test.js

@@ -1,9 +1,11 @@
-'use strict'
+import { it, beforeEach } from 'node:test'
+import assert from 'node:assert/strict'
+import { isDeepStrictEqual } from 'node:util'
 
-const clone = require('clone-deep')
+import clone from 'clone-deep'
 
-const { complete } = require('../../src/.context')
-const fixtures = require('./complete.fixtures')
+import { complete } from '../../src/.context/index.js'
+import * as fixtures from './complete.fixtures.js'
 
 /** @type {toa.norm.Context} */
 let context
@@ -14,8 +16,12 @@ beforeEach(() => {
 })
 
 it('should complete compositions', () => {
-  expect(context.compositions.length).toEqual(fixtures.compositions.length)
-  expect(context.compositions).toEqual(expect.arrayContaining(fixtures.compositions))
+  assert.deepStrictEqual(context.compositions.length, fixtures.compositions.length)
+  assert.ok(
+    fixtures.compositions.every((item) =>
+      context.compositions.some((candidate) => isDeepStrictEqual(candidate, item))
+    )
+  )
 })
 
 it('should create if compositions are not set', () => {
@@ -26,6 +32,6 @@ it('should create if compositions are not set', () => {
     components: [component]
   }))
 
-  expect(() => complete(context)).not.toThrow()
-  expect(context.compositions).toStrictEqual(compositions)
+  assert.doesNotThrow(() => complete(context))
+  assert.deepStrictEqual(context.compositions, compositions)
 })

package/test/context/converge.test.js

@@ -0,0 +1,57 @@
+import { it, beforeEach } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { converge } from '../../src/.context/index.js'
+
+const REFERENCE = '@toa.io/extensions.convergence'
+
+/** @type {object} */
+let context
+
+/** @type {object[]} */
+let components
+
+const component = (id, properties = {}) => ({ id, entity: {}, ...properties })
+
+beforeEach(() => {
+  context = { annotations: { [REFERENCE]: { priority: 0 } } }
+
+  components = [
+    component('store.orders'),
+    // what an extension ships reaches a deployment the same way and converges the same way:
+    // an application whose identity does not converge has no users in its second region
+    component('identity.basic'),
+    component('exposition.octets', { entity: undefined })
+  ]
+})
+
+it('should give the extension to every component that stores anything', () => {
+  converge(context, components)
+
+  assert.deepEqual(components[0].extensions, { [REFERENCE]: null })
+  assert.deepEqual(components[1].extensions, { [REFERENCE]: null })
+})
+
+it('should leave a component that stores nothing alone', () => {
+  converge(context, components)
+
+  assert.equal(components[2].extensions, undefined)
+})
+
+it('should do nothing where the context is not a region', () => {
+  delete context.annotations
+
+  converge(context, components)
+
+  for (const one of components) assert.equal(one.extensions, undefined)
+})
+
+it('should leave what a manifest declared as it was', () => {
+  const declaration = { some: 'declaration' }
+
+  components[0].extensions = { [REFERENCE]: declaration }
+
+  converge(context, components)
+
+  assert.equal(components[0].extensions[REFERENCE], declaration)
+})