@toa.io/core 0.1.0-alpha.12

package/src/transmission.js

@@ -0,0 +1,33 @@
+'use strict'
+
+const { Connector } = require('./connector')
+const { TransmissionException } = require('./exceptions')
+
+class Transmission extends Connector {
+  #bindings
+
+  constructor (bindings) {
+    super()
+
+    this.#bindings = bindings
+    this.depends(bindings)
+  }
+
+  async request (request) {
+    let reply = false
+    let i = 0
+
+    while (reply === false && i < this.#bindings.length) {
+      reply = await this.#bindings[i].request(request)
+      i++
+    }
+
+    if (reply === false) {
+      throw new TransmissionException(`All (${this.#bindings.length}) bindings rejected.`)
+    }
+
+    return reply
+  }
+}
+
+exports.Transmission = Transmission

package/test/call.fixtures.js

@@ -0,0 +1,25 @@
+'use strict'
+
+const { generate } = require('randomstring')
+
+const transmission = {
+  request: jest.fn((request) => ({ [request.invalid ? 'exception' : generate()]: generate() }))
+}
+
+const contract = {
+  fit: jest.fn(() => null)
+}
+
+const request = () => ({
+  ok: {
+    input: { [generate()]: generate() },
+    query: { [generate()]: generate() }
+  },
+  bad: {
+    invalid: true
+  }
+})
+
+exports.transmission = transmission
+exports.contract = contract
+exports.request = request

package/test/call.test.js

@@ -0,0 +1,52 @@
+'use strict'
+
+const { Call } = require('../src/call')
+const fixtures = require('./call.fixtures')
+
+jest.mock('../src/connector')
+
+const { Connector } = require('../src/connector')
+
+let call
+
+beforeEach(() => {
+  jest.clearAllMocks()
+
+  call = new Call(fixtures.transmission, fixtures.contract)
+})
+
+it('should depend on transmission', () => {
+  expect(call).toBeInstanceOf(Connector)
+  expect(call).toBe(Connector.mock.instances[0])
+  expect(Connector.mock.instances[0].depends).toHaveBeenCalledWith(fixtures.transmission)
+})
+
+it('should call transmission', async () => {
+  const request = fixtures.request().ok
+
+  await call.invoke(request)
+
+  expect(fixtures.transmission.request).toHaveBeenCalledWith(request)
+})
+
+it('should fit request', async () => {
+  const request = fixtures.request().ok
+
+  await call.invoke(request)
+
+  expect(fixtures.contract.fit).toHaveBeenLastCalledWith(request)
+})
+
+it('should return reply', async () => {
+  const request = fixtures.request().ok
+
+  const reply = await call.invoke(request)
+
+  expect(reply).toStrictEqual(fixtures.transmission.request.mock.results[0].value)
+})
+
+it('should throw received exceptions', async () => {
+  const request = fixtures.request().bad
+
+  await expect(call.invoke(request)).rejects.toBeDefined()
+})

package/test/cascade.fixtures.js

@@ -0,0 +1,11 @@
+'use strict'
+
+const bridges = ['a', 'b', 'c'].map((index) => ({
+  run: jest.fn((request) => {
+    if (request?.error === index) return { error: index }
+
+    return { output: { [index]: true } }
+  })
+}))
+
+exports.bridges = bridges

package/test/cascade.test.js

@@ -0,0 +1,42 @@
+'use strict'
+
+jest.mock('../src/connector')
+
+const clone = require('clone-deep')
+
+const { Connector } = require('../src/connector')
+const { Cascade } = require('../src/cascade')
+const fixtures = require('./cascade.fixtures')
+
+let cascade
+
+beforeEach(() => {
+  jest.clearAllMocks()
+
+  cascade = new Cascade(clone(fixtures.bridges))
+})
+
+it('should depend on bridges', () => {
+  expect(cascade).toBeInstanceOf(Connector)
+  expect(Connector.mock.instances[0].depends).toHaveBeenCalledWith(fixtures.bridges)
+})
+
+it('should call bridges.run', async () => {
+  const args = [1, 2]
+  await cascade.run(...args)
+
+  for (const bridge of fixtures.bridges) expect(bridge.run).toHaveBeenCalledWith(...args)
+})
+
+it('should merge output', async () => {
+  const reply = await cascade.run()
+
+  expect(reply).toStrictEqual({ output: { a: true, b: true, c: true } })
+})
+
+it('should interrupt on error', async () => {
+  const reply = await cascade.run({ error: 'b' })
+
+  expect(reply).toStrictEqual({ error: 'b' })
+  expect(fixtures.bridges[2].run).not.toHaveBeenCalled()
+})

