@toa.io/core 1.0.0-alpha.30 → 1.0.0-alpha.300

package/test/emission.test.js

@@ -1,35 +0,0 @@
-'use strict'
-
-jest.mock('../src/connector')
-
-const clone = require('clone-deep')
-
-const { Connector } = require('../src/connector')
-const { Emission } = require('../src/emission')
-const fixtures = require('./emission.fixtures')
-
-let emission, event
-
-beforeEach(async () => {
-  jest.clearAllMocks()
-
-  emission = new Emission(fixtures.events)
-  event = clone(fixtures.event)
-
-  await emission.open()
-})
-
-it('should depend on events', () => {
-  expect(emission).toBeInstanceOf(Connector)
-  expect(Connector.mock.instances[0].depends).toHaveBeenCalledWith(fixtures.events)
-})
-
-it('should emit events', async () => {
-  expect.assertions(fixtures.events.length)
-
-  await emission.emit(event)
-
-  for (const evt of fixtures.events) {
-    expect(evt.emit).toHaveBeenCalledWith(event)
-  }
-})

package/test/entities/entity.fixtures.js

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

package/test/entities/entity.test.js

@@ -1,65 +0,0 @@
-'use strict'
-
-const { Entity } = require('../../src/entities/entity')
-const fixtures = require('./entity.fixtures')
-
-beforeEach(() => {
-  jest.clearAllMocks()
-})
-
-describe('new', () => {
-  it('should throw on schema error', () => {
-    const entity = new Entity(fixtures.schema)
-
-    expect(() => entity.set(fixtures.failed())).toThrow()
-  })
-
-  it('should provide state', () => {
-    const entity = new Entity(fixtures.schema)
-    const state = fixtures.state()
-
-    entity.set(state)
-
-    expect(entity.get()).toEqual(state)
-  })
-})
-
-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(expect.objectContaining(expected))
-  })
-
-  it('should set state', () => {
-    const state = fixtures.state()
-    const entity = new Entity(fixtures.schema, state)
-
-    expect(entity.get()).toEqual(state)
-  })
-})
-
-it('should provide event', () => {
-  const origin = fixtures.state()
-  const entity = new Entity(fixtures.schema, origin)
-  const state = entity.get()
-
-  state.foo = 'new value'
-  entity.set(state)
-
-  const event = entity.event()
-
-  expect(event).toEqual(expect.objectContaining({
-    state,
-    origin,
-    changeset: expect.objectContaining({
-      foo: 'new value',
-      _version: 1
-    })
-  }))
-})

package/test/entities/factory.fixtures.js

@@ -1,18 +0,0 @@
-'use strict'
-
-const randomstring = require('randomstring')
-
-const schema = { [randomstring.generate()]: randomstring.generate() }
-const storage = { id: jest.fn(() => randomstring.generate()) }
-const entity = { [randomstring.generate()]: randomstring.generate() }
-const set = Array.from(Array(5))
-  .map((_, index) => ({ id: index, [randomstring.generate()]: randomstring.generate() }))
-
-const Entity = jest.fn().mockImplementation(function () { this.id = randomstring.generate() })
-const EntitySet = jest.fn().mockImplementation(function () {})
-
-exports.schema = schema
-exports.storage = storage
-exports.entity = entity
-exports.set = set
-exports.mock = { Entity, EntitySet }

package/test/entities/factory.test.js

@@ -1,48 +0,0 @@
-'use strict'
-
-const { generate } = require('randomstring')
-
-const fixtures = require('./factory.fixtures')
-const mock = fixtures.mock
-
-jest.mock('../../src/entities/entity', () => ({ Entity: mock.Entity }))
-jest.mock('../../src/entities/set', () => ({ EntitySet: mock.EntitySet }))
-
-const { Factory } = require('../../src/entities/factory')
-
-let factory
-
-beforeEach(async () => {
-  jest.clearAllMocks()
-
-  factory = new Factory(fixtures.schema, () => fixtures.storage.id())
-})
-
-it('should create initial', () => {
-  const id = generate()
-  const initial = factory.init(id)
-
-  expect(initial).toBeInstanceOf(mock.Entity)
-  expect(initial.constructor).toHaveBeenCalledWith(fixtures.schema, id)
-})
-
-it('should create instance', () => {
-  const object = factory.object(fixtures.entity)
-
-  expect(object).toBeInstanceOf(mock.Entity)
-  expect(object.constructor).toHaveBeenCalledWith(fixtures.schema, fixtures.entity)
-})
-
-it('should create set', () => {
-  const objects = factory.objects(fixtures.set)
-
-  expect(objects).toBeInstanceOf(mock.EntitySet)
-
-  const instances = fixtures.set.map((entity, index) => {
-    expect(mock.Entity).toHaveBeenNthCalledWith(index + 1, fixtures.schema, entity)
-
-    return mock.Entity.mock.instances[index]
-  })
-
-  expect(objects.constructor).toHaveBeenCalledWith(instances)
-})

package/test/entities/set.fixtures.js

@@ -1,11 +0,0 @@
-'use strict'
-
-const { generate } = require('randomstring')
-
-const set = [
-  { get: jest.fn(() => ({ [generate()]: generate() })) },
-  { get: jest.fn(() => ({ [generate()]: generate() })) },
-  { get: jest.fn(() => ({ [generate()]: generate() })) }
-]
-
-exports.set = set

package/test/entities/set.test.js

@@ -1,12 +0,0 @@
-'use strict'
-
-const { EntitySet } = require('../../src/entities/set')
-const fixtures = require('./set.fixtures')
-
-it('should provide state', () => {
-  const set = new EntitySet(fixtures.set)
-  const state = set.get()
-  const expected = fixtures.set.map((entity) => entity.get.mock.results[0].value)
-
-  expect(state).toStrictEqual(expected)
-})

package/test/event.fixtures.js

@@ -1,29 +0,0 @@
-'use strict'
-
-const { generate } = require('randomstring')
-
-const definition = {
-  conditioned: true,
-  subjective: true
-}
-
-// noinspection JSCheckFunctionSignatures
-const bridge = {
-  condition: jest.fn(async (origin) => !origin.falsy),
-  payload: jest.fn(async () => ({ [generate()]: generate() }))
-}
-
-const binding = {
-  emit: jest.fn()
-}
-
-const event = {
-  origin: { [generate()]: generate() },
-  state: { [generate()]: generate() },
-  changeset: { [generate()]: generate() }
-}
-
-exports.bridge = bridge
-exports.binding = binding
-exports.definition = definition
-exports.event = event

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