comq 0.25.1 → 0.26.0

package/test/connection.test.js

@@ -42,6 +42,21 @@ describe('initial connection', () => {
       expect.objectContaining({ timeout: expect.any(Number) }))
   })
 
+  it('should connect without a name to verify the broker by', async () => {
+    await connection.open()
+
+    expect(amqplib.connect.mock.calls[0][1]).not.toHaveProperty('servername')
+  })
+
+  it('should verify the broker by the name its address was resolved from', async () => {
+    connection = new Connection(url, {}, 'rmq.example.com')
+
+    await connection.open()
+
+    expect(amqplib.connect).toHaveBeenCalledWith(expect.stringContaining(url),
+      expect.objectContaining({ servername: 'rmq.example.com', timeout: expect.any(Number) }))
+  })
+
   it.each(/** @type {[string, Partial<Error>][]} */[
     ['Socket closed', { message: 'Socket closed abruptly during opening handshake' }],
     ['TLS disconnect', { message: 'Client network socket disconnected before secure TLS connection was established' }],

package/test/io.call.test.js

@@ -122,7 +122,7 @@ describe('back', () => {
 
     replies = await findChannel('reply')
 
-    expect(producer).toHaveBeenCalledWith(payload)
+    expect(producer).toHaveBeenCalledWith(payload, properties)
 
     expect(replies.fire).toHaveBeenCalledWith(properties.replyTo, expect.any(Buffer),
       expect.objectContaining({ correlationId: properties.correlationId }), request)

package/test/io.diagnostics.test.js

@@ -61,7 +61,7 @@ it('should not throw on error without listeners', async () => {
   expect(() => emit(new Error(generate()))).not.toThrow()
 })
 
-it.each(['open', 'close', 'error', 'reconnect', 'exhausted'])('should re-emit %s from connection',
+it.each(['open', 'close', 'error', 'reconnect', 'exhausted', 'join', 'retire', 'leave'])('should re-emit %s from connection',
   /**
    * @param {comq.diagnostics.Event} event
    */

package/test/io.reply.test.js

@@ -102,6 +102,17 @@ describe('reply', () => {
     expect(replies.fire).toHaveBeenCalledWith(properties.replyTo, buffer, expect.anything(), message)
   })
 
+  it('should pass the properties of the request to the producer', async () => {
+    const content = randomBytes(10)
+    const properties = { contentType: 'text/plain', headers: { [generate()]: generate() } }
+    const message = /** @type {comq.amqp.Message} */ { content, properties }
+    const producer = requests.consume.mock.calls[0][1]
+
+    await producer(message)
+
+    expect(produce).toHaveBeenCalledWith(expect.anything(), properties)
+  })
+
   it('should throw if producer returned undefined', async () => {
     jest.clearAllMocks()
 
@@ -161,7 +172,7 @@ describe('encoding', () => {
 
     await producer(message)
 
-    expect(produce).toHaveBeenCalledWith(value)
+    expect(produce).toHaveBeenCalledWith(value, properties)
   })
 
   it.each(encodings)('should encode reply with same encoding (%s)', async (encoding) => {

package/test/io.request.test.js

@@ -120,6 +120,24 @@ describe('send', () => {
     expect(call[2].expiration).toBeUndefined()
   })
 
+  it('should send the properties it is given, as a Request still', async () => {
+    requests.send.mockClear()
+
+    const headers = { [generate()]: generate() }
+
+    setImmediate(reply)
+
+    await io.request(queue, payload, { headers, contentType: 'text/plain', replyTo: generate() })
+
+    const [, buffer, properties] = requests.send.mock.calls[0]
+
+    expect(buffer).toStrictEqual(encode(payload, 'text/plain'))
+    expect(properties.headers).toStrictEqual(headers)
+    expect(properties.contentType).toStrictEqual('text/plain')
+    expect(properties.replyTo).toStrictEqual(call[2].replyTo)
+    expect(properties.correlationId).toBeDefined()
+  })
+
   it('should refuse options other than the encoding', async () => {
     requests.send.mockClear()
 

package/test/io.shards.test.js

@@ -0,0 +1,85 @@
+'use strict'
+
+const { generate } = require('randomstring')
+const { immediate } = require('./helpers')
+const { encode } = require('../source/encode')
+
+const mock = require('./connection.mock')
+const { IO } = require('../source/io')
+
+/** @type {comq.IO} */
+let io
+
+/** @type {jest.MockedObject<comq.Connection>} */
+let connection
+
+/** @type {jest.MockedObject<comq.Channel>} */
+let requests
+
+/** @type {jest.MockedObject<comq.Channel>} */
+let replies
+
+/** @type {(index: number) => boolean} */
+let occupied
+
+let promise
+
+const findChannel = (type) => {
+  const index = connection.createChannel.mock.calls.findIndex(([t]) => (t === type))
+
+  return connection.createChannel.mock.results[index].value
+}
+
+beforeEach(async () => {
+  jest.clearAllMocks()
+
+  connection = mock.connection(true)
+  io = new IO(connection)
+  promise = io.request(generate(), { [generate()]: generate() })
+
+  await immediate()
+
+  requests = await findChannel('request')
+  replies = await findChannel('reply')
+  occupied = requests.occupy.mock.calls[0][0]
+})
+
+it('should tell the request channel which shards owe a Reply', async () => {
+  expect(requests.occupy).toHaveBeenCalledWith(expect.any(Function))
+})
+
+it('should say so of the shard an unanswered Request went through', async () => {
+  expect(occupied(0)).toStrictEqual(true)
+})
+
+it('should not say so of another shard', async () => {
+  expect(occupied(1)).toStrictEqual(false)
+})
+
+it('should not say so once the Request is answered', async () => {
+  const { correlationId, contentType } = requests.send.mock.calls[0][2]
+  const consumer = replies.consume.mock.calls[0][1]
+
+  consumer({ content: encode(generate(), contentType), properties: { correlationId, contentType } })
+
+  await promise
+
+  expect(occupied(0)).toStrictEqual(false)
+})
+
+it('should not tell a channel that is not sharded', async () => {
+  connection = mock.connection()
+  connection.createChannel.mockImplementation(async (type, index) => {
+    const channel = mock.channel(false, index)
+
+    delete channel.occupy
+
+    return channel
+  })
+
+  io = new IO(connection)
+
+  expect(() => io.request(generate(), generate())).not.toThrow()
+
+  await immediate()
+})

package/test/shards/channel.test.js

@@ -985,3 +985,414 @@ function emitRecover (chan) {
 
   for (const call of calls) call[1]()
 }
+
+describe('a shard that joins', () => {
+  /** @type {jest.MockedObject<comq.Connection>} */
+  let joiner
+
+  /** @type {jest.MockedObject<comq.Channel>} */
+  let joined
+
+  const consumer = jest.fn()
+
+  const channelOf = async (connection) => await connection.createChannel.mock.results.at(-1).value
+
+  const sendMany = async () => {
+    for (let i = 0; i < 100; i++) await channel.send(generate(), randomBytes(8))
+  }
+
+  beforeEach(async () => {
+    channel = await create(connections, type)
+    joiner = mock.connection()
+  })
+
+  it('should tell whether a shard is its own', async () => {
+    expect(channel.has(1)).toStrictEqual(true)
+    expect(channel.has(2)).toStrictEqual(false)
+
+    await channel.join(joiner, 2)
+
+    expect(channel.has(2)).toStrictEqual(true)
+  })
+
+  it('should create a channel of the type, numbered as the shard is', async () => {
+    await channel.join(joiner, 2)
+
+    expect(joiner.createChannel).toHaveBeenCalledWith(type, 2)
+  })
+
+  it('should not join twice', async () => {
+    await channel.join(joiner, 2)
+    await channel.join(joiner, 2)
+
+    expect(joiner.createChannel).toHaveBeenCalledTimes(1)
+  })
+
+  it('should consume what has been consumed', async () => {
+    await channel.consume('q', consumer)
+    await channel.subscribe('x', 'g', consumer)
+    await channel.bound('x', 'q', 'k', consumer)
+    await channel.held('x', 'q', 'k', consumer)
+
+    await channel.join(joiner, 2)
+
+    joined = await channelOf(joiner)
+
+    expect(joined.consume).toHaveBeenCalledWith('q', expect.any(Function))
+    expect(joined.subscribe).toHaveBeenCalledWith('x', 'g', consumer)
+    expect(joined.bound).toHaveBeenCalledWith('x', 'q', 'k', consumer)
+    expect(joined.held).toHaveBeenCalledWith('x', 'q', 'k', expect.any(Function))
+  })
+
+  it('should consume what is consumed afterwards', async () => {
+    await channel.join(joiner, 2)
+    await channel.consume('q', consumer)
+
+    joined = await channelOf(joiner)
+
+    expect(joined.consume).toHaveBeenCalledTimes(1)
+  })
+
+  it('should not be published through before it consumes', async () => {
+    const consuming = new Promex()
+
+    await channel.consume('q', consumer)
+
+    joiner.createChannel.mockImplementationOnce(async (type, index) => {
+      const chan = mock.channel(false, index)
+
+      chan.consume.mockImplementation(() => consuming)
+
+      return chan
+    })
+
+    const joining = channel.join(joiner, 2)
+
+    await immediate()
+    await sendMany()
+
+    joined = await channelOf(joiner)
+
+    expect(joined.consume).toHaveBeenCalled()
+    expect(joined.send).not.toHaveBeenCalled()
+
+    consuming.resolve()
+
+    await joining
+    await sendMany()
+
+    expect(joined.send).toHaveBeenCalled()
+  })
+
+  it('should not wait for a key that is held by another', async () => {
+    await channel.held('x', 'q', 'k', consumer)
+
+    joiner.createChannel.mockImplementationOnce(async (type, index) => {
+      const chan = mock.channel(false, index)
+
+      chan.held.mockImplementation(() => new Promex())
+
+      return chan
+    })
+
+    await channel.join(joiner, 2)
+    await sendMany()
+
+    joined = await channelOf(joiner)
+
+    expect(joined.send).toHaveBeenCalled()
+  })
+
+  it('should not consume what a sealed channel consumed', async () => {
+    await channel.consume('q', consumer)
+    await channel.seal()
+    await channel.join(joiner, 2)
+
+    joined = await channelOf(joiner)
+
+    expect(joined.consume).not.toHaveBeenCalled()
+  })
+
+  it('should not be its shard when no channel can be made for it', async () => {
+    const exception = new Error('No channels left to allocate')
+
+    joiner.createChannel.mockImplementationOnce(async () => { throw exception })
+
+    await expect(channel.join(joiner, 2)).rejects.toThrow(exception)
+
+    expect(channel.has(2)).toStrictEqual(false)
+
+    // and may be joined again
+    await channel.join(joiner, 2)
+
+    expect(channel.has(2)).toStrictEqual(true)
+  })
+
+  it('should not join when it cannot consume what the rest do', async () => {
+    const exception = new Error('PRECONDITION_FAILED')
+
+    await channel.consume('q', consumer)
+
+    joiner.createChannel.mockImplementationOnce(async (type, index) => {
+      const chan = mock.channel(false, index)
+
+      chan.consume.mockImplementation(async () => { throw exception })
+
+      return chan
+    })
+
+    await expect(channel.join(joiner, 2)).rejects.toThrow(exception)
+
+    joined = await channelOf(joiner)
+
+    await sendMany()
+
+    expect(channel.has(2)).toStrictEqual(false)
+    expect(joined.close).toHaveBeenCalled()
+    expect(joined.send).not.toHaveBeenCalled()
+  })
+
+  it('should not consume what no shard could', async () => {
+    const chans = await Promise.all(connections.map((conn) => channelOf(conn)))
+
+    for (const chan of chans) chan.consume.mockImplementationOnce(async () => { throw new Error('oops') })
+
+    await expect(channel.consume('q', consumer)).rejects.toThrow()
+    await channel.join(joiner, 2)
+
+    joined = await channelOf(joiner)
+
+    expect(joined.consume).not.toHaveBeenCalled()
+  })
+
+  it.each(['seal', 'close'])('should %s a shard that is joining with the rest', async (method) => {
+    const consuming = new Promex()
+
+    await channel.consume('q', consumer)
+
+    joiner.createChannel.mockImplementationOnce(async (type, index) => {
+      const chan = mock.channel(false, index)
+
+      chan.consume.mockImplementation(() => consuming)
+
+      return chan
+    })
+
+    const joining = channel.join(joiner, 2)
+
+    await immediate()
+    await channel[method]()
+
+    joined = await channelOf(joiner)
+
+    expect(joined[method]).toHaveBeenCalled()
+
+    consuming.resolve()
+
+    await joining
+  })
+
+  it('should not be published through when closed while joining', async () => {
+    const consuming = new Promex()
+
+    await channel.consume('q', consumer)
+
+    joiner.createChannel.mockImplementationOnce(async (type, index) => {
+      const chan = mock.channel(false, index)
+
+      chan.consume.mockImplementation(() => consuming)
+
+      return chan
+    })
+
+    const joining = channel.join(joiner, 2)
+
+    await immediate()
+    await channel.close()
+
+    consuming.resolve()
+
+    await joining
+
+    joined = await channelOf(joiner)
+
+    expect(joined.close).toHaveBeenCalled()
+    expect(joined.send).not.toHaveBeenCalled()
+  })
+
+  it('should tell which shard a message arrived on', async () => {
+    await channel.consume('q', consumer)
+    await channel.join(joiner, 2)
+
+    joined = await channelOf(joiner)
+
+    const message = { content: randomBytes(8) }
+
+    await joined.consume.mock.calls[0][1](message)
+    await channel.fire('reply', randomBytes(8), {}, message)
+
+    expect(joined.fire).toHaveBeenCalled()
+  })
+})
+
+describe('a shard that retires', () => {
+  /** @type {jest.MockedObject<comq.Channel>[]} */
+  let chans
+
+  const sendMany = async () => {
+    for (let i = 0; i < 100; i++) await channel.send(generate(), randomBytes(8))
+  }
+
+  beforeEach(async () => {
+    channel = await create(connections, type)
+    chans = await Promise.all(connections.map((conn) => conn.createChannel.mock.results.at(-1).value))
+  })
+
+  it('should not be published through', async () => {
+    channel.retire(1)
+
+    await sendMany()
+
+    expect(chans[0].send).toHaveBeenCalledTimes(100)
+    expect(chans[1].send).not.toHaveBeenCalled()
+  })
+
+  it('should still take back what answers a message that arrived on it', async () => {
+    await channel.consume('q', jest.fn())
+
+    const message = { content: randomBytes(8) }
+
+    await chans[1].consume.mock.calls[0][1](message)
+
+    channel.retire(1)
+
+    for (let i = 0; i < 20; i++) await channel.fire('reply', randomBytes(8), {}, message)
+
+    expect(chans[1].fire).toHaveBeenCalledTimes(20)
+  })
+
+  it('should go on being consumed from', async () => {
+    channel.retire(1)
+
+    await channel.consume('q', jest.fn())
+
+    expect(chans[1].consume).toHaveBeenCalled()
+  })
+
+  it('should pause once no other shard is left', async () => {
+    const pause = jest.fn()
+    const resume = jest.fn()
+
+    channel.diagnose('pause', pause)
+    channel.diagnose('resume', resume)
+
+    channel.retire(0)
+    channel.retire(1)
+
+    expect(pause).toHaveBeenCalled()
+
+    channel.restore(1)
+
+    expect(resume).toHaveBeenCalled()
+  })
+
+  it('should be published through again once restored', async () => {
+    channel.retire(1)
+    channel.restore(1)
+
+    await sendMany()
+
+    expect(chans[1].send).toHaveBeenCalled()
+  })
+
+  it('should tell since when it has had nothing to do', async () => {
+    chans[1].quiet.mockImplementation(async () => 42)
+
+    await expect(channel.quiet(1)).resolves.toStrictEqual(42)
+  })
+
+  it('should have something to do while whoever publishes says so', async () => {
+    channel.occupy((index) => index === 1)
+
+    const now = Date.now()
+
+    expect(await channel.quiet(1)).toBeGreaterThanOrEqual(now)
+    expect(await channel.quiet(0)).toStrictEqual(0)
+  })
+
+  describe('and leaves', () => {
+    it('should seal its channel, wait for what it delivered, and close it', async () => {
+      const order = []
+
+      chans[1].seal.mockImplementation(async () => order.push('seal'))
+      chans[1].settled.mockImplementation(async () => order.push('settled'))
+      chans[1].close.mockImplementation(async () => order.push('close'))
+
+      await channel.leave(1)
+
+      expect(order).toStrictEqual(['seal', 'settled', 'close'])
+      expect(chans[0].close).not.toHaveBeenCalled()
+    })
+
+    it('should be the way back until what it delivered is done with', async () => {
+      const settled = new Promex()
+
+      await channel.consume('q', jest.fn())
+
+      const message = { content: randomBytes(8) }
+
+      await chans[1].consume.mock.calls[0][1](message)
+
+      chans[1].settled.mockImplementation(() => settled)
+      channel.retire(1)
+
+      const leaving = channel.leave(1)
+
+      await immediate()
+      await channel.fire('reply', randomBytes(8), {}, message)
+
+      expect(chans[1].fire).toHaveBeenCalled()
+
+      settled.resolve()
+
+      await leaving
+      await channel.fire('reply', randomBytes(8), {}, message)
+
+      expect(chans[0].fire).toHaveBeenCalled()
+    })
+
+    it('should not be its shard any longer', async () => {
+      await channel.leave(1)
+
+      expect(channel.has(1)).toStrictEqual(false)
+
+      await sendMany()
+
+      expect(chans[1].send).not.toHaveBeenCalled()
+    })
+
+    it('should not be consumed from', async () => {
+      await channel.leave(1)
+      await channel.consume('q', jest.fn())
+
+      expect(chans[1].consume).not.toHaveBeenCalled()
+    })
+
+    it('should not come back when its channel recovers', async () => {
+      await channel.leave(1)
+
+      for (const [event, listener] of chans[1].diagnose.mock.calls) if (event === 'recover') listener()
+
+      await sendMany()
+
+      expect(chans[1].send).not.toHaveBeenCalled()
+    })
+
+    it('should stop listening to its connection', async () => {
+      await channel.leave(1)
+
+      expect(connections[1].forget).toHaveBeenCalledWith('close', expect.any(Function))
+      expect(connections[1].forget).toHaveBeenCalledWith('open', expect.any(Function))
+    })
+  })
+})