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

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'."
+  })
 })

package/test/context/evict.fixtures.js

@@ -0,0 +1,39 @@
+/**
+ * @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}`
+    }
+  }
+}
+
+export const context = {
+  name: 'test',
+  description: 'context fixture',
+  version: '0.0.0',
+  runtime: '0.0.0',
+  registry: 'localhost:5000',
+  components: [component('a.b'), component('b.a'), component('d.c')],
+  compositions: [
+    {
+      name: 'foo',
+      components: ['a.b', 'b.a'],
+      services: ['@toa.io/extensions.exposition', '@toa.io/extensions.cadence']
+    },
+    {
+      name: 'bar',
+      components: ['d.c']
+    }
+  ]
+}

package/test/context/evict.test.js

@@ -0,0 +1,73 @@
+import { it, beforeEach } from 'node:test'
+import assert from 'node:assert/strict'
+
+import clone from 'clone-deep'
+
+import { evict } from '../../src/.context/index.js'
+import * as fixtures from './evict.fixtures.js'
+
+/** @type {toa.norm.Context} */
+let context
+
+beforeEach(() => {
+  context = clone(fixtures.context)
+})
+
+it('should keep a context that evicts nothing', () => {
+  evict(context)
+
+  assert.deepStrictEqual(context, fixtures.context)
+})
+
+it('should mark an evicted component and keep it', () => {
+  context.evicted = { components: ['a.b'] }
+
+  evict(context)
+
+  assert.deepStrictEqual(
+    context.components.map((component) => [
+      component.locator.id,
+      component.evicted === true
+    ]),
+    [
+      ['a.b', true],
+      ['b.a', false],
+      ['d.c', false]
+    ]
+  )
+})
+
+it('should keep an evicted component in a composition that lists it', () => {
+  context.evicted = { components: ['a.b', 'd.c'] }
+
+  evict(context)
+
+  assert.deepStrictEqual(context.compositions[0].components, ['a.b', 'b.a'])
+  assert.deepStrictEqual(context.compositions[1].components, ['d.c'])
+})
+
+it('should refuse an unknown component', () => {
+  context.evicted = { components: ['d.a'] }
+
+  assert.throws(() => evict(context), {
+    message: "'evicted' names an unknown component 'd.a'."
+  })
+})
+
+it('should drop an evicted service from a composition that runs it', () => {
+  context.evicted = { services: ['@toa.io/extensions.exposition'] }
+
+  evict(context)
+
+  assert.deepStrictEqual(context.compositions[0].services, ['@toa.io/extensions.cadence'])
+})
+
+it('should leave no services where every one is evicted', () => {
+  context.evicted = {
+    services: ['@toa.io/extensions.exposition', '@toa.io/extensions.cadence']
+  }
+
+  evict(context)
+
+  assert.strictEqual('services' in context.compositions[0], false)
+})

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,33 @@ 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

package/test/context/normalize.test.js

