@toa.io/bindings.amqp 0.2.1-dev.3 → 0.2.1-dev.4

package/test/comq.mock.js

@@ -0,0 +1,21 @@
+'use strict'
+
+const { generate } = require('randomstring')
+
+/**
+ * @return {jest.MockedObject<comq.IO>}
+ */
+const io = () => (/** @type {jest.MockedObject<comq.IO>} */ {
+  request: jest.fn(async () => generate()),
+  reply: jest.fn(async () => undefined),
+  emit: jest.fn(async () => undefined),
+  consume: jest.fn(async () => undefined),
+  seal: jest.fn(async () => undefined),
+  close: jest.fn(async () => undefined)
+})
+
+const comq = {
+  connect: jest.fn(async () => io())
+}
+
+exports.comq = comq

package/test/consumer.test.js

@@ -0,0 +1,51 @@
+'use strict'
+
+const { generate } = require('randomstring')
+const { Connector } = require('@toa.io/core')
+
+const mock = {
+  communication: require('./communication.mock').communication,
+  queues: require('./queues.mock')
+}
+
+jest.mock('../source/queues', () => mock.queues)
+
+const { Consumer } = require('../source/consumer')
+
+it('should be', async () => {
+  expect(Consumer).toBeDefined()
+})
+
+const comm = mock.communication()
+const locator = /** @type {toa.core.Locator} */ { name: generate(), namespace: generate() }
+const endpoint = generate()
+
+/** @type {toa.core.bindings.Consumer} */
+let consumer
+
+beforeEach(() => {
+  jest.clearAllMocks()
+
+  consumer = new Consumer(comm, locator, endpoint)
+})
+
+it('should be instance of Connector', async () => {
+  expect(consumer).toBeInstanceOf(Connector)
+})
+
+it('should depend on communication', async () => {
+  expect(comm.link).toHaveBeenCalledWith(consumer)
+})
+
+it('should send request', async () => {
+  const request = generate()
+
+  const reply = await consumer.request(request)
+
+  expect(mock.queues.name).toHaveBeenCalledWith(locator, endpoint)
+
+  const queue = mock.queues.name.mock.results[0].value
+
+  expect(comm.request).toHaveBeenCalledWith(queue, request)
+  expect(reply).toStrictEqual(await comm.request.mock.results[0].value)
+})

package/test/emitter.test.js

@@ -0,0 +1,54 @@
+'use strict'
+
+// region setup
+
+const { generate } = require('randomstring')
+const { Connector } = require('@toa.io/core')
+
+const mock = {
+  communication: require('./communication.mock').communication,
+  queues: require('./queues.mock')
+}
+
+jest.mock('../source/queues', () => mock.queues)
+
+const { Emitter } = require('../source/emitter')
+
+it('should be', async () => {
+  expect(Emitter).toBeDefined()
+})
+
+const comm = mock.communication()
+const locator = /** @type {toa.core.Locator} */ { name: generate(), namespace: generate() }
+const label = generate()
+
+/** @type {toa.core.bindings.Emitter} */
+let emitter
+
+beforeEach(() => {
+  jest.clearAllMocks()
+
+  emitter = new Emitter(comm, locator, label)
+})
+
+// endregion
+
+it('should be instance of Connector', async () => {
+  expect(emitter).toBeInstanceOf(Connector)
+})
+
+it('should depend on communication', async () => {
+  expect(comm.link).toHaveBeenCalledWith(emitter)
+})
+
+it('should emit', async () => {
+  const message = generate()
+
+  await emitter.emit(message)
+
+  expect(mock.queues.name).toHaveBeenCalledWith(locator, label)
+
+  const exchange = mock.queues.name.mock.results[0].value
+
+  expect(comm.emit).toHaveBeenCalledWith(exchange, message)
+})

package/test/factory.test.js

