@toa.io/core 0.1.0-alpha.12

package/test/state.fixtures.js

@@ -0,0 +1,46 @@
+'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 = {
+  entity: jest.fn(() => ({ [generate()]: generate() })),
+  set: 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

@@ -0,0 +1,54 @@
+'use strict'
+
+const { State } = require('../src/state')
+const fixtures = require('./state.fixtures')
+
+let state
+
+beforeAll(() => {
+  delete global.TOA_INTEGRATION_OMIT_EMISSION
+})
+
+afterAll(() => {
+  global.TOA_INTEGRATION_OMIT_EMISSION = true
+})
+
+beforeEach(() => {
+  jest.clearAllMocks()
+
+  state = new State(fixtures.storage, fixtures.factory, fixtures.emitter)
+})
+
+it('should provide entity', async () => {
+  const entity = await state.entity(fixtures.query)
+
+  expect(fixtures.storage.get).toHaveBeenCalledWith(fixtures.query)
+  expect(entity).toStrictEqual(fixtures.factory.entity.mock.results[0].value)
+  expect(fixtures.factory.entity).toHaveBeenCalledWith(fixtures.storage.get.mock.results[0].value)
+})
+
+it('should provide set', async () => {
+  const set = await state.set(fixtures.query)
+
+  expect(fixtures.storage.find).toHaveBeenCalledWith(fixtures.query)
+  expect(set).toStrictEqual(fixtures.factory.set.mock.results[0].value)
+  expect(fixtures.factory.set).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

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

package/test/transmission.test.js

@@ -0,0 +1,46 @@
+'use strict'
+
+jest.mock('../src/connector')
+
+const { Connector } = require('../src/connector')
+const { Transmission } = require('../src/transmission')
+const { codes } = require('../src/exceptions')
+const fixtures = require('./transmission.fixtures')
+
+let transmission
+
+beforeEach(() => {
+  jest.clearAllMocks()
+})
+
+beforeEach(() => {
+  transmission = new Transmission(fixtures.bindings)
+})
+
+it('should be instance of Connector depending on bindings', () => {
+  expect(transmission).toBeInstanceOf(Connector)
+  expect(Connector.mock.instances[0].depends).toHaveBeenCalledWith(fixtures.bindings)
+})
+
+it('should pass arguments and return value', async () => {
+  const request = { foo: 'bar' }
+  const result = await transmission.request(request)
+
+  expect(fixtures.bindings[0].request).toHaveBeenCalledWith(request)
+  expect(result).toBe(await fixtures.bindings[0].request.mock.results[0].value)
+})
+
+it('should pick bindings sequentially', async () => {
+  let result = await transmission.request()
+  expect(result).toBe(await fixtures.bindings[0].request.mock.results[0].value)
+
+  result = await transmission.request({ pick: 1 })
+  expect(result).toBe(await fixtures.bindings[1].request.mock.results[0]?.value)
+})
+
+it('should throw exception if none succeeded', async () => {
+  await expect(transmission.request({ pick: 5 })).rejects.toMatchObject({ code: codes.Transmission })
+
+  fixtures.bindings.forEach((binding) =>
+    expect(binding.request).toHaveBeenCalled())
+})