comq 0.23.0 → 0.24.1

package/test/{io.request.terms.test.js → io.call.terms.test.js}

@@ -21,7 +21,8 @@ let requests
 /** @type {jest.MockedObject<comq.Channel>} */
 let replies
 
-const queue = generate()
+const exchange = generate()
+const key = generate()
 const payload = { [generate()]: generate() }
 
 beforeEach(async () => {
@@ -34,12 +35,12 @@ beforeEach(async () => {
 // endregion
 
 describe('timeout', () => {
-  it('should expire the Request when the caller stops waiting', async () => {
-    io.request(queue, payload, { timeout: 10000 }).catch(noop)
+  it('should expire the call when the caller stops waiting', async () => {
+    io.call(exchange, key, payload, { timeout: 10000 }).catch(noop)
 
     await initialized()
 
-    const expiration = Number(requests.send.mock.calls[0][2].expiration)
+    const expiration = Number(requests.route.mock.calls[0][3].expiration)
 
     expect(expiration).toBeGreaterThan(9000)
     expect(expiration).toBeLessThanOrEqual(10000)
@@ -48,29 +49,29 @@ describe('timeout', () => {
   it('should keep the encoding', async () => {
     const encoding = 'application/octet-stream'
 
-    io.request(queue, randomBytes(8), { encoding, timeout: 10000 }).catch(noop)
+    io.call(exchange, key, randomBytes(8), { encoding, timeout: 10000 }).catch(noop)
 
     await initialized()
 
-    expect(requests.send.mock.calls[0][2].contentType).toStrictEqual(encoding)
+    expect(requests.route.mock.calls[0][3].contentType).toStrictEqual(encoding)
   })
 
   it('should stop waiting while the channels are being created', async () => {
     connection.createChannel.mockImplementation(() => new Promise(noop))
 
-    const promise = io.request(queue, payload, { timeout: 20 })
+    const promise = io.call(exchange, key, payload, { timeout: 20 })
 
     await expect(promise).rejects.toMatchObject({ name: 'TimeoutError' })
   })
 
   it('should reject once it has passed', async () => {
-    const promise = io.request(queue, payload, { timeout: 20 })
+    const promise = io.call(exchange, key, payload, { timeout: 20 })
 
     await expect(promise).rejects.toMatchObject({ name: 'TimeoutError' })
   })
 
   it('should resolve with a reply that arrives in time', async () => {
-    const promise = io.request(queue, payload, { timeout: 10000 })
+    const promise = io.call(exchange, key, payload, { timeout: 10000 })
     const content = randomBytes(8)
 
     await initialized()
@@ -80,7 +81,7 @@ describe('timeout', () => {
   })
 
   it('should re-send with the time that is left', async () => {
-    io.request(queue, payload, { timeout: 10000 }).catch(noop)
+    io.call(exchange, key, payload, { timeout: 10000 }).catch(noop)
 
     await initialized()
     await timeout(20)
@@ -89,10 +90,10 @@ describe('timeout', () => {
 
     await immediate()
 
-    expect(requests.send).toHaveBeenCalledTimes(2)
+    expect(requests.route).toHaveBeenCalledTimes(2)
 
-    const first = Number(requests.send.mock.calls[0][2].expiration)
-    const second = Number(requests.send.mock.calls[1][2].expiration)
+    const first = Number(requests.route.mock.calls[0][3].expiration)
+    const second = Number(requests.route.mock.calls[1][3].expiration)
 
     expect(second).toBeLessThan(first)
   })
@@ -102,7 +103,7 @@ describe('signal', () => {
   it('should reject with the reason it was aborted for', async () => {
     const controller = new AbortController()
     const reason = new Error(generate())
-    const promise = io.request(queue, payload, { signal: controller.signal })
+    const promise = io.call(exchange, key, payload, { signal: controller.signal })
 
     await initialized()
 
@@ -111,14 +112,14 @@ describe('signal', () => {
     await expect(promise).rejects.toBe(reason)
   })
 
-  it('should leave the Request in its queue', async () => {
+  it('should leave the call in its queue', async () => {
     const controller = new AbortController()
 
-    io.request(queue, payload, { signal: controller.signal }).catch(noop)
+    io.call(exchange, key, payload, { signal: controller.signal }).catch(noop)
 
     await initialized()
 
-    expect(requests.send.mock.calls[0][2].expiration).toBeUndefined()
+    expect(requests.route.mock.calls[0][3].expiration).toBeUndefined()
   })
 
   it('should reject at once when aborted before the channels exist', async () => {
@@ -129,27 +130,27 @@ describe('signal', () => {
 
     controller.abort(reason)
 
-    await expect(io.request(queue, payload, { signal: controller.signal })).rejects.toBe(reason)
+    await expect(io.call(exchange, key, payload, { signal: controller.signal })).rejects.toBe(reason)
   })
 
   it('should send nothing once aborted', async () => {
     const controller = new AbortController()
 
-    // the channels exist before the aborted Request is made
-    io.request(queue, payload).catch(noop)
+    // the channels exist before the aborted call is made
+    io.call(exchange, key, payload).catch(noop)
 
     await initialized()
 
     controller.abort()
 
-    await expect(io.request(queue, payload, { signal: controller.signal })).rejects.toBeDefined()
+    await expect(io.call(exchange, key, payload, { signal: controller.signal })).rejects.toBeDefined()
 
-    expect(requests.send).toHaveBeenCalledTimes(1)
+    expect(requests.route).toHaveBeenCalledTimes(1)
   })
 
   it('should not re-send what it abandoned', async () => {
     const controller = new AbortController()
-    const promise = io.request(queue, payload, { signal: controller.signal })
+    const promise = io.call(exchange, key, payload, { signal: controller.signal })
 
     await initialized()
 
@@ -161,19 +162,19 @@ describe('signal', () => {
 
     await immediate()
 
-    expect(requests.send).toHaveBeenCalledTimes(1)
+    expect(requests.route).toHaveBeenCalledTimes(1)
   })
 
   it('should stop waiting for a publication', async () => {
-    io.request(queue, payload).catch(noop)
+    io.call(exchange, key, payload).catch(noop)
 
     await initialized()
 
-    requests.send.mockImplementationOnce(() => new Promise(noop))
+    requests.route.mockImplementationOnce(() => new Promise(noop))
 
     const controller = new AbortController()
     const reason = new Error(generate())
-    const promise = io.request(queue, payload, { signal: controller.signal })
+    const promise = io.call(exchange, key, payload, { signal: controller.signal })
 
     await immediate()
 
@@ -184,7 +185,7 @@ describe('signal', () => {
 
   it('should discard a reply that arrives afterwards', async () => {
     const controller = new AbortController()
-    const promise = io.request(queue, payload, { signal: controller.signal })
+    const promise = io.call(exchange, key, payload, { signal: controller.signal })
 
     await initialized()
 
@@ -197,7 +198,7 @@ describe('signal', () => {
 
   it('should end the wait within the timeout', async () => {
     const controller = new AbortController()
-    const promise = io.request(queue, payload, { signal: controller.signal, timeout: 20 })
+    const promise = io.call(exchange, key, payload, { signal: controller.signal, timeout: 20 })
 
     await expect(promise).rejects.toMatchObject({ name: 'TimeoutError' })
   })
@@ -216,7 +217,7 @@ async function initialized () {
  * @param {Buffer} [content]
  */
 async function answer (index, content = randomBytes(8)) {
-  const { correlationId } = requests.send.mock.calls[index][2]
+  const { correlationId } = requests.route.mock.calls[index][3]
   const deliver = replies.consume.mock.calls[0][1]
 
   await deliver({ content, properties: { correlationId } })

package/test/io.call.test.js

@@ -52,7 +52,7 @@ describe('call', () => {
 
   it('should publish to the exchange under the key', async () => {
     expect(requests.route).toHaveBeenCalledWith(exchange, key, expect.any(Buffer),
-      expect.objectContaining({ mandatory: true }))
+      expect.objectContaining({ mandatory: true }), expect.any(Function))
   })
 
   it('should declare no queue to publish to', async () => {
@@ -98,16 +98,6 @@ describe('call', () => {
   })
 })
 
-describe('timeout', () => {
-  it('should stop waiting while the channels are being created', async () => {
-    connection.createChannel.mockImplementation(() => new Promise(() => undefined))
-
-    const promise = io.call(exchange, key, payload, { timeout: 20 })
-
-    await expect(promise).rejects.toMatchObject({ name: 'TimeoutError' })
-  })
-})
-
 describe('back', () => {
   const producer = jest.fn(() => generate())
 
@@ -126,14 +116,16 @@ describe('back', () => {
     const contentType = 'application/json'
     const properties = { contentType, correlationId: generate(), replyTo: generate() }
 
-    await consumer({ content: encode(payload, contentType), properties })
+    const request = { content: encode(payload, contentType), properties }
+
+    await consumer(request)
 
     replies = await findChannel('reply')
 
     expect(producer).toHaveBeenCalledWith(payload)
 
     expect(replies.fire).toHaveBeenCalledWith(properties.replyTo, expect.any(Buffer),
-      expect.objectContaining({ correlationId: properties.correlationId }))
+      expect.objectContaining({ correlationId: properties.correlationId }), request)
   })
 })
 

package/test/io.reply.test.js

@@ -98,7 +98,8 @@ describe('reply', () => {
     const reply = await produce.mock.results[0].value
     const buffer = encode(reply, properties.contentType)
 
-    expect(replies.fire).toHaveBeenCalledWith(properties.replyTo, buffer, expect.anything())
+    // the request goes along, so that the reply goes back the way it came
+    expect(replies.fire).toHaveBeenCalledWith(properties.replyTo, buffer, expect.anything(), message)
   })
 
   it('should throw if producer returned undefined', async () => {
@@ -190,7 +191,7 @@ describe('encoding', () => {
       mandatory: true
     }
 
-    expect(replies.fire).toHaveBeenCalledWith(properties.replyTo, reply, props)
+    expect(replies.fire).toHaveBeenCalledWith(properties.replyTo, reply, props, message)
   })
 
   it('should set octet-stream for Buffer reply', async () => {
@@ -215,7 +216,8 @@ describe('encoding', () => {
       .toHaveBeenCalledWith(
         expect.any(String),
         buffer,
-        expect.objectContaining({ contentType: 'application/octet-stream' })
+        expect.objectContaining({ contentType: 'application/octet-stream' }),
+        message
       )
   })
 

package/test/io.request.test.js

@@ -5,6 +5,7 @@
 const stream = require('node:stream')
 const { randomBytes } = require('node:crypto')
 const { generate } = require('randomstring')
+const { Promex } = require('promex')
 const { immediate } = require('./helpers')
 const { encode } = require('../source/encode')
 
@@ -115,6 +116,19 @@ describe('send', () => {
     expect(call[2]).toMatchObject({ contentType })
   })
 
+  it('should not expire', async () => {
+    expect(call[2].expiration).toBeUndefined()
+  })
+
+  it('should refuse options other than the encoding', async () => {
+    requests.send.mockClear()
+
+    await expect(io.request(queue, payload, { timeout: 1000 })).rejects.toBeInstanceOf(TypeError)
+    await expect(io.request(queue, payload, { signal: new AbortController().signal })).rejects.toBeInstanceOf(TypeError)
+
+    expect(requests.send).not.toHaveBeenCalled()
+  })
+
   it('should throw if encoding is not supported', async () => {
     const encoding = /** @type {comq.Encoding} */ 'wtf/' + generate()
 
@@ -314,15 +328,276 @@ describe('send', () => {
   })
 })
 
+describe('shards', () => {
+  beforeEach(async () => {
+    jest.clearAllMocks()
+
+    connection = mock.connection(true)
+    io = new IO(connection)
+  })
+
+  /**
+   * Sends a Request through a shard.
+   *
+   * @param {number} index
+   * @param {string} target
+   * @return {Promise<void>}
+   */
+  async function ask (index, target) {
+    requests = await requestChannel()
+
+    requests.send.mockImplementationOnce(async (_queue, _buffer, _options, via) => via(index))
+
+    io.request(target, payload)
+
+    await immediate()
+  }
+
+  /**
+   * @return {Promise<jest.MockedObject<comq.Channel>>}
+   */
+  async function requestChannel () {
+    if (connection.createChannel.mock.calls.length === 0) {
+      // the channels are created with the first Request
+      io.request(generate(), payload)
+
+      await immediate()
+    }
+
+    return findChannel('request')
+  }
+
+  /**
+   * @param {jest.MockedObject<comq.Channel>} channel
+   * @return {string[]} the queues each publish went to
+   */
+  const targets = (channel) => channel.send.mock.calls.map(([queue]) => queue)
+
+  it('should re-send only the requests the lost shard holds', async () => {
+    const a = generate()
+    const b = generate()
+
+    await ask(0, a)
+    await ask(1, b)
+
+    requests.send.mockClear()
+
+    await lose(1)
+
+    expect(targets(requests)).toStrictEqual([b])
+
+    requests.send.mockClear()
+
+    // b has been re-sent through the shard that stays, and is held by it now
+    await lose(0)
+
+    expect(targets(requests)).toContain(a)
+    expect(targets(requests)).toContain(b)
+  })
+
+  it('should re-send only the requests of a shard whose reply channel recovers', async () => {
+    const a = generate()
+    const b = generate()
+
+    await ask(0, a)
+    await ask(1, b)
+
+    replies = await findChannel('reply')
+    requests.send.mockClear()
+
+    const calls = replies.diagnose.mock.calls.filter((call) => call[0] === 'recover')
+
+    for (const [, listener] of calls) listener(1)
+
+    await immediate()
+
+    expect(targets(requests)).toStrictEqual([b])
+  })
+
+  it('should re-send only the requests of a shard removed from the pool', async () => {
+    const a = generate()
+    const b = generate()
+
+    await ask(0, a)
+    await ask(1, b)
+
+    requests.send.mockClear()
+
+    const calls = requests.diagnose.mock.calls.filter((call) => call[0] === 'remove')
+
+    for (const [, listener] of calls) listener(0)
+
+    await immediate()
+
+    expect(targets(requests).includes(a)).toStrictEqual(true)
+    expect(targets(requests).includes(b)).toStrictEqual(false)
+  })
+
+  it('should re-send a request the lost shard held while it was being published', async () => {
+    requests = await requestChannel()
+
+    const published = new Promex()
+
+    requests.send.mockImplementationOnce(async (_queue, _buffer, _options, via) => {
+      via(1)
+
+      await published
+    })
+
+    const target = generate()
+
+    io.request(target, payload)
+
+    await immediate()
+    await lose(1)
+
+    // not before it is published
+    expect(targets(requests).filter((queue) => queue === target)).toHaveLength(1)
+
+    published.resolve()
+
+    await immediate()
+    await immediate()
+
+    expect(targets(requests).filter((queue) => queue === target)).toHaveLength(2)
+  })
+
+  it('should not re-send a request that failed over to another shard', async () => {
+    requests = await requestChannel()
+
+    const published = new Promex()
+
+    requests.send.mockImplementationOnce(async (_queue, _buffer, _options, via) => {
+      via(1)
+
+      await published
+
+      // the pool fails over from the lost shard
+      via(0)
+    })
+
+    const target = generate()
+
+    io.request(target, payload)
+
+    await immediate()
+    await lose(1)
+
+    published.resolve()
+
+    await immediate()
+    await immediate()
+
+    expect(targets(requests).filter((queue) => queue === target)).toHaveLength(1)
+
+    // it is held by the shard it went through
+    await lose(0)
+
+    expect(targets(requests).filter((queue) => queue === target)).toHaveLength(2)
+  })
+
+  it('should not re-send a request that went through another shard than the one lost as it was published', async () => {
+    requests = await requestChannel()
+
+    const published = new Promex()
+
+    requests.send.mockImplementationOnce(async (_queue, _buffer, _options, via) => {
+      via(0)
+
+      await published
+    })
+
+    const target = generate()
+
+    io.request(target, payload)
+
+    await immediate()
+    await lose(1)
+
+    published.resolve()
+
+    await immediate()
+    await immediate()
+
+    expect(targets(requests).filter((queue) => queue === target)).toHaveLength(1)
+  })
+
+  it('should re-send a returned call from the shard it was published on next', async () => {
+    requests = await requestChannel()
+
+    const key = generate()
+
+    requests.route.mockImplementationOnce(async (_exchange, _key, _buffer, _options, via) => via(0))
+
+    io.call(generate(), key, payload)
+
+    await immediate()
+
+    const [,,, properties] = requests.route.mock.calls[0]
+    const message = { fields: { exchange: generate(), routingKey: key }, properties }
+    const calls = requests.diagnose.mock.calls.filter((call) => call[0] === 'reroute')
+
+    expect(calls.length).toBeGreaterThan(0)
+
+    for (const [, listener] of calls) listener(message, 1)
+
+    await lose(0)
+
+    expect(requests.route).toHaveBeenCalledTimes(1)
+
+    await lose(1)
+
+    expect(requests.route).toHaveBeenCalledTimes(2)
+  })
+
+  it('should re-send a call the lost shard holds', async () => {
+    requests = await requestChannel()
+
+    requests.route.mockImplementationOnce(async (_exchange, _key, _buffer, _options, via) => via(1))
+
+    io.call(generate(), generate(), payload)
+
+    await immediate()
+    await lose(0)
+
+    expect(requests.route).toHaveBeenCalledTimes(1)
+
+    await lose(1)
+
+    expect(requests.route).toHaveBeenCalledTimes(2)
+  })
+})
+
+describe('recovery', () => {
+  it('should re-send every unanswered Request of a connection that is not sharded', async () => {
+    const other = generate()
+
+    io.request(other, payload)
+
+    await immediate()
+
+    requests.send.mockClear()
+
+    const calls = requests.diagnose.mock.calls.filter((call) => call[0] === 'recover')
+
+    for (const [, listener] of calls) listener()
+
+    await immediate()
+
+    expect(requests.send.mock.calls.map(([queue]) => queue).sort()).toStrictEqual([queue, other].sort())
+  })
+})
+
 /**
  * Fires the listeners the IO has attached to the shard loss diagnostic.
  *
+ * @param {number} [index]
  * @return {Promise<void>}
  */
-async function lose () {
+async function lose (index = 0) {
   const calls = requests.diagnose.mock.calls.filter((call) => call[0] === 'lost')
 
-  for (const [, listener] of calls) listener(0)
+  for (const [, listener] of calls) listener(index)
 
   await immediate()
   await immediate()

package/test/memory.test.js

@@ -12,7 +12,7 @@ const { timeout } = require('./helpers')
 const mock = require('./amqplib.mock')
 const { amqplib, connect } = mock
 
-jest.mock('amqplib', () => mock.amqplib)
+jest.mock('@toa.io/amqplib', () => mock.amqplib)
 
 const { connect: open, assert } = require('../source')
 const { SingletonConnection } = require('../source/singleton')
@@ -29,14 +29,12 @@ beforeEach(() => {
   amqplib.connect.mockImplementation(async (url) => wired(await connect(url)))
 
   global.COMQ_TESTING_SHUTDOWN_TIMEOUT = 1
-  global.COMQ_TESTING_WATCHDOG_INTERVAL = 60_000
 })
 
 afterEach(() => {
   SingletonConnection.__lets_pretend_this_method_doesnt_exist()
 
   delete global.COMQ_TESTING_SHUTDOWN_TIMEOUT
-  delete global.COMQ_TESTING_WATCHDOG_INTERVAL
 })
 
 afterAll(() => {