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

package/test/channel.test.js

@@ -15,7 +15,7 @@ it('should be', async () => {
   expect(create).toBeDefined()
 })
 
-/** @type {jest.MockedObject<import('amqplib').Connection>} */
+/** @type {jest.MockedObject<comq.amqp.Connection>} */
 let connection
 
 /** @type {comq.Topology} */
@@ -83,7 +83,7 @@ describe('consume', () => {
     expect(chan.consume).toHaveBeenCalledWith(queue, expect.any(Function), expect.anything())
 
     const content = randomBytes(8)
-    const message = /** @type {import('amqplib').ConsumeMessage} */ { content }
+    const message = /** @type {comq.amqp.Message} */ { content }
     const callback = chan.consume.mock.calls[0][1]
 
     await callback(message)
@@ -108,7 +108,7 @@ describe('acknowledgments', () => {
 
     const callback = chan.consume.mock.calls[0][1]
     const content = randomBytes(8)
-    const message = /** @type {import('amqplib').ConsumeMessage} */ { content }
+    const message = /** @type {comq.amqp.Message} */ { content }
 
     await callback(message)
 
@@ -149,7 +149,7 @@ describe('acknowledgments', () => {
     const content = randomBytes(8)
     const properties = {}
     const fields = {}
-    const message = /** @type {import('amqplib').ConsumeMessage} */ { content, properties, fields }
+    const message = /** @type {comq.amqp.Message} */ { content, properties, fields }
 
     if (!requeue) fields.redelivered = !requeue
 
@@ -172,7 +172,7 @@ describe('acknowledgments', () => {
     const content = randomBytes(8)
     const properties = {}
     const fields = {}
-    const message = /** @type {import('amqplib').ConsumeMessage} */ { content, properties, fields }
+    const message = /** @type {comq.amqp.Message} */ { content, properties, fields }
 
     chan.ack.mockImplementation(() => { throw new Error('Channel closed') })
     chan.nack.mockImplementation(() => { throw new Error('Channel closed') })
@@ -308,11 +308,44 @@ describe('throw', () => {
     expect(call[3]).toMatchObject(options)
   })
 
-  it('should catch exceptions', async () => {
+  it('should ignore exceptions', async () => {
     chan.publish.mockImplementation(() => { throw new Error() })
 
     await expect(channel.throw(queue, buffer, options)).resolves.not.toThrow()
   })
+
+  it('should wait for unpause', async () => {
+    jest.clearAllMocks()
+
+    topology.confirms = false
+    channel = await create(connection, topology)
+
+    const exchange = generate()
+    const queue = generate()
+    const buffer = randomBytes(8)
+    const options = { contentType: 'application/octet-stream' }
+
+    // create channel
+    await channel.publish(exchange, buffer, options)
+
+    const chan = await getCreatedChannel()
+
+    chan.publish.mockImplementation(() => false)
+
+    await channel.publish(exchange, buffer, options) // now paused
+
+    expect(chan.publish).toHaveBeenCalledTimes(2)
+
+    setImmediate(async () => {
+      expect(chan.publish).toHaveBeenCalledTimes(2)
+
+      chan.emit('drain')
+    })
+
+    await channel.throw(queue, buffer, options)
+
+    expect(chan.publish).toHaveBeenCalledTimes(3)
+  })
 })
 
 describe.each(['group', 'exclusive'])('%s subscribe', (option) => {
@@ -447,6 +480,9 @@ describe('publish', () => {
 })
 
 describe('seal', () => {
+  const queue = generate()
+  const consumer = jest.fn()
+
   beforeEach(async () => {
     channel = await create(connection, topology)
     chan = await getCreatedChannel()
@@ -460,9 +496,6 @@ describe('seal', () => {
     const tags = []
 
     for (let i = 0; i < random(5) + 3; i++) {
-      const queue = generate()
-      const consumer = jest.fn()
-
       await channel.consume(queue, consumer)
 
       const { consumerTag: tag } = await chan.consume.mock.results[i].value
@@ -477,6 +510,14 @@ describe('seal', () => {
 
     for (const tag of tags) expect(chan.cancel).toHaveBeenCalledWith(tag)
   })
+
+  it('should ignore exceptions', async () => {
+    await channel.consume(queue, consumer)
+
+    chan.cancel.mockImplementationOnce(async () => { throw new Error() })
+
+    await expect(channel.seal()).resolves.not.toThrow()
+  })
 })
 
 describe('back pressure', () => {
@@ -528,224 +569,238 @@ describe('recovery', () => {
     await expect(channel.consume(queue, consumer)).rejects.toStrictEqual(exception)
   })
 
-  it('should assert queue after recovery', async () => {
-    chan.assertQueue.mockImplementation(async () => { throw new Error('Channel closed') })
+  describe.each(/** @type {[string, boolean][]} */ [
+    ['', false],
+    [' not', true]
+  ])('should%s restore incoming (sealed: %s)', (not, sealed) => {
+    beforeEach(async () => {
+      if (sealed) await channel.seal()
+    })
 
-    /** @type {comq.amqp.Connection} */
-    let replacement
+    it('should re-assert queue after recovery', async () => {
+      chan.assertQueue.mockImplementation(async () => { throw new Error('Channel closed') })
 
-    setImmediate(async () => {
-      chan.assertQueue.mockImplementation(async () => {})
+      /** @type {comq.amqp.Connection} */
+      let replacement
 
-      replacement = await amqplib.connect()
+      setImmediate(async () => {
+        chan.assertQueue.mockImplementation(async () => {})
 
-      await channel.recover(replacement)
+        replacement = await amqplib.connect()
+
+        await channel.recover(replacement)
+      })
+
+      await channel.consume(queue, consumer)
+
+      const repl = await getCreatedChannel(replacement)
+
+      expect(repl.assertQueue).toHaveBeenCalled()
     })
 
-    await channel.consume(queue, consumer)
+    it('should re-assert exchange after exception', async () => {
+      chan.assertExchange.mockImplementation(async () => { throw new Error('Channel ended, no reply will be forthcoming') })
 
-    const repl = await getCreatedChannel(replacement)
+      /** @type {comq.amqp.Connection} */
+      let replacement
 
-    expect(repl.assertQueue).toHaveBeenCalled()
-  })
+      setImmediate(async () => {
+        chan.assertExchange.mockImplementation(async () => {})
 
-  it('should re-assert exchange after exception', async () => {
-    chan.assertExchange.mockImplementation(async () => { throw new Error('Channel ended, no reply will be forthcoming') })
+        replacement = await amqplib.connect()
 
-    /** @type {comq.amqp.Connection} */
-    let replacement
+        await channel.recover(replacement)
+      })
 
-    setImmediate(async () => {
-      chan.assertExchange.mockImplementation(async () => {})
+      await channel.subscribe(exchange, queue, consumer)
 
-      replacement = await amqplib.connect()
+      const repl = await getCreatedChannel(replacement)
 
-      await channel.recover(replacement)
+      expect(repl.assertExchange).toHaveBeenCalled()
     })
 
-    await channel.subscribe(exchange, queue, consumer)
+    it('should re-bind queue after exception', async () => {
+      chan.bindQueue.mockImplementation(async () => { throw new Error('Channel ended, no reply will be forthcoming') })
 
-    const repl = await getCreatedChannel(replacement)
+      /** @type {comq.amqp.Connection} */
+      let replacement
 
-    expect(repl.assertExchange).toHaveBeenCalled()
-  })
+      setImmediate(async () => {
+        chan.bindQueue.mockImplementation(async () => {})
 
-  it('should re-bind queue after exception', async () => {
-    chan.bindQueue.mockImplementation(async () => { throw new Error('Channel ended, no reply will be forthcoming') })
+        replacement = await amqplib.connect()
 
-    /** @type {comq.amqp.Connection} */
-    let replacement
+        await channel.recover(replacement)
+      })
 
-    setImmediate(async () => {
-      chan.bindQueue.mockImplementation(async () => {})
+      await channel.subscribe(exchange, queue, consumer)
 
-      replacement = await amqplib.connect()
+      expect(replacement).toBeDefined()
 
-      await channel.recover(replacement)
+      const repl = await getCreatedChannel(replacement)
+
+      expect(repl.bindQueue).toHaveBeenCalled()
     })
 
-    await channel.subscribe(exchange, queue, consumer)
+    it(`should${not} re-consume after recovery`, async () => {
+      await channel.consume(queue, consumer)
 
-    expect(replacement).toBeDefined()
+      const replacement = await amqplib.connect()
 
-    const repl = await getCreatedChannel(replacement)
+      await channel.recover(replacement)
 
-    expect(repl.bindQueue).toHaveBeenCalled()
-  })
+      const chan = await getCreatedChannel(replacement)
 
-  it('should re-consume after recovery', async () => {
-    await channel.consume(queue, consumer)
+      if (sealed) expect(chan.consume).not.toHaveBeenCalled()
+      else expect(chan.consume).toHaveBeenCalledWith(queue, expect.any(Function), expect.anything())
+    })
 
-    const replacement = await amqplib.connect()
+    it(`should${not} re-consume after exception `, async () => {
+      chan.consume.mockImplementation(async () => { throw new Error('Channel ended, no reply will be forthcoming') })
 
-    await channel.recover(replacement)
+      /** @type {comq.amqp.Connection} */
+      let replacement
 
-    const chan = await getCreatedChannel(replacement)
+      setTimeout(async () => {
+        // noinspection JSCheckFunctionSignatures
+        chan.consume.mockImplementation(async () => ({ consumerTag: generate() }))
+        replacement = await amqplib.connect()
 
-    expect(chan.consume).toHaveBeenCalledWith(queue, expect.any(Function), expect.anything())
-  })
+        await channel.recover(replacement)
+      }, 1)
 
-  it('should re-consume after exception ', async () => {
-    chan.consume.mockImplementation(async () => { throw new Error('Channel ended, no reply will be forthcoming') })
+      await channel.consume(queue, consumer)
 
-    /** @type {comq.amqp.Connection} */
-    let replacement
+      const repl = await getCreatedChannel(replacement)
 
-    setTimeout(async () => {
-      // noinspection JSCheckFunctionSignatures
-      chan.consume.mockImplementation(async () => ({ consumerTag: generate() }))
-      replacement = await amqplib.connect()
+      if (sealed) expect(repl.consume).not.toHaveBeenCalled()
+      else expect(repl.consume).toHaveBeenCalled()
+    })
 
-      await channel.recover(replacement)
-    }, 1)
+    it(`should${not} re-subscribe after recovery`, async () => {
+      await channel.subscribe(exchange, queue, consumer)
 
-    await channel.consume(queue, consumer)
+      const replacement = await amqplib.connect()
 
-    const repl = await getCreatedChannel(replacement)
+      await channel.recover(replacement)
 
-    expect(repl.consume).toHaveBeenCalled()
-  })
+      const repl = await getCreatedChannel(replacement)
 
-  it('should re-subscribe after recovery', async () => {
-    await channel.subscribe(exchange, queue, consumer)
+      if (sealed) expect(repl.consume).not.toHaveBeenCalled()
+      else expect(repl.consume).toHaveBeenCalledWith(queue, expect.any(Function), expect.anything())
+    })
 
-    const replacement = await amqplib.connect()
+    it('should re-send after exception', async () => {
+      const queue = generate()
+      const buffer = Buffer.from(generate())
 
-    await channel.recover(replacement)
+      /** @type {comq.amqp.Connection} */
+      let replacement
 
-    const repl = await getCreatedChannel(replacement)
+      chan.publish.mockImplementation(() => { throw new Error('Channel closed') })
 
-    expect(repl.consume).toHaveBeenCalledWith(queue, expect.any(Function), expect.anything())
-  })
+      setImmediate(async () => {
+        expect(chan.publish).toHaveBeenCalled()
 
-  it('should re-send after exception', async () => {
-    const queue = generate()
-    const buffer = Buffer.from(generate())
+        chan.publish.mockImplementation(async () => {})
+        replacement = await amqplib.connect()
 
-    /** @type {comq.amqp.Connection} */
-    let replacement
+        await channel.recover(replacement)
+      })
 
-    chan.publish.mockImplementation(() => { throw new Error('Channel closed') })
+      await channel.send(queue, buffer)
 
-    setTimeout(async () => {
-      expect(chan.publish).toHaveBeenCalled()
+      const repl = await getCreatedChannel(replacement)
 
-      chan.publish.mockImplementation(async () => {})
-      replacement = await amqplib.connect()
+      expect(repl.publish).toHaveBeenCalled()
+    })
 
-      await channel.recover(replacement)
-    }, 1)
+    it('should re-publish unconfirmed messages', async () => {
+      jest.clearAllMocks()
 
-    await channel.send(queue, buffer)
+      const exchange = generate()
+      const buffer = randomBytes(8)
+      const options = { contentType: 'application/octet-stream' }
 
-    const repl = await getCreatedChannel(replacement)
+      topology.confirms = true
+      channel = await create(connection, topology)
 
-    expect(repl.publish).toHaveBeenCalled()
-  })
+      // create channel
+      await channel.consume(generate(), () => undefined)
 
-  it('should re-publish unconfirmed messages', async () => {
-    jest.clearAllMocks()
+      const chan = await getCreatedChannel()
 
-    const exchange = generate()
-    const buffer = randomBytes(8)
-    const options = { contentType: 'application/octet-stream' }
+      chan.publish.mockImplementation(() => true)
 
-    topology.confirms = true
-    channel = await create(connection, topology)
+      /** @type {jest.MockedObject<comq.amqp.Connection>} */
+      let replacement
 
-    // create channel
-    await channel.consume(generate(), () => undefined)
+      setImmediate(async () => {
+        replacement = await amqplib.connect()
 
-    const chan = await getCreatedChannel()
+        await channel.recover(replacement)
+      })
 
-    chan.publish.mockImplementation(() => true)
+      await channel.publish(exchange, buffer, options)
 
-    /** @type {jest.MockedObject<comq.amqp.Connection>} */
-    let replacement
+      expect(replacement).toBeDefined()
 
-    setImmediate(async () => {
-      replacement = await amqplib.connect()
+      const repl = await getCreatedChannel(replacement)
 
-      await channel.recover(replacement)
+      expect(repl.publish).toHaveBeenCalledWith(
+        exchange, '', buffer, expect.objectContaining(options), expect.any(Function)
+      )
     })
 
-    await channel.publish(exchange, buffer, options)
+    it('should unpause on recovery', async () => {
+      jest.clearAllMocks()
 
-    expect(replacement).toBeDefined()
+      topology.confirms = false
+      channel = await create(connection, topology)
 
-    const repl = await getCreatedChannel(replacement)
+      const exchange = generate()
+      const buffer = randomBytes(8)
+      const options = { contentType: 'application/octet-stream' }
 
-    expect(repl.publish).toHaveBeenCalledWith(
-      exchange, '', buffer, expect.objectContaining(options), expect.any(Function)
-    )
-  })
+      // create channel
+      await channel.publish(exchange, buffer, options)
 
-  it('should unpause on recovery', async () => {
-    jest.clearAllMocks()
+      const chan = await getCreatedChannel()
 
-    topology.confirms = false
-    channel = await create(connection, topology)
+      chan.publish.mockImplementation(() => false)
 
-    const exchange = generate()
-    const buffer = randomBytes(8)
-    const options = { contentType: 'application/octet-stream' }
+      await channel.publish(exchange, buffer, options) // now paused
 
-    // create channel
-    await channel.publish(exchange, buffer, options)
+      expect(chan.publish).toHaveBeenCalledTimes(2)
 
-    const chan = await getCreatedChannel()
+      /** @type {jest.MockedObject<comq.amqp.Connection>} */
+      let replacement
 
-    chan.publish.mockImplementation(() => false)
+      setImmediate(async () => {
+        replacement = await amqplib.connect()
 
-    await channel.publish(exchange, buffer, options) // now paused
+        await channel.recover(replacement)
+      })
 
-    expect(chan.publish).toHaveBeenCalledTimes(2)
+      await channel.publish(exchange, buffer, options)
 
-    /** @type {jest.MockedObject<comq.amqp.Connection>} */
-    let replacement
+      expect(replacement).toBeDefined()
 
-    setImmediate(async () => {
-      replacement = await amqplib.connect()
+      const repl = await getCreatedChannel(replacement)
 
-      await channel.recover(replacement)
+      expect(repl.publish).toHaveBeenCalled()
     })
 
-    await channel.publish(exchange, buffer, options)
-
-    const repl = await getCreatedChannel(replacement)
+    it('should emit recover event', async () => {
+      const listener = /** @type {Function} */ jest.fn()
 
-    expect(repl.publish).toHaveBeenCalled()
-  })
-
-  it('should emit recover event', async () => {
-    const listener = /** @type {Function} */ jest.fn()
-
-    channel = await create(connection, topology)
-    channel.diagnose('recover', listener)
+      channel = await create(connection, topology)
+      channel.diagnose('recover', listener)
 
-    await channel.recover(connection)
+      await channel.recover(connection)
 
-    expect(listener).toHaveBeenCalled()
+      expect(listener).toHaveBeenCalled()
+    })
   })
 })
 
@@ -804,7 +859,7 @@ describe('diagnostics', () => {
     const content = randomBytes(8)
     const properties = {}
     const fields = { redelivered }
-    const message = /** @type {import('amqplib').ConsumeMessage} */ { content, properties, fields }
+    const message = /** @type {comq.amqp.Message} */ { content, properties, fields }
 
     await callback(message)
 
@@ -813,6 +868,46 @@ describe('diagnostics', () => {
   })
 })
 
+describe('transient', () => {
+  const exchange = generate()
+  const queue = generate()
+  const buffer = randomBytes(8)
+  const index = random()
+
+  beforeEach(async () => {
+    channel = await create(connection, topology, index)
+    chan = await getCreatedChannel()
+  })
+
+  it('should throw transient exceptions on publish', async () => {
+    chan.publish.mockImplementation(() => { throw new Error('Channel closed') })
+
+    await expect(channel.publish(exchange, buffer)).rejects.toThrow()
+  })
+
+  it('should throw transient exceptions on send', async () => {
+    chan.publish.mockImplementation(() => { throw new Error('Channel closed') })
+
+    await expect(channel.send(queue, buffer)).rejects.toThrow()
+  })
+
+  it('should throw on back pressure', async () => {
+    chan.publish.mockImplementationOnce(backpressure.publish)
+
+    await expect(channel.publish(exchange, buffer)).rejects.toBeDefined()
+  })
+
+  it('should not ignore exceptions on `throw()`', async () => {
+    chan.publish.mockImplementation(() => { throw new Error('Channel closed') })
+
+    await expect(channel.throw(queue, buffer)).rejects.toThrow()
+  })
+
+  it('should expose index', async () => {
+    expect(channel.index).toStrictEqual(index)
+  })
+})
+
 /**
  * @param {comq.amqp.Connection} [conn]
  * @return {jest.MockedObject<comq.amqp.Channel>}

package/test/connect.test.js

@@ -6,6 +6,7 @@ const { connect } = require('../')
 
 jest.mock('../source/io')
 jest.mock('../source/connection')
+jest.mock('../source/shards/connection')
 
 const { IO } = require('../source/io')
 
@@ -14,6 +15,9 @@ const {
   Connection
 } = require('../source/connection')
 
+const shards = /** @type {{ Connection: jest.MockedClass<comq.Connection>}} */
+  require('../source/shards')
+
 it('should be', async () => {
   expect(connect).toBeDefined()
 })
@@ -23,22 +27,46 @@ const url = generate()
 /** @type {comq.IO} */
 let io
 
-beforeEach(async () => {
+beforeEach(() => {
   jest.clearAllMocks()
-
-  io = await connect(url)
 })
 
-it('should return IO', async () => {
-  expect(io).toBeInstanceOf(IO)
+describe('single connection', () => {
+  beforeEach(async () => {
+    io = await connect(url)
+  })
+
+  it('should return IO', async () => {
+    expect(io).toBeInstanceOf(IO)
+  })
+
+  it('should pass active connection', async () => {
+    expect(Connection).toHaveBeenCalledWith(url)
+
+    /** @type {jest.MockedObject<comq.Connection>} */
+    const instance = Connection.mock.instances[0]
+
+    expect(instance.open).toHaveBeenCalled()
+    expect(IO).toHaveBeenCalledWith(instance)
+  })
 })
 
-it('should pass active connection', async () => {
-  expect(Connection).toHaveBeenCalledWith(url)
+describe('sharded connection', () => {
+  const urls = [generate(), generate()]
+
+  beforeEach(async () => {
+    io = await connect(...urls)
+  })
+
+  it('should create sharded connection', async () => {
+    expect(shards.Connection).toHaveBeenCalled()
+  })
+
+  it('should pass single connection instances', async () => {
+    urls.forEach((url) => expect(Connection).toHaveBeenCalledWith(url))
 
-  /** @type {jest.MockedObject<comq.Connection>} */
-  const instance = Connection.mock.instances[0]
+    const instances = Connection.mock.instances
 
-  expect(instance.open).toHaveBeenCalled()
-  expect(IO).toHaveBeenCalledWith(instance)
+    expect(shards.Connection).toHaveBeenCalledWith(instances)
+  })
 })

package/test/connection.mock.js

@@ -1,22 +1,26 @@
 'use strict'
 
-const channel = jest.fn(() => ({
-  consume: jest.fn(async () => undefined),
-  deliver: jest.fn(async () => undefined),
-  send: jest.fn(async () => undefined),
-  throw: jest.fn(async () => undefined),
-  subscribe: jest.fn(async () => undefined),
-  publish: jest.fn(async () => undefined),
-  diagnose: jest.fn(async () => undefined),
-  seal: jest.fn(async () => undefined),
-  recover: jest.fn(async () => undefined)
-}))
+const channel = /** @type {jest.MockedFunction<(sharded?: boolean, index?: number) => comq.Channel>} */ jest.fn(
+  (sharded = false, index = undefined) => ({
+    index,
+    sharded,
+    consume: jest.fn(async () => undefined),
+    deliver: jest.fn(async () => undefined),
+    send: jest.fn(async () => undefined),
+    throw: jest.fn(async () => undefined),
+    subscribe: jest.fn(async () => undefined),
+    publish: jest.fn(async () => undefined),
+    diagnose: jest.fn(async () => undefined),
+    seal: jest.fn(async () => undefined),
+    recover: jest.fn(async () => undefined)
+  }))
 
 /**
  * @returns {jest.MockedObject<comq.Connection>}
  */
-const connection = () => (/** @type {jest.MockedObject<comq.Connection>} */ {
-  createChannel: jest.fn(async () => channel()),
+const connection = (sharded = false) => (/** @type {jest.MockedObject<comq.Connection>} */ {
+  createChannel: jest.fn(async (type, index) => channel(sharded, index)),
+  open: jest.fn(async () => undefined),
   close: jest.fn(async () => undefined),
   diagnose: jest.fn(() => undefined)
 })