@@ -1,10 +1,12 @@
-'use strict'
+import * as definitions from '@toa.io/definitions'
+import { 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 fixtures = require('./normalize.fixtures')
-const { normalize } = require('../../src/.context')
+import * as fixtures from './normalize.fixtures.js'
+import { normalize } from '../../src/.context/index.js'
 
 let context
 
@@ -17,8 +19,8 @@ it('should resolve local version', () => {
 
   normalize(context)
 
-  expect(context.runtime).not.toEqual('.')
-  expect(context.runtime.version).toEqual(require('@toa.io/runtime').version)
+  assert.notDeepStrictEqual(context.runtime, '.')
+  assert.deepStrictEqual(context.runtime.version, definitions.version)
 })
 
 it('should expand registry', () => {
@@ -28,7 +30,29 @@ it('should expand registry', () => {
 
   normalize(context)
 
-  expect(context.registry).toEqual({
-    base
+  assert.deepStrictEqual(context.registry, {
+    base,
+    platforms: ['linux/amd64', 'linux/arm/v7', 'linux/arm64']
   })
 })
+
+it('should set default platforms', () => {
+  context.registry = { base: generate() }
+
+  normalize(context)
+
+  assert.deepStrictEqual(context.registry.platforms, [
+    'linux/amd64',
+    'linux/arm/v7',
+    'linux/arm64'
+  ])
+})
+
+it('should keep platforms declared as none', () => {
+  // `platforms: ~` in the context: the runner's own platform, not the default list
+  context.registry = { base: generate(), platforms: null }
+
+  normalize(context)
+
+  assert.strictEqual(context.registry.platforms, null)
+})

package/test/context/validate.fixtures.js

@@ -1,13 +1,10 @@
-'use strict'
-
-const context = {
+export const context = {
   runtime: {
     version: '0.0.0'
   },
   name: 'test',
   description: 'context fixture',
   version: '0.0.0',
-  packages: 'namespaces/**/*',
   build: {
     command: 'echo test'
   },
@@ -37,5 +34,3 @@ const context = {
     }
   }
 }
-
-exports.context = context

package/test/context/validate.test.js

@@ -1,14 +1,15 @@
-'use strict'
+import { describe, it, before, beforeEach } from 'node:test'
+import assert from 'node:assert/strict'
 
-const clone = require('clone-deep')
+import clone from 'clone-deep'
 
-const { validate } = require('../../src/.context')
-const fixtures = require('./validate.fixtures')
+import { validate } from '../../src/.context/index.js'
+import * as fixtures from './validate.fixtures.js'
 
 let context
 
-beforeAll(() => {
-  expect(() => validate(fixtures.context)).not.toThrow()
+before(() => {
+  assert.doesNotThrow(() => validate(fixtures.context))
 })
 
 beforeEach(() => {
@@ -18,23 +19,32 @@ beforeEach(() => {
 describe('runtime', () => {
   it('should require', () => {
     delete context.runtime
-    expect(() => validate(context)).toThrow(/required/)
+    assert.throws(
+      () => validate(context),
+      (error) => /required/.test(error.message)
+    )
   })
 
   it('should require registry to match uri format', () => {
     context.runtime.registry = 'not-a-uri'
-    expect(() => validate(context)).toThrow(/must match format/)
+    assert.throws(
+      () => validate(context),
+      (error) => /must match format/.test(error.message)
+    )
 
     context.runtime.registry = 'http://localhost'
-    expect(() => validate(context)).not.toThrow()
+    assert.doesNotThrow(() => validate(context))
   })
 
   it('should require proxy to match uri format', () => {
     context.runtime.proxy = 'not-a-uri'
-    expect(() => validate(context)).toThrow(/must match format/)
+    assert.throws(
+      () => validate(context),
+      (error) => /must match format/.test(error.message)
+    )
 
     context.runtime.proxy = 'http://localhost'
-    expect(() => validate(context)).not.toThrow()
+    assert.doesNotThrow(() => validate(context))
   })
 })
 
@@ -42,43 +52,171 @@ describe('registry', () => {
   it('should require', () => {
     delete context.registry
 
-    expect(() => validate(context)).toThrow(/required property 'registry'/)
+    assert.throws(
+      () => validate(context),
+      (error) => /required property 'registry'/.test(error.message)
+    )
   })
+})
 
-  it('should require base', () => {
-    delete context.registry.base
+it('should require name as label', () => {
+  delete context.name
+  assert.throws(
+    () => validate(context),
+    (error) => /required/.test(error.message)
+  )
 
-    expect(() => validate(context)).toThrow(/required property 'base'/)
-  })
+  context.name = 'foo bar'
+  assert.throws(
+    () => validate(context),
+    (error) => /pattern/.test(error.message)
+  )
 
-  it('should set default platforms', () => {
-    delete context.registry.platforms
+  context.name = 'foo-bar'
+  assert.doesNotThrow(() => validate(context))
+})
 
-    validate(context)
+it('should require registry url', () => {
+  delete context.registry
+  assert.throws(
+    () => validate(context),
+    (error) => /required/.test(error.message)
+  )
+})
 
-    expect(context.registry.platforms).toBeInstanceOf(Array)
-    expect(context.registry.platforms).toStrictEqual(['linux/amd64', 'linux/arm/v7', 'linux/arm64'])
+describe('inbox', () => {
+  it('should allow a retention of ten minutes or more', () => {
+    context.inbox = { retention: 600 }
+    assert.doesNotThrow(() => validate(context))
+  })
+
+  it('should refuse a retention shorter than ten minutes', () => {
+    context.inbox = { retention: 599 }
+    assert.throws(
+      () => validate(context),
+      (error) => /must be >= 600/.test(error.message)
+    )
   })
 })
 
-it('should require name as label', () => {
-  delete context.name
-  expect(() => validate(context)).toThrow(/required/)
+it('should allow mono replicas and resources', () => {
+  context.mono = {
+    replicas: 2,
+    resources: {
+      cpu: ['200m', '2'],
+      memory: ['256Mi', '2Gi']
+    }
+  }
 
-  context.name = 'foo bar'
-  expect(() => validate(context)).toThrow(/pattern/)
+  assert.doesNotThrow(() => validate(context))
+})
 
-  context.name = 'foo-bar'
-  expect(() => validate(context)).not.toThrow(/pattern/)
+describe('compositions', () => {
+  it('should allow services', () => {
+    context.compositions[0].services = ['@toa.io/extensions.exposition']
+
+    assert.doesNotThrow(() => validate(context))
+  })
+
+  it('should require services to be a non-empty array of strings', () => {
+    context.compositions[0].services = []
+    assert.throws(
+      () => validate(context),
+      (error) => /fewer than 1 items/.test(error.message)
+    )
+
+    context.compositions[0].services = 'exposition'
+    assert.throws(
+      () => validate(context),
+      (error) => /must be array/.test(error.message)
+    )
+  })
+
+  it('should reject an unknown property', () => {
+    context.compositions[0].compoments = ['a.b']
+
+    assert.throws(
+      () => validate(context),
+      (error) => /must NOT have additional properties/.test(error.message)
+    )
+  })
+
+  it('should allow replicas of one', () => {
+    context.compositions[0].replicas = 1
+
+    assert.doesNotThrow(() => validate(context))
+  })
+
+  it('should refuse replicas below one', () => {
+    context.compositions[0].replicas = 0
+
+    assert.throws(
+      () => validate(context),
+      (error) => /must be >= 1/.test(error.message)
+    )
+  })
 })
 
-it('should set default packages location', () => {
-  delete context.packages
-  expect(() => validate(context)).not.toThrow()
-  expect(context.packages).toBe('components/*')
+describe('evicted', () => {
+  it('should allow components and services', () => {
+    context.evicted = {
+      components: ['a.b'],
+      services: ['@toa.io/extensions.exposition']
+    }
+
+    assert.doesNotThrow(() => validate(context))
+  })
+
+  it('should require a component to be named as one', () => {
+    context.evicted = { components: ['a'] }
+
+    assert.throws(
+      () => validate(context),
+      (error) => /must match pattern/.test(error.message)
+    )
+  })
+
+  it('should reject an empty declaration', () => {
+    context.evicted = {}
+
+    assert.throws(
+      () => validate(context),
+      (error) => /fewer than 1 properties/.test(error.message)
+    )
+  })
+
+  it('should reject an unknown property', () => {
+    context.evicted = { compoments: ['a.b'] }
+
+    assert.throws(
+      () => validate(context),
+      (error) => /must NOT have additional properties/.test(error.message)
+    )
+  })
 })
 
-it('should require registry url', () => {
-  delete context.registry
-  expect(() => validate(context)).toThrow(/required/)
+describe('addressed', () => {
+  it('should take the timeout an addressed call waits by default', () => {
+    context.addressed = { timeout: 5000 }
+
+    assert.doesNotThrow(() => validate(context))
+  })
+
+  it('should take a timeout of a millisecond at least', () => {
+    context.addressed = { timeout: 0 }
+
+    assert.throws(
+      () => validate(context),
+      (error) => /must be >= 1/.test(error.message)
+    )
+  })
+
+  it('should take nothing else', () => {
+    context.addressed = { interval: 5000 }
+
+    assert.throws(
+      () => validate(context),
+      (error) => /must NOT have additional properties/.test(error.message)
+    )
+  })
 })