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

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
 
@@ -11,18 +12,21 @@ beforeEach(() => {
   source = clone(fixtures.source)
 })
 
-it('should expand', () => {
-  expand(source)
-  expect(source).toMatchObject(fixtures.target)
+it('should expand', async () => {
+  await expand(source)
+  assert.partialDeepStrictEqual(source, fixtures.target)
 })
 
-it('should recognize storages.queues', async () => {
-  const queues = { foo: 'bar' }
+it('should derive version from the component contents', async () => {
+  await expand(source)
 
-  source.queues = clone(queues)
+  assert.match(source.version, /^[0-9a-f]{8}$/)
+})
+
+it('should keep declared version', async () => {
+  source.version = '1.0.0'
 
-  expand(source)
+  await expand(source)
 
-  expect(source.queues).toBeUndefined()
-  expect(source.properties['@toa.io/storages.queues']).toMatchObject(queues)
+  assert.deepStrictEqual(source.version, '1.0.0')
 })

package/test/component/migrations.test.js

@@ -0,0 +1,62 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import { join } from 'node:path'
+
+import { migrations } from '../../src/.component/index.js'
+
+const DUMMIES = join(import.meta.dirname, 'dummies/migrations')
+
+const entity = () => ({ entity: { schema: { properties: {} } } })
+
+describe('migrations', () => {
+  it('should read a directory of migrations', async () => {
+    const manifest = entity()
+
+    await migrations(join(DUMMIES, 'ordered'), manifest)
+
+    assert.deepEqual(
+      manifest.entity.migrations.map(({ id }) => id),
+      ['0001-first', '0002-second', '0010-third']
+    )
+  })
+
+  it('should read whatever extension each was written with', async () => {
+    const manifest = entity()
+
+    await migrations(join(DUMMIES, 'ordered'), manifest)
+
+    assert.deepEqual(manifest.entity.migrations[0].steps, [
+      { index: { name: 'index_a', keys: { a: 'asc' } } }
+    ])
+    assert.deepEqual(manifest.entity.migrations[2].steps, [{ delete: { filter: {} } }])
+  })
+
+  it('should leave a component with no migrations alone', async () => {
+    const manifest = entity()
+
+    await migrations(join(DUMMIES, 'nothing-here'), manifest)
+
+    assert.equal(manifest.entity.migrations, undefined)
+  })
+
+  it('should refuse two files resolving to one id', async () => {
+    await assert.rejects(
+      migrations(join(DUMMIES, 'conflicting'), entity()),
+      /has more than one migrations\/0001-one/
+    )
+  })
+
+  it('should refuse migrations on a component that stores nothing', async () => {
+    await assert.rejects(
+      migrations(join(DUMMIES, 'stateless'), {}),
+      /declares migrations but stores nothing/
+    )
+  })
+
+  it('should refuse a migration that is not a list of steps', async () => {
+    await assert.rejects(
+      migrations(join(DUMMIES, 'malformed'), entity()),
+      /is not a list of steps/
+    )
+  })
+})

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,10 +1,10 @@
-'use strict'
+import { describe, it, beforeEach } from 'node:test'
+import assert from 'node:assert/strict'
 
-const { dirname } = require('node:path')
-const clone = require('clone-deep')
+import clone from 'clone-deep'
 
-const { normalize } = require('../../src/.component')
-const fixtures = require('./normalize.fixtures')
+import { normalize, extensions } from '../../src/.component/index.js'
+import * as fixtures from './normalize.fixtures.js'
 
 let manifest
 
@@ -13,51 +13,117 @@ 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)
+  })
+
+  it('should state an empty output where none is declared', async () => {
+    await normalize(manifest)
+
+    assert.deepStrictEqual(manifest.operations.add.output, {})
+  })
+
+  it('should state no input for an operation that takes none', async () => {
+    manifest.operations.compute = { type: 'computation', input: null }
+
+    await normalize(manifest)
+
+    assert.equal('input' in manifest.operations.compute, false)
+  })
+
+  it('should scope a computation to none', async () => {
+    manifest.operations.compute = { type: 'computation' }
+
+    await normalize(manifest)
+
+    assert.deepStrictEqual(manifest.operations.compute.scope, 'none')
+    assert.deepStrictEqual(manifest.operations.compute.query, false)
+  })
+
+  it('should scope an effect to none unless it says otherwise', async () => {
+    manifest.operations.affect = { type: 'effect' }
+    manifest.operations.reach = { type: 'effect', scope: 'entries' }
+
+    await normalize(manifest)
+
+    assert.deepStrictEqual(manifest.operations.affect.scope, 'none')
+    assert.deepStrictEqual(manifest.operations.reach.scope, 'entries')
+  })
+})
+
+describe('namespace', () => {
+  it('should default to `default`', async () => {
+    delete manifest.namespace
+
+    await normalize(manifest)
+
+    assert.deepStrictEqual(manifest.namespace, 'default')
+  })
+})
+
+describe('entity', () => {
+  it('should default storage and flags', async () => {
+    manifest.entity = { properties: {} }
+
+    await normalize(manifest)
+
+    assert.deepStrictEqual(manifest.entity.storage, '@toa.io/storages.mongodb')
+    assert.deepStrictEqual(manifest.entity.associated, false)
+    assert.deepStrictEqual(manifest.entity.custom, false)
+  })
+
+  it('should allow a date-time on the record', async () => {
+    manifest.entity = { properties: { settled: { type: 'string', format: 'date-time' } } }
+
+    await normalize(manifest)
+
+    assert.deepStrictEqual(manifest.entity.properties.settled.format, 'date-time')
   })
 })
 
 describe('extensions', () => {
-  it('should resolve absolute references', () => {
-    const origins = manifest.extensions['@toa.io/extensions.origins']
-    const path = dirname(require.resolve('@toa.io/extensions.origins/package.json'))
+  it('should add predefined extensions', async () => {
+    await extensions(manifest)
+
+    // telemetry normalizes its declaration, so a component that declares nothing has an
+    // empty one rather than none; fetch has no manifest of its own to normalize
+    assert.deepStrictEqual(manifest.extensions['@toa.io/extensions.telemetry'], {})
+    assert.strictEqual(manifest.extensions['@toa.io/extensions.fetch'], null)
+  })
 
-    normalize(manifest)
+  it('should add predefined extensions without explicit declarations', async () => {
+    delete manifest.extensions
 
-    expect(manifest.extensions[path]).toStrictEqual(origins)
+    await extensions(manifest)
+
+    assert.deepStrictEqual(manifest.extensions, {
+      '@toa.io/extensions.telemetry': {},
+      '@toa.io/extensions.fetch': null,
+      '@toa.io/extensions.introspection': {}
+    })
   })
 })
 
 describe('receivers', () => {
   it('should substitute default namespace', async () => {
     manifest.receivers = {
-      'messages.created': 'add'
+      'messages.created': { operation: 'add' }
     }
 
-    normalize(manifest)
+    await normalize(manifest)
 
-    expect(manifest.receivers).toStrictEqual({
-      'default.messages.created': 'add'
-    })
+    assert.deepStrictEqual(Object.keys(manifest.receivers), ['default.messages.created'])
   })
 
   it('should not substitute default namespace for foreign events', async () => {
-    const receiver = {
-      transition: 'add',
-      source: 'test'
-    }
-
     manifest.receivers = {
-      'messages.created': receiver
+      'messages.created': { transition: 'add', source: 'test' }
     }
 
-    normalize(manifest)
+    await normalize(manifest)
 
-    expect(manifest.receivers).toStrictEqual({
-      'messages.created': receiver
-    })
+    assert.deepStrictEqual(Object.keys(manifest.receivers), ['messages.created'])
   })
 })

package/test/component/validate.fixtures.js

@@ -1,31 +1,29 @@
-'use strict'
-
-const ok = {
+export const ok = {
   namespace: 'foo',
   name: 'bar',
   entity: {
     storage: 'whatever',
-    schema: {
-      properties: {
-        name: {
-          type: 'string',
-          minLength: 1,
-          maxLength: 128
-        }
+    associated: false,
+    custom: false,
+    properties: {
+      name: {
+        type: 'string',
+        minLength: 1,
+        maxLength: 128
       }
     }
   },
   operations: {
     get: {
       type: 'observation',
-      scope: 'objects',
+      scope: 'entries',
       bridge: 'whatever',
       bindings: ['@toa.io/bindings.amqp']
     },
     add: {
       type: 'transition',
       concurrency: 'none',
-      scope: 'object',
+      scope: 'entry',
       bridge: 'whatever',
       bindings: ['@toa.io/bindings.amqp']
     },
@@ -37,11 +35,15 @@ const ok = {
     },
     compute: {
       type: 'computation',
+      scope: 'none',
+      query: false,
       bridge: 'whatever',
       bindings: ['@toa.io/bindings.amqp']
     },
     affect: {
       type: 'effect',
+      scope: 'none',
+      query: false,
       bridge: 'whatever',
       bindings: ['@toa.io/bindings.amqp']
     }
@@ -60,9 +62,9 @@ const ok = {
       operation: 'add',
       bridge: 'whatever',
       binding: 'amqp',
-      path: '/somewhere'
+      path: '/somewhere',
+      conditioned: false,
+      adaptive: false
     }
   }
 }
-
-exports.ok = ok