@@ -0,0 +1,201 @@
+'use strict'
+
+// region setup
+
+const { generate } = require('randomstring')
+const { Locator } = require('@toa.io/core')
+
+jest.mock('../source/pointer')
+jest.mock('../source/communication')
+jest.mock('../source/producer')
+jest.mock('../source/consumer')
+jest.mock('../source/emitter')
+jest.mock('../source/receiver')
+jest.mock('../source/broadcast')
+
+const {
+  /** @type {jest.MockedClass<Communication>} */
+  Communication
+} = require('../source/communication')
+
+const {
+  /** @type {jest.MockedClass<Pointer>} */
+  Pointer
+} = require('../source/pointer')
+
+const {
+  /** @type {jest.MockedClass<Producer>} */
+  Producer
+} = require('../source/producer')
+
+const {
+  /** @type {jest.MockedClass<Consumer>} */
+  Consumer
+} = require('../source/consumer')
+
+const {
+  /** @type {jest.MockedClass<Emitter>} */
+  Emitter
+} = require('../source/emitter')
+
+const {
+  /** @type {jest.MockedClass<Receiver>} */
+  Receiver
+} = require('../source/receiver')
+
+const {
+  /** @type {jest.MockedClass<Broadcast>} */
+  Broadcast
+} = require('../source/broadcast')
+
+const { Factory } = require('../')
+
+it('should be', async () => {
+  expect(Factory).toBeDefined()
+})
+
+/** @type {toa.core.bindings.Factory} */
+let factory
+
+beforeEach(() => {
+  jest.clearAllMocks()
+
+  factory = new Factory()
+})
+
+const locator = /** @type {toa.core.Locator} */ { name: generate(), namespace: generate() }
+const endpoints = [generate(), generate()]
+const endpoint = generate()
+const name = generate()
+const group = generate()
+const component = /** @type {toa.core.Component} */ {}
+const processor = /** @type {toa.core.Receiver} */ {}
+
+/** @type {jest.MockedObject<toa.amqp.Communication>} */
+let comm
+
+/** @type {toa.core.Connector} */
+let producer
+
+/** @type {toa.core.bindings.Consumer} */
+let consumer
+
+/** @type {toa.core.Connector} */
+let receiver
+
+/** @type {toa.core.bindings.Emitter} */
+let emitter
+
+/** @type {toa.core.bindings.Broadcast} */
+let broadcast
+
+// endregion
+
+describe.each(['Producer', 'Consumer', 'Emitter', 'Receiver', 'Broadcast'])('%s assets', (classname) => {
+  const method = classname.toLowerCase()
+
+  it('should be', async () => {
+    expect(factory[method]).toBeDefined()
+  })
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+
+    switch (method) {
+      case 'producer':
+        factory.producer(locator, endpoints, component)
+        break
+      case 'consumer':
+        factory.consumer(locator, endpoint)
+        break
+      case 'emitter':
+        factory.emitter(locator, endpoint)
+        break
+      case 'receiver':
+        factory.receiver(locator, endpoint, group, processor)
+        break
+      case 'broadcast':
+        factory.broadcast(name, group)
+        break
+    }
+  })
+
+  if (method !== 'broadcast') {
+    it('should create Pointer', async () => {
+      expect(Pointer).toHaveBeenCalledWith(locator)
+    })
+  }
+
+  it('should create Communication', async () => {
+    const pointer = Pointer.mock.instances[0]
+
+    expect(Communication).toHaveBeenCalledWith(pointer)
+  })
+})
+
+describe('Producer', () => {
+  beforeEach(() => {
+    producer = factory.producer(locator, endpoints, component)
+    comm = Communication.mock.instances[0]
+  })
+
+  it('should create instance', async () => {
+    expect(Producer).toHaveBeenCalledWith(comm, locator, endpoints, component)
+    expect(producer).toStrictEqual(Producer.mock.instances[0])
+  })
+})
+
+describe('Consumer', () => {
+  beforeEach(() => {
+    consumer = factory.consumer(locator, endpoint)
+    comm = Communication.mock.instances[0]
+  })
+
+  it('should create instance', async () => {
+    expect(Consumer).toHaveBeenCalledWith(comm, locator, endpoint)
+    expect(consumer).toStrictEqual(Consumer.mock.instances[0])
+  })
+})
+
+describe('Emitter', () => {
+  beforeEach(() => {
+    emitter = factory.emitter(locator, endpoint)
+    comm = Communication.mock.instances[0]
+  })
+
+  it('should create instance', async () => {
+    expect(Emitter).toHaveBeenCalledWith(comm, locator, endpoint)
+    expect(emitter).toStrictEqual(Emitter.mock.instances[0])
+  })
+})
+
+describe('Receiver', () => {
+  beforeEach(() => {
+    receiver = factory.receiver(locator, endpoint, group, processor)
+    comm = Communication.mock.instances[0]
+  })
+
+  it('should create instance', async () => {
+    expect(Receiver).toHaveBeenCalledWith(comm, locator, endpoint, group, processor)
+    expect(receiver).toStrictEqual(Receiver.mock.instances[0])
+  })
+})
+
+describe('Broadcast', () => {
+  beforeEach(() => {
+    broadcast = factory.broadcast(name, group)
+    comm = Communication.mock.instances[0]
+  })
+
+  it('should create Locator', async () => {
+    const locator = Broadcast.mock.calls[0][1]
+
+    expect(locator.namespace).toStrictEqual('system')
+    expect(locator.name).toStrictEqual(name)
+  })
+
+  it('should create instance', async () => {
+    expect(Broadcast).toHaveBeenCalledWith(comm, expect.any(Locator), group)
+    expect(broadcast).toStrictEqual(Broadcast.mock.instances[0])
+  })
+})

