@toa.io/norm 1.0.0-alpha.274 → 1.0.0-alpha.278

package/test/component/expand.test.js

@@ -1,9 +1,10 @@
-'use strict'
+import { it, beforeEach } from 'node:test'
+import assert from 'node:assert/strict'
 
-const clone = require('clone-deep')
+import clone from 'clone-deep'
 
-const { expand } = require('../../src/.component')
-const fixtures = require('./expand.fixtures')
+import { expand } from '../../src/.component/index.js'
+import * as fixtures from './expand.fixtures.js'
 
 let source
 
@@ -13,13 +14,13 @@ beforeEach(() => {
 
 it('should expand', async () => {
   await expand(source)
-  expect(source).toMatchObject(fixtures.target)
+  assert.partialDeepStrictEqual(source, fixtures.target)
 })
 
 it('should derive version from the component contents', async () => {
   await expand(source)
 
-  expect(source.version).toMatch(/^[0-9a-f]{8}$/)
+  assert.match(source.version, /^[0-9a-f]{8}$/)
 })
 
 it('should keep declared version', async () => {
@@ -27,7 +28,7 @@ it('should keep declared version', async () => {
 
   await expand(source)
 
-  expect(source.version).toStrictEqual('1.0.0')
+  assert.deepStrictEqual(source.version, '1.0.0')
 })
 
 it('should recognize storages.queues', async () => {
@@ -37,6 +38,6 @@ it('should recognize storages.queues', async () => {
 
   await expand(source)
 
-  expect(source.queues).toBeUndefined()
-  expect(source.properties['@toa.io/storages.queues']).toMatchObject(queues)
+  assert.strictEqual(source.queues, undefined)
+  assert.partialDeepStrictEqual(source.properties['@toa.io/storages.queues'], queues)
 })

package/test/component/normalize.fixtures.js

@@ -1,11 +1,9 @@
-'use strict'
+import { generate } from 'randomstring'
 
-const { generate } = require('randomstring')
-
-const operations = {
+export const operations = {
   namespace: 'dummies',
   name: 'dummy',
-  path: __dirname,
+  path: import.meta.dirname,
   bindings: ['foo', 'bar'],
   'bindings@local': ['foo'],
   operations: {
@@ -22,5 +20,3 @@ const operations = {
     }
   }
 }
-
-exports.operations = operations

package/test/component/normalize.test.js

@@ -1,8 +1,10 @@
-'use strict'
-const clone = require('clone-deep')
+import { describe, it, beforeEach } from 'node:test'
+import assert from 'node:assert/strict'
 
-const { normalize, extensions } = require('../../src/.component')
-const fixtures = require('./normalize.fixtures')
+import clone from 'clone-deep'
+
+import { normalize, extensions } from '../../src/.component/index.js'
+import * as fixtures from './normalize.fixtures.js'
 
 let manifest
 
@@ -11,27 +13,27 @@ beforeEach(() => {
 })
 
 describe('operations', () => {
-  it('should set default bindings', () => {
-    normalize(manifest)
+  it('should set default bindings', async () => {
+    await normalize(manifest)
 
-    expect(manifest.operations.add.bindings).toStrictEqual(manifest.bindings)
+    assert.deepStrictEqual(manifest.operations.add.bindings, manifest.bindings)
   })
 })
 
 describe('extensions', () => {
-  it('should add predefined extensions', () => {
-    extensions(manifest)
+  it('should add predefined extensions', async () => {
+    await extensions(manifest)
 
-    expect(manifest.extensions['@toa.io/extensions.telemetry']).toBeNull()
-    expect(manifest.extensions['@toa.io/extensions.fetch']).toBeNull()
+    assert.strictEqual(manifest.extensions['@toa.io/extensions.telemetry'], null)
+    assert.strictEqual(manifest.extensions['@toa.io/extensions.fetch'], null)
   })
 
-  it('should add predefined extensions without explicit declarations', () => {
+  it('should add predefined extensions without explicit declarations', async () => {
     delete manifest.extensions
 
-    extensions(manifest)
+    await extensions(manifest)
 
-    expect(manifest.extensions).toStrictEqual({
+    assert.deepStrictEqual(manifest.extensions, {
       '@toa.io/extensions.telemetry': null,
       '@toa.io/extensions.fetch': null,
       '@toa.io/extensions.introspection': {}
@@ -45,9 +47,9 @@ describe('receivers', () => {
       'messages.created': 'add'
     }
 
-    normalize(manifest)
+    await normalize(manifest)
 
-    expect(manifest.receivers).toStrictEqual({
+    assert.deepStrictEqual(manifest.receivers, {
       'default.messages.created': 'add'
     })
   })
@@ -62,9 +64,9 @@ describe('receivers', () => {
       'messages.created': receiver
     }
 
-    normalize(manifest)
+    await normalize(manifest)
 
-    expect(manifest.receivers).toStrictEqual({
+    assert.deepStrictEqual(manifest.receivers, {
       'messages.created': receiver
     })
   })

package/test/component/validate.fixtures.js

@@ -1,6 +1,4 @@
-'use strict'
-
-const ok = {
+export const ok = {
   namespace: 'foo',
   name: 'bar',
   entity: {
@@ -64,5 +62,3 @@ const ok = {
     }
   }
 }
-
-exports.ok = ok

package/test/component/validate.test.js

@@ -1,9 +1,10 @@
-'use strict'
+import { describe, it, beforeEach } from 'node:test'
+import assert from 'node:assert/strict'
 
-const clone = require('clone-deep')
+import clone from '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
 
@@ -11,248 +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()
+  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()
+  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()
+    await assert.rejects(validate(manifest))
   })
 
   describe('schema', () => {
-    it('should be required', () => {
+    it('should be required', async () => {
       delete manifest.entity.schema
-      expect(() => validate(manifest)).toThrow()
+      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/)
+      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()
+    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([
+  for (const [_, operation] of [
     ['computation', 'compute']
-  ])('should set query: false for %s', async (_, operation) => {
+  ])
+     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(/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,7 +14,7 @@ const component = (id) => {
   }
 }
 
-const context = {
+export const context = {
   runtime: '0.0.0',
   name: 'test',
   description: 'context fixture',
@@ -42,7 +40,7 @@ const context = {
 }
 
 /** @type {Array<toa.norm.context.Composition>} */
-const compositions = [
+export const compositions = [
   ...context.compositions,
   {
     name: 'd-a',
@@ -53,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,7 +20,7 @@ const component = (id) => {
   }
 }
 
-const context = {
+export const context = {
   name: 'test',
   description: 'context fixture',
   version: '0.0.0',
@@ -41,7 +39,7 @@ const context = {
   ]
 }
 
-const expected = clone(context)
+export const expected = clone(context)
 
 expected.compositions = [
   {
@@ -53,6 +51,3 @@ expected.compositions = [
     components: [component('d.c'), component('a.b')]
   }
 ]
-
-exports.context = context
-exports.expected = expected