comq 0.4.1 → 0.5.0

package/test/shards/connection.test.js

@@ -0,0 +1,106 @@
+'use strict'
+
+const { generate } = require('randomstring')
+const { random, promex, sample } = require('@toa.io/generic')
+
+const { Connection } = require('../../source/shards')
+
+const mock = require('../connection.mock')
+
+jest.mock('../../source/shards/channel')
+
+const { create } = require('../../source/shards/channel')
+
+it('should be', async () => {
+  expect(Connection).toBeDefined()
+})
+
+/** @type {jest.MockedObject<comq.Connection>[]} */
+const connections = [mock.connection(), mock.connection()]
+
+/** @type {comq.Connection} */
+let connection
+
+beforeEach(() => {
+  jest.clearAllMocks()
+
+  connection = new Connection(connections)
+})
+
+describe('open', () => {
+  it('should resolve when one of connections is established', async () => {
+    expect.assertions(1)
+
+    /** @type {toa.generic.Promex[]} */
+    const promises = []
+
+    for (const conn of connections) {
+      const promise = promex()
+
+      conn.open.mockImplementation(() => promise)
+      promises.push(promise)
+    }
+
+    let connected = false
+
+    setImmediate(() => {
+      expect(connected).toStrictEqual(false)
+
+      const any = sample(promises)
+
+      any.resolve()
+    })
+
+    await connection.open()
+
+    connected = true
+  })
+})
+
+describe('close', () => {
+  it('should close all connections', async () => {
+    await connection.close()
+
+    for (const conn of connections) {
+      expect(conn.close).toHaveBeenCalled()
+    }
+  })
+})
+
+describe('createChannel', () => {
+  const type = generate()
+
+  beforeEach(() => {
+    connection.createChannel(type)
+  })
+
+  it('should create channel', async () => {
+    expect(create).toHaveBeenCalledWith(connections, type)
+  })
+})
+
+describe.each(/** @type {comq.diagnostics.event[]} */ ['open', 'close'])('diagnose %s event',
+  (event) => {
+    const index = random(connections.length)
+
+    it('should re-emit event', async () => {
+      for (const conn of connections) {
+        expect(conn.diagnose).toHaveBeenCalledWith(event, expect.any(Function))
+      }
+
+      const listener = /** @type {Function} */ jest.fn()
+
+      connection.diagnose(event, listener)
+
+      const call = connections[index].diagnose.mock.calls.find(
+        (call) => call[0] === event)
+
+      const emit = call[1]
+      const args = [generate(), generate()]
+
+      emit(event, ...args)
+
+      expect(listener).toHaveBeenCalled()
+      expect(listener).toHaveBeenCalledWith(event, ...args, index)
+    })
+  })

package/types/amqp.d.ts

@@ -5,11 +5,13 @@ declare namespace comq.amqp {
   namespace options {
     type Consume = amqplib.Options.Consume
     type Publish = amqplib.Options.Publish
+    type Exchange = amqplib.Options.AssertExchange
+    type Queue = amqplib.Options.AssertQueue
   }
 
   type Connection = amqplib.Connection
   type Channel = amqplib.Channel | amqplib.ConfirmChannel
-
+  type Message = amqplib.Message
 }
 
 export type Connection = comq.amqp.Connection

package/types/channel.d.ts

@@ -1,16 +1,19 @@
-import { ConsumeMessage, Options, Connection } from 'amqplib'
+import { Message, Options, Connection } from 'amqplib'
 import * as _diagnostics from './diagnostic'
 
 declare namespace comq {
 
   namespace channels {
 
-    type consumer = (message: ConsumeMessage) => void | Promise<void>
+    type consumer = (message: Message) => void | Promise<void>
 
   }
 
   interface Channel {
-    create(connection: Connection): Promise<void>
+    index?: number
+    sharded?: boolean
+
+    create(): Promise<void>
 
     consume(queue: string, consumer: channels.consumer): Promise<void>
 
@@ -18,10 +21,10 @@ declare namespace comq {
 
     send(queue: string, buffer: Buffer, options?: Options.Publish): Promise<void>
 
-    throw(queue: string, buffer: Buffer, options?: Options.Publish): Promise<void>
-
     publish(exchange: string, buffer: Buffer, options?: Options.Publish): Promise<void>
 
+    throw(queue: string, buffer: Buffer, options?: Options.Publish): Promise<void>
+
     seal(): Promise<void>
 
     diagnose(event: _diagnostics.event, listener: Function): void

package/types/connection.d.ts

@@ -12,10 +12,12 @@ declare namespace comq {
 
     createChannel(type: _topology.type): Promise<_channel.Channel>
 
+    createChannel(type: _topology.type, index: number): Promise<_channel.Channel>
+
     diagnose(event: _diagnostics.event, listener: Function): void
   }
 
-  type connect = (url: string) => Promise<_io.IO>
+  type connect = (...urls: string[]) => Promise<_io.IO>
 
 }
 

package/types/diagnostic.d.ts

@@ -1,6 +1,6 @@
 declare namespace comq.diagnostics {
 
-  type event = 'open' | 'close' | 'flow' | 'drain' | 'recover' | 'discard'
+  type event = 'open' | 'close' | 'flow' | 'drain' | 'remove' | 'recover' | 'discard'
 
 }
 

package/types/topology.d.ts

@@ -4,6 +4,10 @@ declare namespace comq {
 
     type type = 'request' | 'reply' | 'event'
 
+    type Set = {
+      [K in type]: Topology
+    }
+
   }
 
   type Topology = {