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

package/test/event.test.js

@@ -1,118 +0,0 @@
-'use strict'
-
-const clone = require('clone-deep')
-
-jest.mock('../src/connector')
-
-const { Connector } = require('../src/connector')
-const { Event } = require('../src/event')
-const fixtures = require('./event.fixtures')
-
-let event, emit
-
-beforeEach(() => {
-  jest.clearAllMocks()
-
-  event = new Event(fixtures.definition, fixtures.binding, fixtures.bridge)
-  emit = () => event.emit(fixtures.event)
-})
-
-it('should depend on binding', () => {
-  expect(event).toBeInstanceOf(Connector)
-  expect(Connector.mock.instances[0].depends).toHaveBeenCalledWith(fixtures.binding)
-})
-
-it('should depend on bridge if provided', () => {
-  expect(Connector.mock.instances[0].depends).toHaveBeenCalledWith(fixtures.bridge)
-
-  event = new Event(fixtures.definition, fixtures.binding)
-  expect(Connector.mock.instances[1].depends).not.toHaveBeenCalledWith(fixtures.bridge)
-})
-
-describe('condition', () => {
-  describe('conditioned', () => {
-    it('should call condition', async () => {
-      await emit()
-
-      expect(fixtures.bridge.condition).toHaveBeenCalledWith(fixtures.event)
-    })
-
-    it('should emit if condition returns true', async () => {
-      await emit()
-
-      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 () => {
-      const origin = clone(fixtures.event.origin)
-
-      origin.falsy = true
-
-      await event.emit(origin, fixtures.event.changeset, fixtures.event.state)
-
-      expect(fixtures.binding.emit).not.toHaveBeenCalled()
-    })
-  })
-
-  describe('unconditioned', () => {
-    beforeEach(() => {
-      const definition = clone(fixtures.definition)
-
-      definition.conditioned = false
-
-      event = new Event(definition, fixtures.binding, fixtures.bridge)
-    })
-
-    it('should not call condition', async () => {
-      await event.emit(fixtures.event.origin, fixtures.event.changeset, fixtures.event.state)
-
-      expect(fixtures.bridge.condition).not.toHaveBeenCalledWith()
-
-      const payload = await fixtures.bridge.payload.mock.results[0].value
-      const message = { payload }
-
-      expect(fixtures.binding.emit).toHaveBeenCalledWith(message)
-    })
-  })
-})
-
-describe('payload', () => {
-  describe('subjective', () => {
-    it('should emit payload', async () => {
-      await emit()
-
-      const payload = await fixtures.bridge.payload.mock.results[0].value
-      const message = { payload }
-
-      expect(fixtures.binding.emit).toHaveBeenCalledWith(message)
-    })
-  })
-
-  describe('objective', () => {
-    beforeEach(() => {
-      const definition = clone(fixtures.definition)
-
-      definition.subjective = false
-
-      event = new Event(definition, fixtures.binding, fixtures.bridge)
-      emit = () => event.emit(fixtures.event)
-    })
-
-    it('should not call payload', async () => {
-      await emit()
-
-      expect(fixtures.bridge.payload).not.toHaveBeenCalled()
-    })
-
-    it('should return state as payload', async () => {
-      await emit()
-
-      const payload = fixtures.event.state
-      const message = { payload }
-
-      expect(fixtures.binding.emit).toHaveBeenCalledWith(message)
-    })
-  })
-})

package/test/locator.test.js

@@ -1,113 +0,0 @@
-'use strict'
-
-const { generate } = require('randomstring')
-const { Locator } = require('../src/locator')
-
-/** @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())
-  })
-})
-
-describe('parse', () => {
-  it('should be', async () => {
-    expect(Locator.parse).toBeInstanceOf(Function)
-  })
-
-  const namespace = generate()
-  const name = generate()
-  const id = `${namespace}.${name}`
-
-  it('should parse id', async () => {
-    const locator = Locator.parse(id)
-
-    expect(locator.namespace).toStrictEqual(namespace)
-    expect(locator.name).toStrictEqual(name)
-  })
-
-  it('should parse endpoint', async () => {
-    const endpoint = `${id}.${generate()}`
-    const locator = Locator.parse(endpoint)
-
-    expect(locator.namespace).toStrictEqual(namespace)
-    expect(locator.name).toStrictEqual(name)
-  })
-
-  it('should parse token as global', async () => {
-    const locator = Locator.parse(name)
-
-    expect(locator.namespace).toBeUndefined()
-    expect(locator.name).toStrictEqual(name)
-  })
-})

package/test/query.fixtures.js

@@ -1,100 +0,0 @@
-'use strict'
-
-const samples = {
-  simple: {
-    query: {
-      criteria: 'name==Eddie'
-    },
-    parsed: {
-      criteria: {
-        type: 'COMPARISON',
-        left: { type: 'SELECTOR', selector: 'name' },
-        operator: '==',
-        right: { type: 'VALUE', value: 'Eddie' }
-      }
-    },
-    properties: {
-      name: {
-        type: 'string'
-      }
-    }
-  },
-
-  extended: {
-    query: {
-      criteria: 'flag==true;volume>2.1'
-    },
-    parsed: {
-      criteria: {
-        type: 'LOGIC',
-        left: {
-          type: 'COMPARISON',
-          left: { type: 'SELECTOR', selector: 'flag' },
-          operator: '==',
-          right: { type: 'VALUE', value: true }
-        },
-        operator: ';',
-        right: {
-          type: 'COMPARISON',
-          left: { type: 'SELECTOR', selector: 'volume' },
-          operator: '>',
-          right: { type: 'VALUE', value: 2.1 }
-        }
-      }
-    },
-    properties: {
-      flag: {
-        type: 'boolean'
-      },
-      volume: {
-        type: 'number'
-      }
-    }
-  },
-
-  abc: {
-    properties: {
-      a: {
-        type: 'string'
-      },
-      b: {
-        type: 'string'
-      },
-      c: {
-        type: 'string'
-      }
-    }
-  },
-
-  id: {
-    properties: {
-      id: {
-        type: 'string'
-      },
-      name: {
-        type: 'string'
-      }
-    },
-    query: {
-      id: '123',
-      criteria: 'name==Eddie'
-    },
-    parsed: {
-      id: '123',
-      criteria: {
-        type: 'COMPARISON',
-        left: {
-          type: 'SELECTOR',
-          selector: 'name'
-        },
-        operator: '==',
-        right: {
-          type: 'VALUE',
-          value: 'Eddie'
-        }
-      }
-    }
-  }
-}
-
-exports.samples = samples

package/test/query.test.js

@@ -1,86 +0,0 @@
-'use strict'
-
-const { Query } = require('../src/query')
-const fixtures = require('./query.fixtures')
-
-beforeEach(() => {
-  jest.clearAllMocks()
-})
-
-describe('criteria', () => {
-  it('should not throw if no criteria', () => {
-    const instance = new Query(fixtures.samples.simple.properties)
-    const query = instance.parse({})
-
-    expect(query.criteria).toBeUndefined()
-  })
-
-  it('should parse criteria', () => {
-    const instance = new Query(fixtures.samples.simple.properties)
-    const query = instance.parse(fixtures.samples.simple.query)
-
-    expect(query.criteria).toEqual(fixtures.samples.simple.parsed.criteria)
-  })
-
-  it('should parse criteria with type coercion', () => {
-    const instance = new Query(fixtures.samples.extended.properties)
-    const query = instance.parse(fixtures.samples.extended.query)
-
-    expect(query.criteria).toEqual(fixtures.samples.extended.parsed.criteria)
-  })
-
-  it('should throw on unknown properties', () => {
-    const instance = new Query(fixtures.samples.simple.properties)
-
-    expect(() => instance.parse({ criteria: 'lastname==Johnson' })).toThrow(/not defined/)
-  })
-
-  it('should parse id', () => {
-    const instance = new Query(fixtures.samples.id.properties)
-    const query = instance.parse({ ...fixtures.samples.id.query })
-
-    expect(query).toStrictEqual(fixtures.samples.id.parsed)
-  })
-})
-
-describe('options', () => {
-  const instance = new Query(fixtures.samples.abc.properties)
-
-  it('should not throw if no options', () => {
-    const query = instance.parse({})
-
-    expect(query.options).toBeUndefined()
-  })
-
-  describe('omit, limit', () => {
-    it('should pass', () => {
-      const input = { omit: 1, limit: 1 }
-      const query = instance.parse(input)
-
-      expect(query.options).toStrictEqual(input)
-    })
-  })
-
-  describe('sort', () => {
-    it('should set default values', () => {
-      const sort = ['a', 'b:desc', 'c']
-      const query = instance.parse({ sort })
-
-      expect(query.options.sort).toStrictEqual([['a', 'asc'], ['b', 'desc'], ['c', 'asc']])
-    })
-
-    it('should throw on unknown properties', () => {
-      const sort = ['d:asc']
-
-      expect(() => instance.parse({ sort })).toThrow(/not defined/)
-    })
-  })
-
-  describe('projection', () => {
-    it('should throw on unknown properties', () => {
-      const projection = ['a', 'b', 'c', 'd']
-
-      expect(() => instance.parse({ projection })).toThrow(/not defined/)
-    })
-  })
-})

package/test/receiver.fixtures.js

@@ -1,23 +0,0 @@
-'use strict'
-
-const { generate } = require('randomstring')
-
-const definition = /** @type {toa.norm.component.Receiver} */ {
-  operation: generate(),
-  conditioned: false,
-  adaptive: false
-}
-
-const local = /** @type {toa.core.Component} */ {
-  invoke: jest.fn()
-}
-
-// 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
-exports.local = local
-exports.bridge = bridge

package/test/receiver.test.js

@@ -1,95 +0,0 @@
-'use strict'
-
-const clone = require('clone-deep')
-const { generate } = require('randomstring')
-const { merge } = require('@toa.io/generic')
-
-jest.mock('../src/connector')
-
-const { Connector } = /** @type {{ Connector: jest.Mock<toa.core.Connector>}} */ require('../src/connector')
-
-const { Receiver } = require('../src/receiver')
-const fixtures = require('./receiver.fixtures')
-
-/** @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)
-})
-
-it('should depend on local, bridge', () => {
-  expect(Connector.mock.instances[0].depends).toHaveBeenCalledWith(fixtures.local)
-  expect(Connector.mock.instances[0].depends).toHaveBeenCalledWith(fixtures.bridge)
-})
-
-it('should apply', async () => {
-  const payload = { foo: 'bar' }
-
-  await receiver.receive({ payload })
-
-  expect(fixtures.local.invoke).toHaveBeenCalledWith(definition.operation, { input: 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 : { input: 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
-    receiver = new Receiver(definition, fixtures.local, fixtures.bridge)
-  })
-
-  it('should test condition', async () => {
-    const payload = { foo: 'bar' }
-    await receiver.receive({ payload })
-
-    expect(fixtures.bridge.condition).toHaveBeenCalledWith(payload)
-    expect(fixtures.local.invoke).toHaveBeenCalledWith(definition.operation, { input: payload })
-  })
-
-  it('should not apply if condition is false', async () => {
-    const payload = { reject: true }
-    await receiver.receive({ payload })
-
-    expect(fixtures.local.invoke).not.toHaveBeenCalled()
-  })
-})
-
-describe('adaptive', () => {
-  beforeEach(() => {
-    definition.adaptive = true
-    receiver = new Receiver(definition, fixtures.local, fixtures.bridge)
-  })
-
-  it('should apply', async () => {
-    const payload = { reject: true }
-    await receiver.receive({ payload })
-
-    expect(fixtures.local.invoke)
-      .toHaveBeenCalledWith(definition.operation, await fixtures.bridge.request.mock.results[0].value)
-  })
-})

package/test/reflection.test.js

@@ -1,30 +0,0 @@
-'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

@@ -1,47 +0,0 @@
-'use strict'
-
-const { generate } = require('randomstring')
-
-const storage = {
-  name: 'dummy',
-  get: jest.fn(() => ({ id: generate() })),
-  find: jest.fn(() => ([{ id: generate() }])),
-  add: jest.fn(() => true),
-  set: jest.fn(() => true),
-  store: jest.fn(() => true)
-}
-
-const factory = {
-  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() }
-  }))
-}
-
-const initial = {
-  initial: true, ...entity
-}
-
-const unchanged = {
-  ...entity,
-  event: jest.fn(() => ({ state: { [generate()]: generate() }, changeset: {} }))
-}
-
-const emitter = {
-  emit: jest.fn()
-}
-
-exports.storage = storage
-exports.factory = factory
-exports.emitter = emitter
-exports.query = query
-exports.entity = entity
-exports.initial = initial
-exports.unchanged = unchanged

package/test/state.test.js

@@ -1,46 +0,0 @@
-'use strict'
-
-const { State } = require('../src/state')
-const fixtures = require('./state.fixtures')
-
-let state
-
-beforeEach(() => {
-  jest.clearAllMocks()
-
-  state = new State(fixtures.storage, fixtures.factory, fixtures.emitter)
-})
-
-it('should provide object', async () => {
-  const entity = await state.object(fixtures.query)
-
-  expect(fixtures.storage.get).toHaveBeenCalledWith(fixtures.query)
-  expect(entity).toStrictEqual(fixtures.factory.object.mock.results[0].value)
-  expect(fixtures.factory.object).toHaveBeenCalledWith(fixtures.storage.get.mock.results[0].value)
-})
-
-it('should provide objects', async () => {
-  const set = await state.objects(fixtures.query)
-
-  expect(fixtures.storage.find).toHaveBeenCalledWith(fixtures.query)
-  expect(set).toStrictEqual(fixtures.factory.objects.mock.results[0].value)
-  expect(fixtures.factory.objects).toHaveBeenCalledWith(fixtures.storage.find.mock.results[0].value)
-})
-
-it('should store entity', async () => {
-  await state.commit(fixtures.initial)
-
-  expect(fixtures.storage.store).toHaveBeenCalledWith(fixtures.initial.get.mock.results[0].value)
-})
-
-it('should emit', async () => {
-  await state.commit(fixtures.entity)
-
-  expect(fixtures.emitter.emit).toHaveBeenCalledWith(fixtures.entity.event.mock.results[0].value)
-})
-
-it('should not emit if state has not been changed', async () => {
-  await state.commit(fixtures.unchanged)
-
-  expect(fixtures.emitter.emit).not.toHaveBeenCalled()
-})

package/test/transmission.fixtures.js

@@ -1,15 +0,0 @@
-'use strict'
-
-const { generate } = require('randomstring')
-
-const binding = (index) => ({
-  request: jest.fn(async (request) => {
-    if (request?.pick !== undefined && request.pick !== index) return false
-
-    return { output: generate() }
-  })
-})
-
-const bindings = [0, 1, 2, 3, 4].map(binding)
-
-exports.bindings = bindings