package/test/connector.fixtures.js

@@ -0,0 +1,40 @@
+'use strict'
+
+const { random, timeout } = require('@toa.io/gears')
+const { Connector } = require('../src/connector')
+
+class TestConnector extends Connector {
+  #label
+  #seq
+
+  constructor (label, seq) {
+    super()
+
+    this.#seq = seq
+    this.#label = label
+  }
+
+  async connection () {
+    await timeout(random(10))
+    this.#seq.push(`+${this.#label}`)
+  }
+
+  async disconnection () {
+    await timeout(random(10))
+    this.#seq.push(`-${this.#label}`)
+  }
+
+  disconnected () {
+    this.#seq.push(`*${this.#label}`)
+  }
+}
+
+class FailingConnector extends Connector {
+  async connection () {
+    await timeout(random(10))
+    throw new Error('FailingConnector')
+  }
+}
+
+exports.TestConnector = TestConnector
+exports.FailingConnector = FailingConnector

package/test/connector.test.js

@@ -0,0 +1,199 @@
+'use strict'
+
+const fixtures = require('./connector.fixtures')
+
+let sequence
+
+beforeEach(() => {
+  sequence = []
+})
+
+describe('callbacks', () => {
+  let a
+
+  beforeEach(() => {
+    a = new fixtures.TestConnector('a', sequence)
+  })
+
+  it('should call connection', async () => {
+    await a.connect()
+    expect(sequence).toEqual(['+a'])
+  })
+
+  it('should call disconnection', async () => {
+    await a.connect()
+    await a.disconnect()
+
+    expect(sequence.indexOf('+a')).toBeLessThan(sequence.indexOf('-a'))
+  })
+
+  it('should reconnect', async () => {
+    await a.connect()
+    await a.disconnect()
+    await a.connect()
+    await a.disconnect()
+    await a.connect()
+
+    expect(sequence).toEqual(['+a', '-a', '*a', '+a', '-a', '*a', '+a'])
+  })
+})
+
+describe('dependencies', () => {
+  let a
+  let b
+  let c
+  let d
+
+  beforeEach(() => {
+    a = new fixtures.TestConnector('a', sequence)
+    b = new fixtures.TestConnector('b', sequence)
+    c = new fixtures.TestConnector('c', sequence)
+    d = new fixtures.TestConnector('d', sequence)
+  })
+
+  it('should wait dependencies on connection', async () => {
+    a.depends(b).depends(c)
+    a.depends(d)
+
+    await a.connect()
+
+    expect(sequence.indexOf('+c')).toBeLessThan(sequence.indexOf('+b'))
+    expect(sequence.indexOf('+b')).toBeLessThan(sequence.indexOf('+a'))
+    expect(sequence.indexOf('+d')).toBeLessThan(sequence.indexOf('+a'))
+  })
+
+  it('should wait array of connectors', async () => {
+    a.depends([b, d])
+    b.depends(c)
+    d.depends(c)
+
+    await a.connect()
+
+    expect(sequence.indexOf('+c')).toBeLessThan(sequence.indexOf('+b'))
+    expect(sequence.indexOf('+c')).toBeLessThan(sequence.indexOf('+d'))
+    expect(sequence.indexOf('+b')).toBeLessThan(sequence.indexOf('+a'))
+    expect(sequence.indexOf('+d')).toBeLessThan(sequence.indexOf('+a'))
+  })
+
+  it('should wait array(1) of connectors', async () => {
+    a.depends([b])
+    b.depends(c)
+
+    await a.connect()
+
+    expect(sequence.indexOf('+c')).toBeLessThan(sequence.indexOf('+b'))
+    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 await 2-way dependencies', async () => {
+    a.depends([b, c, d])
+    d.depends([b, c])
+
+    await a.connect()
+
+    expect(sequence.indexOf('+b')).toBeLessThan(sequence.indexOf('+a'))
+    expect(sequence.indexOf('+c')).toBeLessThan(sequence.indexOf('+a'))
+    expect(sequence.indexOf('+d')).toBeLessThan(sequence.indexOf('+a'))
+
+    expect(sequence.indexOf('+b')).toBeLessThan(sequence.indexOf('+d'))
+    expect(sequence.indexOf('+c')).toBeLessThan(sequence.indexOf('+d'))
+  })
+
+  it('should disconnect before dependencies', async () => {
+    a.depends(b).depends(c)
+    b.depends(d)
+
+    await a.disconnect()
+
+    expect(sequence.indexOf('-a')).toBeLessThan(sequence.indexOf('-b'))
+    expect(sequence.indexOf('-b')).toBeLessThan(sequence.indexOf('-c'))
+    expect(sequence.indexOf('-b')).toBeLessThan(sequence.indexOf('-d'))
+  })
+
+  it('should call disconnected', async () => {
+    a.depends(b).depends(c)
+    b.depends(d)
+
+    await a.disconnect()
+
+    expect(sequence.indexOf('*c')).toBeLessThan(sequence.indexOf('*b'))
+    expect(sequence.indexOf('*b')).toBeLessThan(sequence.indexOf('*a'))
+    expect(sequence.indexOf('*d')).toBeLessThan(sequence.indexOf('*b'))
+    expect(sequence.indexOf('*a')).toBe(sequence.length - 1)
+  })
+
+  it('should disconnect if no parents left', async () => {
+    a.depends(c)
+    b.depends(c)
+
+    await a.connect()
+    await b.connect()
+
+    expect(sequence).toEqual(['+c', '+a', '+b'])
+
+    await a.disconnect()
+
+    expect(sequence).toEqual(['+c', '+a', '+b', '-a', '*a'])
+
+    await b.disconnect()
+
+    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'
+    ])
+  })
+
+  describe('errors', () => {
+    let f
+
+    beforeEach(() => {
+      f = new fixtures.FailingConnector()
+    })
+
+    it('should disconnect on fail', async () => {
+      f.depends(b).depends(c)
+
+      await expect(f.connect()).rejects.toThrow('FailingConnector')
+      expect(sequence).toEqual(['+c', '+b', '-b', '-c', '*c', '*b'])
+    })
+
+    it('should interrupt connection chain', async () => {
+      a.depends(f).depends(c)
+      f.depends(d)
+
+      await expect(a.connect()).rejects.toThrow('FailingConnector')
+
+      expect(sequence.indexOf('+c')).toBeLessThan(sequence.indexOf('-c'))
+      expect(sequence.indexOf('+d')).toBeLessThan(sequence.indexOf('-d'))
+
+      expect(sequence.indexOf('+a')).toBe(-1)
+      expect(sequence.indexOf('-a')).toBe(-1)
+    })
+  })
+})

