@toa.io/norm 1.0.0-alpha.31 → 1.0.0-alpha.310

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.realtime']
+    },
+    {
+      name: 'bar',
+      components: ['d.c']
+    }
+  ]
+}

package/test/context/evict.test.js

@@ -0,0 +1,72 @@
+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.realtime'
+  ])
+})
+
+it('should leave no services where every one is evicted', () => {
+  context.evicted = {
+    services: ['@toa.io/extensions.exposition', '@toa.io/extensions.realtime']
+  }
+
+  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,156 @@ 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 name as label', () => {
+  delete context.name
+  assert.throws(
+    () => validate(context),
+    (error) => /required/.test(error.message)
+  )
+
+  context.name = 'foo bar'
+  assert.throws(
+    () => validate(context),
+    (error) => /pattern/.test(error.message)
+  )
 
-  it('should require base', () => {
-    delete context.registry.base
+  context.name = 'foo-bar'
+  assert.doesNotThrow(() => validate(context))
+})
+
+it('should require registry url', () => {
+  delete context.registry
+  assert.throws(
+    () => validate(context),
+    (error) => /required/.test(error.message)
+  )
+})
 
-    expect(() => validate(context)).toThrow(/required property 'base'/)
+it('should allow mono replicas and resources', () => {
+  context.mono = {
+    replicas: 2,
+    resources: {
+      cpu: ['200m', '2'],
+      memory: ['256Mi', '2Gi']
+    }
+  }
+
+  assert.doesNotThrow(() => validate(context))
+})
+
+describe('compositions', () => {
+  it('should allow services', () => {
+    context.compositions[0].services = ['@toa.io/extensions.exposition']
+
+    assert.doesNotThrow(() => validate(context))
   })
 
-  it('should set default platforms', () => {
-    delete context.registry.platforms
+  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)
+    )
+  })
 
-    validate(context)
+  it('should reject an unknown property', () => {
+    context.compositions[0].compoments = ['a.b']
 
-    expect(context.registry.platforms).toBeInstanceOf(Array)
-    expect(context.registry.platforms).toStrictEqual(['linux/amd64', 'linux/arm/v7', 'linux/arm64'])
+    assert.throws(
+      () => validate(context),
+      (error) => /must NOT have additional properties/.test(error.message)
+    )
   })
-})
 
-it('should require name as label', () => {
-  delete context.name
-  expect(() => validate(context)).toThrow(/required/)
+  it('should allow replicas of one', () => {
+    context.compositions[0].replicas = 1
 
-  context.name = 'foo bar'
-  expect(() => validate(context)).toThrow(/pattern/)
+    assert.doesNotThrow(() => validate(context))
+  })
 
-  context.name = 'foo-bar'
-  expect(() => validate(context)).not.toThrow(/pattern/)
+  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)
+    )
+  })
 })

package/test/definition.test.js

@@ -0,0 +1,35 @@
+import { it } from 'node:test'
+import assert from 'node:assert/strict'
+import { join } from 'node:path'
+
+import { definition } from '../src/definition.js'
+
+it('reads a definition.js where a package ships one', async () => {
+  const { name, module } = await definition(join(import.meta.dirname, 'dummies/defined'))
+
+  assert.equal(name, 'dummies.defined')
+  assert.equal(module.declares, true)
+  assert.equal(module.runs, undefined)
+})
+
+it('reads the entry where a package ships no definition.js', async () => {
+  const path = join(import.meta.dirname, '../')
+  const { name, module } = await definition(path)
+
+  assert.equal(name, '@toa.io/norm')
+  assert.ok(module.context instanceof Function)
+})
+
+it('names a directory without package.json by its reference', async () => {
+  const path = join(import.meta.dirname, 'dummies/bare')
+  const { name, module } = await definition(path)
+
+  assert.equal(name, path)
+  assert.equal(module.declares, true)
+})
+
+it('loads a definition once', async () => {
+  const path = join(import.meta.dirname, 'dummies/bare')
+
+  assert.equal(await definition(path), await definition(path))
+})

package/test/dummies/bare/index.js

@@ -0,0 +1 @@
+export const declares = true

package/test/dummies/defined/definition.js

@@ -0,0 +1 @@
+export const declares = true

package/test/dummies/defined/index.js

@@ -0,0 +1 @@
+export const runs = true

package/test/dummies/defined/package.json

@@ -0,0 +1 @@
+{ "name": "dummies.defined", "type": "module", "main": "index.js" }