@toa.io/core 0.2.0-dev.3 → 0.2.1-dev.0

package/test/connector.fixtures.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const { random, timeout } = require('@toa.io/gears')
+const { random, timeout } = require('@toa.io/generic')
 const { Connector } = require('../src/connector')
 
 class TestConnector extends Connector {

package/test/connector.test.js

@@ -29,10 +29,8 @@ describe('callbacks', () => {
 
   it('should reconnect', async () => {
     await a.connect()
-    await a.disconnect()
-    await a.connect()
-    await a.disconnect()
-    await a.connect()
+    await a.reconnect()
+    await a.reconnect()
 
     expect(sequence).toEqual(['+a', '-a', '*a', '+a', '-a', '*a', '+a'])
   })
@@ -85,12 +83,8 @@ describe('dependencies', () => {
     expect(sequence.indexOf('+b')).toBeLessThan(sequence.indexOf('+a'))
   })
 
-  it('should not throw on empty array', async () => {
-    a.depends([])
-
-    await a.connect()
-
-    expect(sequence).toStrictEqual(['+a'])
+  it('should throw on empty array', async () => {
+    expect(() => a.depends([])).toThrow(/must not be empty/)
   })
 
   it('should await 2-way dependencies', async () => {
@@ -148,25 +142,8 @@ describe('dependencies', () => {
     expect(sequence).toEqual(['+c', '+a', '+b', '-a', '*a', '-b', '-c', '*c', '*b'])
   })
 
-  it('should not throw if depends not on Connector', async () => {
-    a.depends({})
-
-    await expect((async () => {
-      await a.connect()
-      await a.disconnect()
-    })()).resolves.not.toThrow()
-
-    b.depends([undefined, c, {}])
-
-    await expect((async () => {
-      await b.connect()
-      await b.disconnect()
-    })()).resolves.not.toThrow()
-
-    expect(sequence).toStrictEqual([
-      '+a', '-a', '*a',
-      '+c', '+b', '-b', '-c', '*c', '*b'
-    ])
+  it('should throw if depends not on Connector', async () => {
+    expect(() => a.depends({})).toThrow()
   })
 
   describe('errors', () => {

package/test/context.fixtures.js

@@ -0,0 +1,18 @@
+'use strict'
+
+const { Connector } = require('../src/connector')
+
+const local = {
+  link: jest.fn()
+}
+
+const discover = jest.fn(() => ({
+  invoke: jest.fn(),
+  link: jest.fn()
+}))
+
+const aspects = [new Connector(), new Connector()]
+
+exports.local = local
+exports.discover = discover
+exports.aspects = aspects

package/test/context.test.js

@@ -0,0 +1,29 @@
+'use strict'
+
+const fixtures = require('./context.fixtures')
+const { Context } = require('../src/context')
+
+/** @type {toa.core.Context} */
+let context
+
+beforeEach(() => {
+  jest.clearAllMocks()
+
+  context = new Context(fixtures.local, fixtures.discover, fixtures.aspects)
+})
+
+it('should expose aspects', () => {
+  expect(context.aspects).toBeDefined()
+  expect(context.aspects).toStrictEqual(fixtures.aspects)
+})
+
+describe('call', () => {
+  it('should discover once', async () => {
+    const request = {}
+
+    await context.call('a', 'b', 'c', request)
+    await context.call('a', 'b', 'c', request)
+
+    expect(fixtures.discover).toHaveBeenCalledTimes(1)
+  })
+})

package/test/contract/contract.fixtures.js

@@ -1,9 +1,10 @@
 'use strict'
 
 const { generate } = require('randomstring')
-const { yaml } = require('@toa.io/gears')
+const { load } = require('@toa.io/yaml')
 const { resolve } = require('path')
 
+// noinspection JSCheckFunctionSignatures
 const schema = {
   fit: jest.fn((input) => (input.invalid ? { message: generate() } : null))
 }
@@ -16,8 +17,12 @@ const declaration = {}
 
 const schemas = {
   request: {
-    properties: { query: yaml.sync(resolve(__dirname, '../../src/contract/schemas/query.yaml')) },
-    additionalProperties: false
+    type: 'object',
+    properties: {
+      input: { type: 'null' },
+      query: load.sync(resolve(__dirname, '../../src/contract/schemas/query.yaml'))
+    },
+    additionalProperties: true
   }
 }
 

package/test/contract/request.test.js

@@ -41,18 +41,23 @@ describe('schema', () => {
     expect(Request.schema({})).toBeDefined()
   })
 
-  it('should add required input', () => {
+  it('should add required input if defined', () => {
     const input = { type: 'number' }
 
     expect(Request.schema({ input }).properties.input).toStrictEqual(input)
   })
 
+  it('should set input as null if undefined', async () => {
+    expect(Request.schema({}).properties.input).toStrictEqual({ type: 'null' })
+  })
+
   it('should contain query if declaration.query is not defined', () => {
     expect(Request.schema({}).properties.query).toBeDefined()
   })
 
   it('should not contain query if declaration.query is false', () => {
     delete schema.properties.query
+    schema.not = { required: ['query'] }
     expect(Request.schema({ query: false })).toStrictEqual(schema)
   })
 
@@ -86,12 +91,18 @@ describe('schema', () => {
     expect(transition.omit).toBeUndefined()
     expect(transition.limit).toBeUndefined()
 
-    const entity = Request.schema({ type: 'observation', subject: 'entity' }).properties.query.properties
+    const entity = Request.schema({
+      type: 'observation',
+      scope: 'object'
+    }).properties.query.properties
 
     expect(entity.omit).toBeUndefined()
     expect(entity.limit).toBeUndefined()
 
-    const set = Request.schema({ type: 'observation', subject: 'set' }).properties.query.properties
+    const set = Request.schema({
+      type: 'observation',
+      scope: 'objects'
+    }).properties.query.properties
 
     expect(set.omit).toBeDefined()
     expect(set.limit).toBeDefined()

package/test/emission.fixtures.js

@@ -2,6 +2,7 @@
 
 const { generate } = require('randomstring')
 
+// noinspection JSCheckFunctionSignatures
 const events = [0, 1, 2].map((index) => ({
   emit: jest.fn(async (state) => ({ ...state, event: index }))
 }))

package/test/entities/entity.fixtures.js

@@ -1,16 +1,16 @@
 'use strict'
 
 const { generate } = require('randomstring')
-const clone = require('clone-deep')
 
+// noinspection JSCheckFunctionSignatures
 const schema = {
   fit: jest.fn((object) =>
-    (object.fail ? { [generate()]: generate() } : undefined)),
+    (object.fail ? { [generate()]: generate() } : null)),
 
   defaults: jest.fn(() => ({ [generate()]: generate() }))
 }
 
-const state = () => clone({
+const state = () => ({
   id: generate(),
   foo: generate(),
   _created: generate(),
@@ -19,7 +19,7 @@ const state = () => clone({
   _version: generate()
 })
 
-const failed = () => clone({ ...state(), fail: true })
+const failed = () => ({ ...state(), fail: true })
 
 exports.schema = schema
 exports.state = state

package/test/entities/entity.test.js

@@ -27,23 +27,18 @@ describe('new', () => {
 describe('argument', () => {
   it('should provide initial state if no argument passed', () => {
     const entity = new Entity(fixtures.schema)
+    const defaults = fixtures.schema.defaults.mock.results[0].value
+    const expected = { ...defaults, _version: 0 }
 
-    expect(entity.get()).toStrictEqual(fixtures.schema.defaults.mock.results[0].value)
+    expect(entity.get()).toStrictEqual(expected)
   })
 
-  it('should set provide origin state', () => {
+  it('should set state', () => {
     const state = fixtures.state()
     const entity = new Entity(fixtures.schema, state)
 
     expect(entity.get()).toStrictEqual(state)
   })
-
-  it('should not validate origin state', () => {
-    const state = fixtures.failed()
-    const entity = new Entity(fixtures.schema, state)
-
-    expect(entity.get()).toStrictEqual(state)
-  })
 })
 
 it('should provide event', () => {
@@ -58,7 +53,24 @@ it('should provide event', () => {
 
   expect(event).toStrictEqual({
     state,
-    origin: origin,
+    origin,
     changeset: { foo: 'new value' }
   })
 })
+
+it('should define `id` as readonly', async () => {
+  const origin = fixtures.state()
+  const entity = new Entity(fixtures.schema, origin)
+  const state = entity.get()
+
+  expect(() => (state.id = 1)).toThrow('assign to read only property')
+})
+
+it('should seal id', async () => {
+  const origin = fixtures.state()
+  const entity = new Entity(fixtures.schema, origin)
+  const state = entity.get()
+  const redefine = () => Object.defineProperty(state, 'id', { writable: true })
+
+  expect(redefine).toThrow('redefine property')
+})

package/test/entities/factory.test.js

@@ -27,16 +27,16 @@ it('should create initial', () => {
 })
 
 it('should create instance', () => {
-  const entity = factory.entity(fixtures.entity)
+  const object = factory.object(fixtures.entity)
 
-  expect(entity).toBeInstanceOf(mock.Entity)
-  expect(entity.constructor).toHaveBeenCalledWith(fixtures.schema, fixtures.entity)
+  expect(object).toBeInstanceOf(mock.Entity)
+  expect(object.constructor).toHaveBeenCalledWith(fixtures.schema, fixtures.entity)
 })
 
 it('should create set', () => {
-  const set = factory.set(fixtures.set)
+  const objects = factory.objects(fixtures.set)
 
-  expect(set).toBeInstanceOf(mock.EntitySet)
+  expect(objects).toBeInstanceOf(mock.EntitySet)
 
   const instances = fixtures.set.map((entity, index) => {
     expect(mock.Entity).toHaveBeenNthCalledWith(index + 1, fixtures.schema, entity)
@@ -44,5 +44,5 @@ it('should create set', () => {
     return mock.Entity.mock.instances[index]
   })
 
-  expect(set.constructor).toHaveBeenCalledWith(instances)
+  expect(objects.constructor).toHaveBeenCalledWith(instances)
 })

package/test/event.fixtures.js

@@ -7,6 +7,7 @@ const definition = {
   subjective: true
 }
 
+// noinspection JSCheckFunctionSignatures
 const bridge = {
   condition: jest.fn(async (origin) => !origin.falsy),
   payload: jest.fn(async () => ({ [generate()]: generate() }))

package/test/event.test.js

@@ -40,7 +40,9 @@ describe('condition', () => {
     it('should emit if condition returns true', async () => {
       await emit()
 
-      expect(fixtures.binding.emit).toHaveBeenCalledWith(await fixtures.bridge.payload.mock.results[0].value)
+      const payload = await fixtures.bridge.payload.mock.results[0].value
+      const message = { payload }
+      expect(fixtures.binding.emit).toHaveBeenCalledWith(message)
     })
 
     it('should not emit if condition returns false', async () => {
@@ -67,7 +69,11 @@ describe('condition', () => {
       await event.emit(fixtures.event.origin, fixtures.event.changeset, fixtures.event.state)
 
       expect(fixtures.bridge.condition).not.toHaveBeenCalledWith()
-      expect(fixtures.binding.emit).toHaveBeenCalledWith(await fixtures.bridge.payload.mock.results[0].value)
+
+      const payload = await fixtures.bridge.payload.mock.results[0].value
+      const message = { payload }
+
+      expect(fixtures.binding.emit).toHaveBeenCalledWith(message)
     })
   })
 })
@@ -77,7 +83,10 @@ describe('payload', () => {
     it('should emit payload', async () => {
       await emit()
 
-      expect(fixtures.binding.emit).toHaveBeenCalledWith(await fixtures.bridge.payload.mock.results[0].value)
+      const payload = await fixtures.bridge.payload.mock.results[0].value
+      const message = { payload }
+
+      expect(fixtures.binding.emit).toHaveBeenCalledWith(message)
     })
   })
 
@@ -100,7 +109,10 @@ describe('payload', () => {
     it('should return state as payload', async () => {
       await emit()
 
-      expect(fixtures.binding.emit).toHaveBeenCalledWith(fixtures.event.state)
+      const payload = fixtures.event.state
+      const message = { payload }
+
+      expect(fixtures.binding.emit).toHaveBeenCalledWith(message)
     })
   })
 })

package/test/locator.test.js

@@ -1,24 +1,81 @@
 'use strict'
 
+const { generate } = require('randomstring')
 const { Locator } = require('../src/locator')
 
-const manifest = {
-  domain: 'foo',
-  name: 'bar',
-  entity: { schema: { foo: 'bar' } },
-  operations: { add: { query: false }, get: { output: null } }
-}
-
-const nameless = {
-  domain: 'foo',
-  entity: { schema: { foo: 'bar' } },
-  operations: [{ name: 'add' }, { name: 'get' }]
-}
-
-it('should provide host', () => {
-  expect(new Locator(manifest).host('db')).toBe('foo-db')
-  expect(new Locator(nameless).host('db')).toBe('foo-db')
-  expect(new Locator(nameless).host('DB')).toBe('foo-db')
-  expect(new Locator(manifest).host('db', 1)).toBe('foo-bar-db')
-  expect(new Locator(nameless).host('db', 1)).toBe('foo-db')
+/** @type {string} */
+let name
+
+/** @type {string} */
+let namespace
+
+/** @type {toa.core.Locator} */
+let locator
+
+beforeEach(() => {
+  name = generate()
+  namespace = generate()
+
+  locator = new Locator(name, namespace)
+})
+
+it('should expose name and namespace', () => {
+  expect(locator.name).toStrictEqual(name)
+  expect(locator.namespace).toStrictEqual(namespace)
+})
+
+it('should expose id, label', () => {
+  const id = locator.namespace + '.' + locator.name
+  const label = locator.namespace.toLowerCase() + '-' + locator.name.toLowerCase()
+
+  expect(locator.id).toStrictEqual(id)
+  expect(locator.label).toStrictEqual(label)
+})
+
+it('should expose uppercase', () => {
+  expect(locator.uppercase).toStrictEqual((locator.namespace + '_' + locator.name).toUpperCase())
+})
+
+it('should throw if name is undefined', () => {
+  expect(() => new Locator(undefined, namespace)).toThrow(TypeError)
+
+  // noinspection JSCheckFunctionSignatures
+  expect(() => new Locator()).toThrow(TypeError)
+})
+
+it('should expose host', () => {
+  expect(locator.hostname()).toStrictEqual((namespace + '-' + name).toLowerCase())
+})
+
+it('should expose host with given prefix', () => {
+  const prefix = generate()
+
+  expect(locator.hostname(prefix)).toStrictEqual((prefix + '-' + namespace + '-' + name).toLowerCase())
+})
+
+describe('global', () => {
+  beforeEach(() => {
+    locator = new Locator(name)
+  })
+
+  it('should not throw', () => undefined)
+
+  it('should expose id', () => {
+    expect(locator.id).toStrictEqual(name)
+  })
+
+  it('should expose label', () => {
+    expect(locator.label).toStrictEqual(name.toLowerCase())
+  })
+
+  it('should expose uppercase', () => {
+    expect(locator.uppercase).toStrictEqual(name.toUpperCase())
+  })
+
+  it('should expose hostname', () => {
+    const type = generate()
+
+    expect(locator.hostname(type)).toStrictEqual((type + '-' + name).toLowerCase())
+    expect(locator.hostname()).toStrictEqual(name.toLowerCase())
+  })
 })

package/test/receiver.fixtures.js

@@ -2,19 +2,20 @@
 
 const { generate } = require('randomstring')
 
-const definition = {
+const definition = /** @type {toa.norm.component.Receiver} */ {
   transition: generate(),
   conditioned: false,
   adaptive: false
 }
 
-const local = {
+const local = /** @type {toa.core.Component} */ {
   invoke: jest.fn()
 }
 
-const bridge = {
-  condition: jest.fn((payload) => !(payload.reject === true)),
-  request: jest.fn(() => generate())
+// noinspection JSCheckFunctionSignatures
+const bridge = /** @type {toa.core.bridges.Event} */ {
+  condition: jest.fn(async (payload) => !(payload.reject === true)),
+  request: jest.fn(async () => ({ input: generate() }))
 }
 
 exports.definition = definition

package/test/receiver.test.js

@@ -1,17 +1,25 @@
 'use strict'
 
 const clone = require('clone-deep')
+const { generate } = require('randomstring')
+const { merge } = require('@toa.io/generic')
 
 jest.mock('../src/connector')
 
-const { Connector } = require('../src/connector')
+const { Connector } = /** @type {{ Connector: jest.Mock<toa.core.Connector>}} */ require('../src/connector')
 
 const { Receiver } = require('../src/receiver')
 const fixtures = require('./receiver.fixtures')
 
-let receiver, definition
+/** @type {toa.core.Receiver} */
+let receiver
+
+/** @type {toa.norm.component.Receiver} */
+let definition
 
 beforeEach(() => {
+  jest.clearAllMocks()
+
   definition = clone(fixtures.definition)
   receiver = new Receiver(fixtures.definition, fixtures.local, fixtures.bridge)
 })
@@ -23,11 +31,32 @@ it('should depend on local, bridge', () => {
 
 it('should apply', async () => {
   const payload = { foo: 'bar' }
-  await receiver.receive(payload)
+
+  await receiver.receive({ payload })
 
   expect(fixtures.local.invoke).toHaveBeenCalledWith(definition.transition, payload)
 })
 
+it.each([[false], [true]])('should pass UI extensions (adaptive: %s)', async (adaptive) => {
+  jest.clearAllMocks()
+
+  definition.adaptive = adaptive
+  receiver = new Receiver(definition, fixtures.local, fixtures.bridge)
+
+  const payload = { foo: generate() }
+  const extension = { [generate()]: generate() }
+  const message = { payload, ...extension }
+
+  await receiver.receive(message)
+
+  const request = adaptive ? await fixtures.bridge.request.mock.results[0].value : payload
+  const expected = merge(clone(request), extension)
+
+  const argument = fixtures.local.invoke.mock.calls[0][1]
+
+  expect(argument).toStrictEqual(expected)
+})
+
 describe('conditioned', () => {
   beforeEach(() => {
     definition.conditioned = true
@@ -36,7 +65,7 @@ describe('conditioned', () => {
 
   it('should test condition', async () => {
     const payload = { foo: 'bar' }
-    await receiver.receive(payload)
+    await receiver.receive({ payload })
 
     expect(fixtures.bridge.condition).toHaveBeenCalledWith(payload)
     expect(fixtures.local.invoke).toHaveBeenCalledWith(definition.transition, payload)
@@ -44,7 +73,7 @@ describe('conditioned', () => {
 
   it('should not apply if condition is false', async () => {
     const payload = { reject: true }
-    await receiver.receive(payload)
+    await receiver.receive({ payload })
 
     expect(fixtures.local.invoke).not.toHaveBeenCalled()
   })
@@ -58,9 +87,9 @@ describe('adaptive', () => {
 
   it('should apply', async () => {
     const payload = { reject: true }
-    await receiver.receive(payload)
+    await receiver.receive({ payload })
 
     expect(fixtures.local.invoke)
-      .toHaveBeenCalledWith(definition.transition, fixtures.bridge.request.mock.results[0].value)
+      .toHaveBeenCalledWith(definition.transition, await fixtures.bridge.request.mock.results[0].value)
   })
 })

package/test/reflection.test.js

@@ -0,0 +1,30 @@
+'use strict'
+
+const { generate } = require('randomstring')
+const { Reflection, Connector } = require('../')
+
+it('should export', () => {
+  expect(Reflection).toBeDefined()
+})
+
+/** @type {toa.core.Reflection<string>} */
+let reflection
+
+const value = generate()
+
+/** @type {toa.core.reflection.Source<string>} */
+const source = async () => value
+
+beforeEach(() => {
+  reflection = new Reflection(source)
+})
+
+it('should be a Connector', () => {
+  expect(reflection).toBeInstanceOf(Connector)
+})
+
+it('should reflect', async () => {
+  await reflection.connect()
+
+  expect(reflection.value).toStrictEqual(value)
+})

package/test/state.fixtures.js

@@ -12,20 +12,21 @@ const storage = {
 }
 
 const factory = {
-  entity: jest.fn(() => ({ [generate()]: generate() })),
-  set: jest.fn(() => ({ [generate()]: generate() }))
+  object: jest.fn(() => ({ [generate()]: generate() })),
+  objects: jest.fn(() => ({ [generate()]: generate() }))
 }
 
 const query = generate()
 
 const entity = {
   get: jest.fn(() => ({ [generate()]: generate() })),
-  event: jest.fn(() => ({ state: { [generate()]: generate() }, changeset: { [generate()]: generate() } }))
+  event: jest.fn(() => ({
+    state: { [generate()]: generate() }, changeset: { [generate()]: generate() }
+  }))
 }
 
 const initial = {
-  initial: true,
-  ...entity
+  initial: true, ...entity
 }
 
 const unchanged = {