package/test/contract/conditions.test.js

@@ -0,0 +1,26 @@
+'use strict'
+
+const { generate } = require('randomstring')
+
+const { Conditions } = require('../../src/contract/conditions')
+const fixtures = require('./contract.fixtures')
+
+let conditions
+
+beforeEach(() => {
+  conditions = new Conditions(fixtures.schema)
+})
+
+it('should fit value', () => {
+  const value = { foo: generate() }
+
+  conditions.fit(value)
+
+  expect(fixtures.schema.fit).toHaveBeenCalledWith(value)
+})
+
+it('should throw on invalid value', () => {
+  const value = { invalid: true }
+
+  expect(() => conditions.fit(value)).toThrow()
+})

package/test/contract/contract.fixtures.js

@@ -0,0 +1,27 @@
+'use strict'
+
+const { generate } = require('randomstring')
+const { yaml } = require('@toa.io/gears')
+const { resolve } = require('path')
+
+const schema = {
+  fit: jest.fn((input) => (input.invalid ? { message: generate() } : null))
+}
+
+const query = {
+  parse: jest.fn(() => ({ [generate()]: generate() }))
+}
+
+const declaration = {}
+
+const schemas = {
+  request: {
+    properties: { query: yaml.sync(resolve(__dirname, '../../src/contract/schemas/query.yaml')) },
+    additionalProperties: false
+  }
+}
+
+exports.schema = schema
+exports.query = query
+exports.declaration = declaration
+exports.schemas = schemas

