@toa.io/norm 1.0.0-alpha.30 → 1.0.0-alpha.301

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,321 @@ 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))
     })
   })
 
-  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)
+      )
     })
   })
 })
 
 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 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('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))
   })
 })

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)
+})

package/test/context/dereference.fixtures.js

@@ -1,6 +1,4 @@
-'use strict'
-
-const clone = require('clone-deep')
+import clone from 'clone-deep'
 
 /**
  * @param id {string}
@@ -22,12 +20,11 @@ const component = (id) => {
   }
 }
 
-const context = {
+export 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: [
@@ -42,7 +39,7 @@ const context = {
   ]
 }
 
-const expected = clone(context)
+export const expected = clone(context)
 
 expected.compositions = [
   {
@@ -54,6 +51,3 @@ expected.compositions = [
     components: [component('d.c'), component('a.b')]
   }
 ]
-
-exports.context = context
-exports.expected = expected

package/test/context/dereference.test.js

@@ -1,24 +1,35 @@
-'use strict'
+import { it, before } from 'node:test'
+import assert from 'node:assert/strict'
 
-const clone = require('clone-deep')
+import clone from 'clone-deep'
 
-const { dereference } = require('../../src/.context')
-const fixtures = require('./dereference.fixtures')
+import { dereference } from '../../src/.context/index.js'
+import * as fixtures from './dereference.fixtures.js'
 
 /** @type {toa.norm.Context} */
 let context
 
-beforeAll(() => {
+before(() => {
   context = clone(fixtures.context)
   dereference(context)
 })
 
 it('should dereference', () => {
-  expect(context).toEqual(expect.objectContaining(fixtures.expected))
+  assert.partialDeepStrictEqual(context, fixtures.expected)
 })
 
 it('should not throw on empty compositions', () => {
   context.compositions = undefined
 
-  expect(() => dereference(context)).not.toThrow()
+  assert.doesNotThrow(() => dereference(context))
+})
+
+it('should throw on an unknown component', () => {
+  const broken = clone(fixtures.context)
+
+  broken.compositions[1].components.push('nope.here')
+
+  assert.throws(() => dereference(broken), {
+    message: "Composition 'bar' lists an unknown component 'nope.here'."
+  })
 })