comq 0.4.1-dev.3 → 0.5.0-dev.0

package/test/connection.test.js

@@ -4,7 +4,7 @@
 
 const { generate } = require('randomstring')
 
-const { timeout } = require('@toa.io/generic')
+const { timeout, promex, random } = require('@toa.io/generic')
 const { amqplib } = require('./amqplib.mock')
 const { channel: create } = require('./connection.mock')
 const mock = { amqplib, channel: { create } }
@@ -12,7 +12,7 @@ const mock = { amqplib, channel: { create } }
 jest.mock('amqplib', () => mock.amqplib)
 jest.mock('../source/channel', () => mock.channel)
 
-const presets = require('../source/presets')
+const presets = require('../source/topology')
 const { Connection } = require('../source/connection')
 
 it('should be', async () => {
@@ -64,7 +64,7 @@ describe('initial connection', () => {
 })
 
 describe('reconnection', () => {
-  /** @type {jest.MockedObject<import('amqplib').Connection>} */
+  /** @type {jest.MockedObject<comq.amqp.Connection>} */
   let conn
 
   beforeEach(async () => {
@@ -115,7 +115,7 @@ describe('reconnection', () => {
 })
 
 describe('create channel', () => {
-  /** @type {jest.MockedObject<import('amqplib').Connection>} */
+  /** @type {jest.MockedObject<comq.amqp.Connection>} */
   let conn
 
   beforeEach(async () => {
@@ -126,7 +126,7 @@ describe('create channel', () => {
 
   it.each(
     /** @type {comq.topology.type[]} */
-    ['request', 'reply', 'event'])('should create channel of %s type',
+    ['request', 'reply', 'event'])('should create failsafe channel of %s type',
     async (type) => {
       // noinspection JSCheckFunctionSignatures
       create.mockImplementationOnce(async () => generate())
@@ -134,10 +134,19 @@ describe('create channel', () => {
       const preset = presets[type]
       const channel = await connection.createChannel(type)
 
-      expect(create).toHaveBeenCalledWith(conn, preset)
+      expect(create).toHaveBeenCalledWith(conn, preset, undefined)
       expect(channel).toStrictEqual(await create.mock.results[0].value)
     })
 
+  it('should create failfast channel', async () => {
+    const type = 'request'
+    const index = random()
+
+    await connection.createChannel(type, index)
+
+    expect(create).toHaveBeenCalledWith(expect.anything(), expect.anything(), index)
+  })
+
   it('should create channel after exception', async () => {
     create.mockImplementation(async () => { throw new Error() })
 
@@ -152,6 +161,49 @@ describe('create channel', () => {
 
     expect(channel).toStrictEqual(await create.mock.results[1].value)
   })
+
+  it('should wait for initial connection', async () => {
+    jest.clearAllMocks()
+    expect.assertions(2)
+
+    connection = new Connection(url)
+
+    setImmediate(async () => {
+      expect(create).not.toHaveBeenCalled()
+
+      await connection.open()
+    })
+
+    await connection.createChannel('request')
+
+    expect(create).toHaveBeenCalled()
+  })
+
+  it('should wait for reconnection', async () => {
+    expect.assertions(3)
+
+    jest.clearAllMocks()
+
+    const promise = promex()
+
+    amqplib.connect.mockImplementationOnce(() => promise)
+
+    conn.emit('close', new Error())
+
+    expect(amqplib.connect).toHaveBeenCalled()
+
+    setImmediate(async () => {
+      expect(create).not.toHaveBeenCalled()
+
+      const conn = await amqplib.connect()
+
+      promise.resolve(conn)
+    })
+
+    await connection.createChannel('request')
+
+    expect(create).toHaveBeenCalled()
+  })
 })
 
 describe('close', () => {
@@ -164,15 +216,16 @@ describe('close', () => {
     expect(amqp.close).toHaveBeenCalled()
   })
 
-  it('should ignore exceptions', async () => {
-    await connection.open()
+  it('should close after connection is (re)established', async () => {
+    // don't wait for completion
+    connection.open().then()
 
-    /** @type {jest.MockedObject<import('amqplib').Connection>} */
-    const amqp = await amqplib.connect.mock.results[0].value
+    await connection.close()
 
-    amqp.close.mockImplementation(async () => { throw new Error() })
+    /** @type {jest.MockedObject<comq.amqp.Connection>} */
+    const conn = await amqplib.connect.mock.results[0].value
 
-    await expect(connection.close()).resolves.not.toThrow()
+    expect(conn.close).toHaveBeenCalled()
   })
 })
 

package/test/decode.test.js

@@ -16,7 +16,7 @@ it('should decode application/json', async () => {
   const content = Buffer.from(json)
   const contentType = 'application/json'
   const properties = { contentType }
-  const message = /** @type {import('amqplib').ConsumeMessage} */ { content, properties }
+  const message = /** @type {comq.amqp.Message} */ { content, properties }
 
   const decoded = decode(message)
 
@@ -28,7 +28,7 @@ it('should decode application/msgpack', async () => {
   const content = pack(object)
   const contentType = 'application/msgpack'
   const properties = { contentType }
-  const message = /** @type {import('amqplib').ConsumeMessage} */ { content, properties }
+  const message = /** @type {comq.amqp.Message} */ { content, properties }
 
   const decoded = decode(message)
 
@@ -40,7 +40,7 @@ it('should return buffer if content type is not defined', async () => {
   const json = JSON.stringify(object)
   const content = Buffer.from(json)
   const properties = {}
-  const message = /** @type {import('amqplib').ConsumeMessage} */ { content, properties }
+  const message = /** @type {comq.amqp.Message} */ { content, properties }
 
   const buffer = decode(message)
   const string = buffer.toString()
@@ -55,7 +55,7 @@ it('should return buffer if content type is application/octet-stream', async ()
   const content = Buffer.from(json)
   const contentType = 'application/octet-stream'
   const properties = { contentType }
-  const message = /** @type {import('amqplib').ConsumeMessage} */ { content, properties }
+  const message = /** @type {comq.amqp.Message} */ { content, properties }
 
   const buffer = decode(message)
   const string = buffer.toString()
@@ -68,7 +68,7 @@ it('should throw if content-type is not supported', async () => {
   const content = randomBytes(8)
   const contentType = 'wtf/' + generate()
   const properties = { contentType }
-  const message = /** @type {import('amqplib').ConsumeMessage} */ { content, properties }
+  const message = /** @type {comq.amqp.Message} */ { content, properties }
 
   expect(() => decode(message)).toThrow('is not supported')
 })

package/test/io.close.test.js

@@ -104,7 +104,7 @@ describe('close', () => {
     const callback = channel.subscribe.mock.calls[0][2]
     const content = randomBytes(8)
     const properties = {}
-    const message = /** @type {import('amqplib').ConsumeMessage} */ { content, properties }
+    const message = /** @type {comq.amqp.Message} */ { content, properties }
 
     callback(message)
 
@@ -137,7 +137,7 @@ describe('close', () => {
     const callback = channel.consume.mock.calls[0][1]
     const content = generate()
     const properties = { replyTo: generate(), contentType: 'text/plain' }
-    const message = /** @type {import('amqplib').ConsumeMessage} */ { content, properties }
+    const message = /** @type {comq.amqp.Message} */ { content, properties }
 
     callback(message)
 

package/test/io.consume.test.js

@@ -63,7 +63,7 @@ describe('group consumption', () => {
     const payload = generate()
     const content = encode(payload, contentType)
     const properties = { contentType }
-    const message = /** @type {import('amqplib').ConsumeMessage} */ { content, properties }
+    const message = /** @type {comq.amqp.Message} */ { content, properties }
     const callback = events.subscribe.mock.calls[0][2]
 
     await callback(message)

package/test/io.reply.test.js

@@ -74,7 +74,7 @@ describe('queues', () => {
   it('should throw if message is missing replyTo', async () => {
     const content = randomBytes(10)
     const properties = {}
-    const message = /** @type {import('amqplib').ConsumeMessage} */ { content, properties }
+    const message = /** @type {comq.amqp.Message} */ { content, properties }
     const producer = requests.consume.mock.calls[0][1]
 
     await expect(producer(message)).rejects.toThrow('is missing the `replyTo` property')
@@ -99,7 +99,7 @@ describe('reply', () => {
 
     const content = randomBytes(10)
     const properties = { replyTo: generate(), contentType: 'text/plain' }
-    const message = /** @type {import('amqplib').ConsumeMessage} */ { content, properties }
+    const message = /** @type {comq.amqp.Message} */ { content, properties }
     const producer = requests.consume.mock.calls[0][1]
 
     await producer(message)
@@ -119,7 +119,7 @@ describe('reply', () => {
     const callback = requests.consume.mock.calls[0][1]
     const content = randomBytes(10)
     const properties = { replyTo: generate() }
-    const message = /** @type {import('amqplib').ConsumeMessage} */ { content, properties }
+    const message = /** @type {comq.amqp.Message} */ { content, properties }
 
     await expect(callback(message)).rejects.toThrow('must return a value')
   })
@@ -143,7 +143,7 @@ describe('encoding', () => {
     const value = { [generate()]: generate() }
     const content = encode(value, encoding)
     const properties = { contentType: encoding, replyTo: generate() }
-    const message = /** @type {import('amqplib').ConsumeMessage} */ { content, properties }
+    const message = /** @type {comq.amqp.Message} */ { content, properties }
     const producer = requests.consume.mock.calls[0][1]
 
     await producer(message)
@@ -161,7 +161,7 @@ describe('encoding', () => {
       contentType: encoding
     }
 
-    const message = /** @type {import('amqplib').ConsumeMessage} */ { content, properties }
+    const message = /** @type {comq.amqp.Message} */ { content, properties }
     const producer = requests.consume.mock.calls[0][1]
 
     await producer(message)
@@ -190,7 +190,7 @@ describe('encoding', () => {
       contentType: 'application/msgpack'
     }
 
-    const message = /** @type {import('amqplib').ConsumeMessage} */ { content, properties }
+    const message = /** @type {comq.amqp.Message} */ { content, properties }
     const producer = requests.consume.mock.calls[0][1]
     const buffer = randomBytes(8)
 
@@ -214,7 +214,7 @@ describe('encoding', () => {
       correlationId: generate()
     }
 
-    const message = /** @type {import('amqplib').ConsumeMessage} */ { content, properties }
+    const message = /** @type {comq.amqp.Message} */ { content, properties }
     const producer = requests.consume.mock.calls[0][1]
 
     await expect(producer(message)).rejects.toThrow('must be of type `Buffer`')

package/test/io.request.test.js

@@ -174,6 +174,32 @@ describe('send', () => {
 
     expect(requests.send).toHaveBeenCalledTimes(2)
   })
+
+  it('should resend unanswered Requests on sharded connection', async () => {
+    jest.clearAllMocks()
+
+    connection = mock.connection(true)
+    io = new IO(connection)
+
+    promise = io.request(queue, payload)
+
+    // allows initializers to run
+    await immediate()
+
+    requests = await findChannel('request')
+
+    expect(requests.sharded).toStrictEqual(true)
+    expect(requests.diagnose).toHaveBeenCalledWith('remove', expect.any(Function))
+
+    const calls = requests.diagnose.mock.calls.filter((call) => call[0] === 'remove')
+    const listeners = calls.map((call) => call[1])
+
+    for (const listener of listeners) listener()
+
+    await immediate()
+
+    expect(requests.send).toHaveBeenCalledTimes(2)
+  })
 })
 
 describe('reply', () => {
@@ -210,7 +236,7 @@ const reply = async (content = randomBytes(8), contentType = undefined) => {
   const correlationId = requests.send.mock.calls[0][2].correlationId
   const properties = { correlationId, contentType }
   const callback = replies.consume.mock.calls[0][1]
-  const message = /** @type {import('amqplib').ConsumeMessage} */ { content, properties }
+  const message = /** @type {comq.amqp.Message} */ { content, properties }
 
   await callback(message)
 }

package/test/presets.test.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const presets = require('../source/presets')
+const presets = require('../source/topology')
 
 it('should define request preset', async () => {
   expect(presets.request).toStrictEqual({

package/test/shards/channel.test.js

@@ -0,0 +1,367 @@
+'use strict'
+
+const { randomBytes } = require('node:crypto')
+const { generate } = require('randomstring')
+const { promex, sample, immediate, random, each } = require('@toa.io/generic')
+
+const mock = require('../connection.mock')
+
+const { create } = require('../../source/shards/channel')
+
+it('should be', async () => {
+  expect(create).toBeInstanceOf(Function)
+})
+
+/** @type {Array<jest.MockedObject<comq.Connection>>} */
+const connections = [mock.connection(), mock.connection()]
+const type = /** @type {comq.topology.type} */ generate()
+
+/** @type {comq.Channel} */
+let channel
+
+beforeEach(() => {
+  jest.clearAllMocks()
+})
+
+it('should expose `sharded`', async () => {
+  channel = await create(connections, type)
+
+  expect(channel.sharded).toStrictEqual(true)
+})
+
+it('should resolve when one of the connections has created a channel', async () => {
+  /** @type {toa.generic.Promex[]} */
+  const promises = []
+
+  for (const conn of connections) {
+    const promise = promex()
+
+    conn.createChannel.mockImplementationOnce(() => promise)
+
+    promises.push(promise)
+  }
+
+  let any
+  const chan = mock.channel()
+
+  setImmediate(() => {
+    any = sample(promises)
+    any.resolve(chan)
+  })
+
+  await create(connections, type)
+  await immediate()
+
+  expect(any).toBeDefined()
+
+  // resolve pending promises
+  for (const promise of promises) if (promise !== any) promise.resolve(chan)
+
+  await Promise.all(promises)
+})
+
+it('should create failfast channels of given type', async () => {
+  await create(connections, type)
+
+  each(connections, (conn, index) => {
+    expect(conn.createChannel).toHaveBeenCalledWith(type, index)
+  })
+})
+
+describe.each(['consume', 'subscribe'])('%s', (method) => {
+  const exchange = generate()
+  const queue = generate()
+  const group = generate()
+  const processor = jest.fn()
+  const args = method === 'consume' ? [queue, processor] : [exchange, group, processor]
+
+  it(`should ${method} using all channels`, async () => {
+    channel = await create(connections, type)
+
+    const channels = await getCreatedChannels()
+
+    expect(channels.length).toStrictEqual(2)
+
+    await channel[method](...args)
+
+    for (const chan of channels) expect(chan[method]).toHaveBeenCalledWith(...args)
+  })
+
+  it(`should should ${method} using available and pending channels`, async () => {
+    const promise = promex()
+
+    connections[0].createChannel.mockImplementationOnce(() => promise)
+
+    channel = await create(connections, type)
+
+    await channel[method](...args)
+
+    /** @type {jest.MockedObject<comq.Channel>} */
+    const chan1 = await connections[1].createChannel.mock.results[0].value
+
+    expect(chan1[method]).toHaveBeenCalled()
+
+    /** @type {jest.MockedObject<comq.Channel>} */
+    const chan0 = mock.channel()
+
+    promise.resolve(chan0)
+
+    await immediate()
+
+    expect(chan0[method]).toHaveBeenCalled()
+  })
+
+  it(`should ${method} using a channel removed from the pool once it is recovered`, async () => {
+    channel = await create(connections, type)
+
+    const channels = await getCreatedChannels()
+    const chan = sample(channels)
+    const buffer = randomBytes(8)
+    const fail = /** @type {jest.MockedFunction} */ jest.fn(async () => { throw new Error() })
+
+    chan.publish.mockImplementationOnce(fail)
+
+    // `chan` has failed and removed from the pool
+    while (fail.mock.calls.length === 0) await channel.publish(exchange, buffer)
+
+    await channel[method](...args)
+
+    expect(chan[method]).not.toHaveBeenCalled()
+
+    const calls = chan.diagnose.mock.calls.filter((call) => call[0] === 'recover')
+    const listeners = calls.map((call) => call[1])
+
+    // emit `recover` event
+    for (const listener of listeners) await listener()
+
+    await immediate()
+
+    expect(chan[method]).toHaveBeenCalled()
+  })
+})
+
+describe.each(/** @type {string[]} */['send', 'publish', 'throw'])('%s', (method) => {
+  const label = generate()
+  const buffer = randomBytes(8)
+  const options = { contentType: generate() }
+
+  /** @type {jest.MockedObject<comq.Channel>[]} */
+  let channels
+
+  beforeEach(async () => {
+    channel = await create(connections, type)
+    channels = await getCreatedChannels()
+  })
+
+  it('should send to single channel', async () => {
+    await channel[method](label, buffer, options)
+
+    let used = 0
+
+    for (const chan of channels) {
+      if (chan[method].mock.calls.length === 0) continue
+
+      used++
+
+      expect(chan[method]).toHaveBeenCalledWith(label, buffer, options)
+    }
+
+    expect(used).toStrictEqual(1)
+  })
+
+  it('should route pending messages among remaining shards', async () => {
+    const b = random(channels.length)
+    const broken = channels[b]
+    const options = { contentType: generate() }
+    let thrown = false
+
+    broken[method].mockImplementationOnce(async () => {
+      thrown = true
+      throw new Error()
+    })
+
+    let i = 0
+
+    // eslint-disable-next-line no-unmodified-loop-condition
+    while (!thrown) await channel[method](label + ++i, buffer, options)
+
+    const last = label + i
+
+    // now channel has thrown an exception
+    expect(broken[method]).toHaveBeenCalledWith(last, buffer, options)
+
+    const r = (b + 1) % 2
+    const remaining = channels[r]
+
+    expect(remaining[method]).toHaveBeenCalledWith(last, buffer, options)
+  })
+
+  it('should wait for recovery', async () => {
+    const reject = async () => { throw new Error() }
+
+    /** @type {jest.MockedObject<comq.Channel>} */
+    let recovered
+
+    // both shards rejects and will be removed from the pool
+    channels[0][method].mockImplementationOnce(reject)
+    channels[1][method].mockImplementationOnce(reject)
+
+    setImmediate(() => {
+      const r = random(channels.length)
+
+      recovered = channels[r]
+
+      // subscriptions to the 'recover' event
+      const calls = recovered.diagnose.mock.calls.filter(
+        (call) => call[0] === 'recover')
+
+      expect(calls.length).toBeGreaterThan(0)
+
+      // emit 'recover' event to return shard to the pool
+      for (const call of calls) call[1]()
+    })
+
+    await channel[method](label, buffer, options)
+
+    expect(recovered).toBeDefined()
+    expect(recovered[method]).toHaveBeenCalledTimes(2) // failed and succeeded
+  })
+})
+
+describe('seal', () => {
+  it('should seal channels', async () => {
+    channel = await create(connections, type)
+
+    await channel.seal()
+
+    const channels = await getCreatedChannels()
+
+    for (const chan of channels) expect(chan.seal).toHaveBeenCalled()
+  })
+
+  it('should seal channels eventually', async () => {
+    expect.assertions(connections.length + 1)
+
+    channel = await create(connections, type)
+
+    const channels = await getCreatedChannels()
+    const chan = sample(channels)
+    const promise = promex()
+    let sealed = false
+
+    chan.seal.mockImplementationOnce(() => promise)
+
+    setImmediate(() => {
+      expect(sealed).toStrictEqual(false)
+
+      promise.resolve()
+    })
+
+    await channel.seal()
+
+    sealed = true
+
+    for (const chan of channels) expect(chan.seal).toHaveBeenCalled()
+  })
+
+  it('should seal pending channel', async () => {
+    const connection = sample(connections)
+    const promise = promex()
+
+    connection.createChannel.mockImplementationOnce(() => promise)
+
+    channel = await create(connections, type)
+
+    /** @type {jest.MockedObject<comq.Channel>} */
+    let chan
+
+    setImmediate(() => {
+      chan = mock.channel()
+
+      promise.resolve(chan)
+    })
+
+    await channel.seal()
+
+    expect(chan).toBeDefined()
+    expect(chan.seal).toHaveBeenCalled()
+  })
+})
+
+describe('diagnose', () => {
+  const events = /** @type {comq.diagnostics.event[]} */ ['flow', 'drain', 'recover', 'discard']
+
+  /** @type {jest.MockedObject<comq.Channel>[]} */
+  let channels
+
+  beforeEach(async () => {
+    channel = await create(connections, type)
+    channels = await getCreatedChannels()
+  })
+
+  it.each(events)('should re-emit `%s` event',
+    async (event) => {
+      const listener = /** @type {Function} */ jest.fn()
+      const index = random(channels.length)
+      const chan = channels[index]
+
+      channel.diagnose(event, listener)
+
+      expect(chan.diagnose).toHaveBeenCalledWith(event, expect.any(Function))
+
+      const call = chan.diagnose.mock.calls.find((call) => call[0] === event)
+      const emit = call[1]
+      const args = [generate(), generate()]
+
+      emit(...args)
+
+      expect(listener).toHaveBeenCalledWith(...args, index)
+    })
+
+  it('should emit `remove` event', async () => {
+    const queue = generate()
+    const buffer = randomBytes(8)
+    const chan = sample(channels)
+    const listener = /** @type {jest.MockedFunction} */ jest.fn()
+
+    let thrown = false
+
+    channel.diagnose('remove', listener)
+
+    chan.send.mockImplementationOnce(() => {
+      thrown = true
+      throw new Error()
+    })
+
+    // eslint-disable-next-line no-unmodified-loop-condition
+    while (!thrown) await channel.send(queue, buffer)
+
+    expect(listener).toHaveBeenCalledWith(expect.any(Number))
+  })
+})
+
+it('should not throw on recovery (if the "bench" is empty)', async () => {
+  channel = await create(connections, type)
+
+  const channels = await getCreatedChannels()
+  const chan = sample(channels)
+
+  expect(chan.diagnose).toHaveBeenCalledWith('recover', expect.any(Function))
+
+  const calls = chan.diagnose.mock.calls.filter((call) => call[0] === 'recover')
+  const listeners = calls.map((call) => call[1])
+
+  // emit 'recover'
+  const emit = () => { for (const listener of listeners) listener() }
+
+  expect(emit).not.toThrow()
+})
+
+/**
+ * @return {Promise<jest.MockedObject<comq.Channel>[]>}
+ */
+async function getCreatedChannels () {
+  const promises = connections.map((connection) => connection.createChannel.mock.results[0].value)
+
+  return await Promise.all(promises)
+}