package/test/contract/request.test.js

@@ -0,0 +1,99 @@
+'use strict'
+
+const clone = require('clone-deep')
+const { generate } = require('randomstring')
+
+jest.mock('../../src/contract/conditions')
+
+const { Request } = require('../../src/contract/request')
+const { Conditions } = require('../../src/contract/conditions')
+const fixtures = require('./contract.fixtures')
+
+let contract
+
+beforeEach(() => {
+  jest.clearAllMocks()
+
+  contract = new Request(fixtures.schema)
+})
+
+it('should extend Conditions', () => {
+  expect(contract).toBeInstanceOf(Conditions)
+  expect(Conditions).toHaveBeenCalledWith(fixtures.schema)
+})
+
+it('should fit request', () => {
+  const request = { [generate()]: generate() }
+
+  contract.fit(request)
+
+  expect(Conditions.mock.instances[0].fit).toHaveBeenCalledWith(request)
+})
+
+describe('schema', () => {
+  let schema
+
+  beforeEach(() => {
+    schema = clone(fixtures.schemas.request)
+  })
+
+  it('should provide schema', () => {
+    expect(Request.schema({})).toBeDefined()
+  })
+
+  it('should add required input', () => {
+    const input = { type: 'number' }
+
+    expect(Request.schema({ input }).properties.input).toStrictEqual(input)
+  })
+
+  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
+    expect(Request.schema({ query: false })).toStrictEqual(schema)
+  })
+
+  it('should require query if declaration.query is true', () => {
+    schema.required = ['query']
+    expect(Request.schema({ query: true }).required).toStrictEqual(expect.arrayContaining(['query']))
+  })
+
+  it('should forbid projection for non observations', () => {
+    expect(Request.schema({ type: 'transition' }).properties.query.properties.projection)
+      .toBe(undefined)
+
+    expect(Request.schema({ type: 'assignment' }).properties.query.properties.projection)
+      .toBe(undefined)
+
+    expect(Request.schema({ type: 'observation' }).properties.query.properties.projection)
+      .toBeDefined()
+  })
+
+  it('should forbid version for observations', () => {
+    expect(Request.schema({ type: 'transition' }).properties.query.properties.version)
+      .toBeDefined()
+
+    expect(Request.schema({ type: 'observation' }).properties.query.properties.version)
+      .toBe(undefined)
+  })
+
+  it('should allow omit, limit only for set observations', () => {
+    const transition = Request.schema({ type: 'transition' }).properties.query.properties
+
+    expect(transition.omit).toBeUndefined()
+    expect(transition.limit).toBeUndefined()
+
+    const entity = Request.schema({ type: 'observation', subject: 'entity' }).properties.query.properties
+
+    expect(entity.omit).toBeUndefined()
+    expect(entity.limit).toBeUndefined()
+
+    const set = Request.schema({ type: 'observation', subject: 'set' }).properties.query.properties
+
+    expect(set.omit).toBeDefined()
+    expect(set.limit).toBeDefined()
+  })
+})

package/test/emission.fixtures.js

@@ -0,0 +1,16 @@
+'use strict'
+
+const { generate } = require('randomstring')
+
+const events = [0, 1, 2].map((index) => ({
+  emit: jest.fn(async (state) => ({ ...state, event: index }))
+}))
+
+const event = {
+  origin: { [generate()]: generate() },
+  state: { [generate()]: generate() },
+  changeset: { [generate()]: generate() }
+}
+
+exports.events = events
+exports.event = event

package/test/emission.test.js

@@ -0,0 +1,35 @@
+'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.connection()
+})
+
+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

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