@toa.io/norm 1.0.0-alpha.28 → 1.0.0-alpha.283

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,249 @@ 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/)
+    await assert.rejects(validate(manifest), (error) => /must NOT be valid/.test(error.message))
   })
 
   it('should set `default` namespace', async () => {
     delete manifest.namespace
 
-    expect(() => validate(manifest)).not.toThrow()
-    expect(manifest.namespace).toStrictEqual('default')
+    await assert.doesNotReject(validate(manifest))
+    assert.deepStrictEqual(manifest.namespace, 'default')
   })
 })
 
 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', () => {
+    it('should be required', async () => {
       delete manifest.entity.schema
-      expect(() => validate(manifest)).toThrow(/must have required property/)
+      await assert.rejects(validate(manifest))
     })
 
-    it('should be JSON schema object', () => {
+    it('should be JSON schema object', async () => {
       manifest.entity.schema = { properties: { foo: 'bar' } }
-      expect(() => validate(manifest)).toThrow()
+      await assert.rejects(validate(manifest))
     })
 
-    it('should be JSON schema object of type object', () => {
+    it('should be JSON schema object of type object', async () => {
       manifest.entity.schema = { type: 'integer' }
-      expect(() => validate(manifest)).toThrow(/must be equal to constant 'object'/)
+      await assert.rejects(validate(manifest), (error) => /must be equal to constant/.test(error.message))
 
       manifest.entity.schema = {}
       validate(manifest)
-      expect(manifest.entity.schema.type).toBe('object')
+      assert.strictEqual(manifest.entity.schema.type, 'object')
     })
 
-    it('should have property names matching token pattern', () => {
+    it('should have property names matching token pattern', async () => {
       manifest.entity.schema.properties._foo = { type: 'string' }
-      expect(() => validate(manifest)).toThrow(/pattern/)
+      await assert.rejects(validate(manifest), (error) => /pattern/.test(error.message))
     })
 
-    it('should allow default id', () => {
+    it('should allow default id', async () => {
       manifest.entity.schema.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)
+    it('should provide default', async () => {
+      await assert.doesNotReject(validate(manifest))
+      assert.strictEqual(manifest.entity.associated, false)
     })
   })
 })
 
 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) => {
+  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))
   })
 })

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,8 @@ 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 +28,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/dependencies.load.test.js

@@ -1,24 +1,25 @@
-'use strict'
+import { it } from 'node:test'
+import assert from 'node:assert/strict'
 
-const { join } = require('node:path')
-const { load } = require('../../src/.context/.dependencies/load')
+import { join } from 'node:path'
+import { load } from '../../src/.context/.dependencies/load.js'
 
 it('should be', async () => {
-  expect(load).toBeInstanceOf(Function)
+  assert.ok(load instanceof Function)
 })
 
 it('should load module', async () => {
-  const path = join(__dirname, '../../')
-  const { metadata, module } = load(path)
+  const path = join(import.meta.dirname, '../../')
+  const { metadata, module } = await load(path)
 
-  expect(metadata.name).toStrictEqual('@toa.io/norm')
-  expect(module.context).toBeInstanceOf(Function)
+  assert.deepStrictEqual(metadata.name, '@toa.io/norm')
+  assert.ok(module.context instanceof Function)
 })
 
 it('should return null metadata if no package.json', async () => {
-  const path = join(__dirname, '../../src')
-  const { metadata, module } = load(path)
+  const path = join(import.meta.dirname, '../../src')
+  const { metadata, module } = await load(path)
 
-  expect(metadata).toBeNull()
-  expect(module.context).toBeInstanceOf(Function)
+  assert.strictEqual(metadata, null)
+  assert.ok(module.context instanceof Function)
 })

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,34 @@
-'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'." })
 })

package/test/context/expand.fixtures.js

@@ -1,5 +1 @@
-'use strict'
-
-const { context } = require('./validate.fixtures')
-
-exports.context = context
+export { context } from './validate.fixtures.js'

package/test/context/expand.test.js

@@ -1,10 +1,11 @@
-'use strict'
+import { describe, it, beforeEach } from 'node:test'
+import assert from 'node:assert/strict'
 
-const clone = require('clone-deep')
-const { generate } = require('randomstring')
+import clone from 'clone-deep'
+import { generate } from 'randomstring'
 
-const { expand } = require('../../src/.context')
-const fixtures = require('./expand.fixtures')
+import { expand } from '../../src/.context/index.js'
+import * as fixtures from './expand.fixtures.js'
 
 /** @type {toa.norm.context.Declaration | object} */
 let context
@@ -17,7 +18,7 @@ describe('annotations', () => {
   it('should not throw without annotations', () => {
     delete context.annotations
 
-    expect(() => expand(context)).not.toThrow()
+    assert.doesNotThrow(() => expand(context))
   })
 
   it('should expand known annotations', () => {
@@ -28,7 +29,7 @@ describe('annotations', () => {
 
     expand(context)
 
-    expect(context.annotations).toStrictEqual(fixtures.context.annotations)
+    assert.deepStrictEqual(context.annotations, fixtures.context.annotations)
   })
 
   it('should recognize annotations', () => {
@@ -36,6 +37,31 @@ describe('annotations', () => {
 
     expand(context)
 
-    expect(context.annotations['@toa.io/storages.mongodb']).toBeDefined()
+    assert.notStrictEqual(context.annotations['@toa.io/storages.mongodb'], undefined)
+  })
+})
+
+describe('composition services', () => {
+  it('should resolve shortcuts', () => {
+    context.compositions[0].services = ['exposition', 'configuration']
+
+    expand(context)
+
+    assert.deepStrictEqual(context.compositions[0].services,
+      ['@toa.io/extensions.exposition', '@toa.io/extensions.configuration'])
+  })
+
+  it('should leave a package reference alone', () => {
+    context.compositions[0].services = ['@acme/extension']
+
+    expand(context)
+
+    assert.deepStrictEqual(context.compositions[0].services, ['@acme/extension'])
+  })
+
+  it('should not throw without compositions', () => {
+    delete context.compositions
+
+    assert.doesNotThrow(() => expand(context))
   })
 })

package/test/context/normalize.fixtures.js

@@ -1,15 +1,12 @@
-'use strict'
+import { generate } from 'randomstring'
 
-const { generate } = require('randomstring')
-
-const context = {
+export const context = {
   runtime: {
     version: '0.0.0'
   },
   name: 'test',
   description: 'context fixture',
   version: '0.0.0',
-  packages: 'namespaces/**/*',
   registry: 'localhost:5000',
   compositions: [
     {
@@ -28,5 +25,3 @@ const context = {
     }
   }
 }
-
-exports.context = context