package/test/pointer.test.js

@@ -2,15 +2,14 @@
 
 const { generate } = require('randomstring')
 const { Locator } = require('@toa.io/core')
-const { encode, letters: { up } } = require('@toa.io/generic')
+const { encode } = require('@toa.io/generic')
 
-const { Pointer } = require('../src/pointer')
-const { PREFIX } = require('../src/constants')
+const { Pointer } = require('../source/pointer')
 
 /** @type {toa.core.Locator} */
 let locator
 
-/** @type {toa.amqp.Pointer} */
+/** @type {Pointer} */
 let pointer
 
 const protocol = 'amqp:'
@@ -35,7 +34,7 @@ beforeEach(() => {
   const namespace = generate()
   const uris = { default: url.href }
   const value = encode(uris)
-  const key = `TOA_${up(PREFIX)}_POINTER`
+  const key = 'TOA_BINDINGS_AMQP_POINTER'
 
   process.env[key] = value
 

package/test/producer.test.js

@@ -0,0 +1,69 @@
+'use strict'
+
+const { generate } = require('randomstring')
+const { each } = require('@toa.io/generic')
+
+const mock = {
+  communication: require('./communication.mock').communication,
+  queues: require('./queues.mock')
+}
+
+jest.mock('../source/queues', () => mock.queues)
+
+const { Producer } = require('../source/producer')
+
+it('should be', async () => {
+  expect(Producer).toBeDefined()
+})
+
+/** @type {jest.MockedObject<toa.amqp.Communication>} */
+let comm
+
+const locator = /** @type {toa.core.Locator} */ generate()
+const endpoints = [generate(), generate()]
+
+const component = /** @type {jest.MockedObject<toa.core.Component>} */ {
+  connect: jest.fn(async () => undefined),
+  link: jest.fn(),
+  invoke: jest.fn(async () => generate())
+}
+
+/** @type {Producer} */
+let producer
+
+beforeEach(() => {
+  jest.clearAllMocks()
+
+  comm = mock.communication()
+  producer = new Producer(comm, locator, endpoints, component)
+})
+
+it('should depend on Communication', async () => {
+  expect(comm.link).toHaveBeenCalled()
+})
+
+it('should depend onComponent', async () => {
+  expect(component.link).toHaveBeenCalled()
+})
+
+it('should bind endpoints', async () => {
+  await producer.connect()
+
+  await each(endpoints, async (endpoint, i) => {
+    const n = i + 1
+
+    expect(mock.queues.name).toHaveBeenNthCalledWith(n, locator, endpoint)
+
+    const queue = mock.queues.name.mock.results[i].value
+
+    expect(comm.reply).toHaveBeenNthCalledWith(n, queue, expect.any(Function))
+
+    const process = comm.reply.mock.calls[i][1]
+
+    const request = generate()
+
+    await process(request)
+
+    expect(component.invoke).toHaveBeenNthCalledWith(n, endpoint, request)
+  })
+})

package/test/properties.test.js

@@ -0,0 +1,7 @@
+'use strict'
+
+const { properties } = require('../')
+
+it('should export properties', async () => {
+  expect(properties).toStrictEqual({ async: true })
+})

package/test/queues.mock.js

@@ -0,0 +1,7 @@
+'use strict'
+
+const { generate } = require('randomstring')
+
+const name = jest.fn(() => generate())
+
+exports.name = name

package/test/queues.test.js

@@ -0,0 +1,35 @@
+'use strict'
+
+const { generate } = require('randomstring')
+
+const { name } = require('../source/queues')
+
+/** @type {toa.core.Locator} */
+let locator
+
+const endpoint = generate()
+
+beforeEach(() => {
+  locator = /** @type {toa.core.Locator} */ {
+    name: generate(),
+    namespace: generate()
+  }
+})
+
+it('should be', async () => {
+  expect(name).toBeInstanceOf(Function)
+})
+
+it('should name a queue', async () => {
+  const queue = name(locator, endpoint)
+
+  expect(queue).toStrictEqual(`${locator.namespace}.${locator.name}.${endpoint}`)
+})
+
+it('should name a queue with nameless locator', async () => {
+  delete locator.name
+
+  const queue = name(locator, endpoint)
+
+  expect(queue).toStrictEqual(`${locator.namespace}.${endpoint}`)
+})

package/test/receiver.test.js

@@ -0,0 +1,64 @@
+'use strict'
+
+const { generate } = require('randomstring')
+const { Connector } = require('@toa.io/core')
+
+const mock = {
+  communication: require('./communication.mock').communication,
+  queues: require('./queues.mock')
+}
+
+jest.mock('../source/queues', () => mock.queues)
+
+const { Receiver } = require('../source/receiver')
+
+it('should be', async () => {
+  expect(Receiver).toBeDefined()
+})
+
+/** @type {jest.MockedObject<toa.amqp.Communication>} */
+const comm = mock.communication()
+
+const locator = /** @type {toa.core.Locator} */ { name: generate(), namespace: generate() }
+const group = generate()
+const label = generate()
+
+const processor = /** @type {jest.MockedObject<toa.core.Receiver>} */ {
+  connect: jest.fn(async () => undefined),
+  link: jest.fn(),
+  receive: jest.fn(async () => undefined)
+}
+
+/** @type {Receiver} */
+let receiver
+
+beforeEach(() => {
+  jest.clearAllMocks()
+
+  receiver = new Receiver(comm, locator, label, group, processor)
+})
+
+it('should be instance of Connector', async () => {
+  expect(receiver).toBeInstanceOf(Connector)
+})
+
+it('should depend on communication', async () => {
+  expect(comm.link).toHaveBeenCalledWith(receiver)
+})
+
+it('should consume events', async () => {
+  await receiver.open()
+
+  expect(mock.queues.name).toHaveBeenCalledWith(locator, label)
+
+  const exchange = mock.queues.name.mock.results[0].value
+
+  expect(comm.consume).toHaveBeenCalledWith(exchange, group, expect.any(Function))
+
+  const callback = comm.consume.mock.calls[0][2]
+  const message = generate()
+
+  await callback(message)
+
+  expect(processor.receive).toHaveBeenCalledWith(message)
+})

package/types/communication.d.ts

@@ -0,0 +1,16 @@
+import { Connector } from '@toa.io/core/types'
+import * as comq from 'comq'
+
+declare namespace toa.amqp {
+
+  interface Communication extends Connector {
+    request(queue: string, request: any): Promise<any>
+
+    reply(queue: string, process: comq.producer): Promise<void>
+
+    emit(exchange: string, message: any): Promise<void>
+
+    consume(exchange: string, group: string, callback: comq.consumer): Promise<void>
+  }
+
+}

package/src/broadcaster.js

@@ -1,37 +0,0 @@
-'use strict'
-
-const { Connector } = require('@toa.io/core')
-const { newid } = require('@toa.io/generic')
-
-/**
- * @implements {toa.core.bindings.Broadcaster}
- */
-class Broadcaster extends Connector {
-  #group
-  #channel
-  #prefix
-
-  constructor (channel, prefix, group) {
-    super()
-
-    this.#group = group === undefined ? newid() : group
-
-    this.#channel = channel
-    this.#prefix = prefix + '.'
-
-    this.depends(channel)
-  }
-
-  async send (label, payload) {
-    await this.#channel.publish(this.#prefix + label, payload, {
-      expiration: 10,
-      persistent: false
-    })
-  }
-
-  async receive (label, callback) {
-    await this.#channel.subscribe(this.#prefix + label, this.#group, callback)
-  }
-}
-
-exports.Broadcaster = Broadcaster