comq 0.4.0-dev.6 → 0.4.1-dev.0

package/docs/notes.md

@@ -35,3 +35,13 @@ next Request is consumed from the Request queue*.
 A lightweight Producer (one that produces responses quickly) can result in being "overloaded"
 from the Consumer's perspective (that is, does not consume messages with an expected rate), even
 though the Producer being idle while waiting for response publication confirmations.
+
+## `replyTo` property prefix `direct:///`
+
+`IO.request` accepts `replyTo` property modifier function `(replyTo): string` as fourth argument. It
+is the temporary solution to provide an option for compatibility with
+official [RabbitMQ client for .NET](https://github.com/rabbitmq/rabbitmq-dotnet-client/blob/feceedccd6b81d4b461795390432dc3330fdf596/projects/Unit/TestPublicationAddress.cs).
+
+It is yet to be clarified and implemented correctly. [#6](https://github.com/toa-io/comq/issues/6)
+
+See [Direct Reply-to](https://www.rabbitmq.com/direct-reply-to.html).

package/features/events.feature

@@ -5,12 +5,17 @@ Feature: Events (pub/sub)
 
   Scenario: Sending and receiving an event
     Given that `checker` is consuming events from the `numbers_added` exchange
-    When I emit an event to the `numbers_added` exchange
+    When an event is emitted to the `numbers_added` exchange
     Then `checker` receives the event
 
   Scenario: Receiving an event by two consumer groups
     Given that `first` is consuming events from the `numbers_added` exchange
     And `second` is consuming events from the `numbers_added` exchange
-    When I emit an event to the `numbers_added` exchange
+    When an event is emitted to the `numbers_added` exchange
     Then `first` receives the event
     And `second` receives the event
+
+  Scenario: Receiving an event exclusively
+    Given that events are exclusively consumed from the `numbers_added` exchange
+    When an event is emitted to the `numbers_added` exchange
+    Then the event is received

package/features/recovery.feature

@@ -87,14 +87,14 @@ Feature: Request-Reply Topology Recovery
     Given the broker is down
     And `logger` consuming events from the `numbers_added` exchange is expected
     When the broker is up
-    And I emit an event to the `numbers_added` exchange
+    And an event is emitted to the `numbers_added` exchange
     Then `logger` receives the event
 
   Scenario: Defining emitter while broker crashed
     Given `someone` consuming events from the `numbers_added` exchange is expected
     And the broker has crashed
     When the broker is up
-    Then I emit an event to the `numbers_added` exchange
+    Then an event is emitted to the `numbers_added` exchange
     And `someone` receives the event
 
   Scenario: Start consuming events while broker is down
@@ -105,5 +105,5 @@ Feature: Request-Reply Topology Recovery
     And `second` consuming events from the `numbers_added` exchange is expected
     When the broker has crashed
     And the broker is up
-    Then I emit an event to the `numbers_added` exchange
+    Then an event is emitted to the `numbers_added` exchange
     And `second` receives the event

package/features/steps/.test/connection.test.js

@@ -125,23 +125,24 @@ describe('When I attempt to connect to the broker as {string} with password {str
   })
 })
 
-describe.each([['', true], [' not', false]])('Then the connection is%s established', (not, defined) => {
-  const step = tomato.steps.Th(`the connection is${not} established`)
+describe.each([['', true], [' not', false]])('Then the connection is%s established',
+  (not, connected) => {
+    const step = tomato.steps.Th(`the connection is${not} established`)
 
-  it('should be', async () => undefined)
+    it('should be', async () => undefined)
 
-  it(`should fail if io is${defined ? 'n\'t' : ''} defined`, async () => {
-    context.io = defined ? undefined : generate()
+    it(`should fail if is${connected ? 'n\'t' : ''} connected`, async () => {
+      context.connected = !connected
 
-    await expect(step.call(context)).rejects.toThrow(AssertionError)
-  })
+      await expect(step.call(context)).rejects.toThrow(AssertionError)
+    })
 
-  it(`should pass if io is${defined ? '' : 'n\'t'} defined`, async () => {
-    context.io = defined ? generate() : undefined
+    it(`should pass if is${connected ? '' : 'n\'t'} connected`, async () => {
+      context.connected = connected
 
-    await expect(step.call(context)).resolves.not.toThrow()
+      await expect(step.call(context)).resolves.not.toThrow()
+    })
   })
-})
 
 describe('Then no exceptions are thrown', () => {
   const step = tomato.steps.Th('no exceptions are thrown')

package/features/steps/.test/context.mock.js

@@ -3,5 +3,12 @@
 const { generate } = require('randomstring')
 
 const connect = jest.fn(async () => generate())
+const disconnect = jest.fn(async () => undefined)
 
-exports.context = () => ({ connect })
+/**
+ * @return {jest.MockedObject<comq.features.Context>}
+ */
+exports.context = () => (/** @type {jest.MockedObject<comq.features.Context>} */{
+  connect,
+  disconnect
+})

package/features/steps/.test/context.test.js

@@ -40,21 +40,12 @@ describe('connect', () => {
     expect(comq.connect).toHaveBeenCalledWith('amqp://developer:secret@localhost:5673')
   })
 
-  it('should not connect twice', async () => {
-    await context.connect()
-
-    expect(comq.connect).toHaveBeenCalledTimes(1)
-  })
-
-  it('should reconnect with credentials', async () => {
+  it('should connect with credentials', async () => {
     const user = generate()
     const password = generate()
 
     await context.connect(user, password)
 
-    expect(io.close).toHaveBeenCalled()
-
-    expect(comq.connect).toHaveBeenCalledTimes(2)
     expect(comq.connect).toHaveBeenCalledWith(`amqp://${user}:${password}@localhost:5673`)
   })
 

package/features/steps/.test/events.test.js

@@ -57,8 +57,14 @@ describe('Given {token} consuming events from the {token} exchange is expected',
   it('should be', async () => undefined)
 })
 
-describe('When I emit an event to the {token} exchange', () => {
-  const step = tomato.steps.Wh('I emit an event to the {token} exchange')
+describe('Given that events are exclusively consumed from the {token} exchange', () => {
+  tomato.steps.Gi('that events are exclusively consumed from the {token} exchange')
+
+  it('should be', async () => undefined)
+})
+
+describe('When an event is emitted to the {token} exchange', () => {
+  const step = tomato.steps.Wh('an event is emitted to the {token} exchange')
 
   it('should be', async () => undefined)
 
@@ -121,3 +127,28 @@ describe('Then {token} receives the event', () => {
     await expect(step.call(context, group)).resolves.not.toThrow()
   })
 })
+
+describe('Then the event is received', () => {
+  const step = tomato.steps.Th('the event is received')
+
+  const payload = generate()
+  const group = undefined
+
+  beforeEach(() => {
+    context.consumed = { [group]: payload }
+  })
+
+  it('should be', async () => undefined)
+
+  it('should throw if not consumed', async () => {
+    context.published = generate()
+
+    await expect(step.call(context, group)).rejects.toThrow(AssertionError)
+  })
+
+  it('should pass if consumed', async () => {
+    context.published = payload
+
+    await expect(step.call(context, group)).resolves.not.toThrow()
+  })
+})

package/features/steps/.types/context.d.ts

@@ -4,16 +4,17 @@ import * as _io from '../../../types/io'
 declare namespace comq.features {
 
   interface Context {
-    url?: string
     io?: _io.IO
+    connected?: boolean
     reply?: Promise<any>
     consumed?: Record<string, any>
     published?: any
     events?: { [K in _diagnostics.event]?: boolean }
     exception?: Error
-    expected: Promise<any>
+    expected?: Promise<any>
 
     connect(user?: string, password?: string): Promise<void>
+    disconnect(): Promise<void>
   }
 
 }

package/features/steps/connection.js

@@ -51,7 +51,7 @@ Then('the connection is not established',
    * @this {comq.features.Context}
    */
   async function () {
-    assert.equal(this.io, undefined, 'connection is established contrary to expectations')
+    assert.equal(this.connected, false, 'connection is established contrary to expectations')
   })
 
 Then('the connection is established',
@@ -59,9 +59,9 @@ Then('the connection is established',
    * @this {comq.features.Context}
    */
   async function () {
-    if (this.connecting) await this.connecting
+    if (this.connecting !== undefined) await this.connecting
 
-    assert.notEqual(this.io, undefined, 'connection is not established')
+    assert.equal(this.connected, true, 'connection is not established')
   })
 
 Then('no exceptions are thrown',

package/features/steps/context.js

@@ -7,11 +7,8 @@ const { connect } = require('../../')
  * @implements {comq.features.Context}
  */
 class Context extends World {
-  /** @type {comq.IO} */
-  static io
-  static url
-
   io
+  connected = false
   connecting
   reply
   consumed
@@ -23,26 +20,33 @@ class Context extends World {
   async connect (user, password) {
     const url = locator(user, password)
 
-    if (url !== Context.url) await this.#connect(url)
+    await this.#connect(url)
+  }
+
+  async disconnect () {
+    if (this.io === undefined) return
 
-    this.io = Context.io
+    await this.io.close()
 
-    for (const event of EVENTS) this.io.diagnose(event, () => (this.events[event] = true))
+    this.io = undefined
+    this.connected = false
+    this.events = {}
   }
 
+  /**
+   * @param {string} url
+   * @return {Promise<void>}
+   */
   async #connect (url) {
-    if (Context.url !== undefined) await Context.disconnect()
+    if (this.io !== undefined) await this.disconnect()
 
-    Context.url = url
-    Context.io = await connect(url)
-  }
-
-  static async disconnect () {
-    if (Context.io === undefined) return
+    this.io = await connect(url)
+    this.connected = true
 
-    await Context.io.close()
+    for (const event of EVENTS) this.io.diagnose(event, () => (this.events[event] = true))
 
-    Context.io = undefined
+    this.io.diagnose('close', () => (this.connected = false))
+    this.io.diagnose('open', () => (this.connected = true))
   }
 }
 

package/features/steps/events.js

@@ -12,7 +12,7 @@ Given('(that ){token} is consuming events from the {token} exchange',
    * @this {comq.features.Context}
    */
   async function (group, exchange) {
-    await consume(this, group, exchange)
+    await consume.call(this, group, exchange)
   })
 
 Given('{token} consuming events from the {token} exchange is expected',
@@ -24,10 +24,19 @@ Given('{token} consuming events from the {token} exchange is expected',
   async function (group, exchange) {
     await timeout(500) // let it crash
 
-    this.expected = consume(this, group, exchange)
+    this.expected = consume.call(this, group, exchange)
   })
 
-When('I emit an event to the {token} exchange',
+Given('that events are exclusively consumed from the {token} exchange',
+  /**
+   * @param {string} exchange
+   * @this {comq.features.Context}
+   */
+  async function (exchange) {
+    this.expected = consume.call(this, undefined, exchange)
+  })
+
+When('an event is emitted to the {token} exchange',
   /**
    * @param {string} exchange
    * @this {comq.features.Context}
@@ -48,22 +57,38 @@ Then('{token} receives the event',
    * @this {comq.features.Context}
    */
   async function (group) {
-    await timeout(100)
+    await consumed.call(this, group)
+  })
 
-    assert.notEqual(this.published, undefined, 'No event has been published')
-    assert.equal(this.published, this.consumed[group], `'${group}' haven't consumed event`)
+Then('the event is received',
+  /**
+   * @this {comq.features.Context}
+   */
+  async function () {
+    await consumed.call(this)
   })
 
 /**
- * @param {comq.features.Context} context
+ * @this {comq.features.Context} context
  * @param {string} group
  * @param {string} exchange
  * @return {Promise<void>}
  */
-const consume = async (context, group, exchange) => {
-  context.consumed ??= {}
+async function consume (group, exchange) {
+  this.consumed ??= {}
 
-  return context.io.consume(exchange, group, async (payload) => {
-    context.consumed[group] = payload
+  return this.io.consume(exchange, group, async (payload) => {
+    this.consumed[group] = payload
   })
 }
+
+/**
+ * @param {string} group
+ * @return {Promise<void>}
+ */
+async function consumed (group) {
+  await timeout(100) // let it consume
+
+  assert.notEqual(this.published, undefined, 'No event has been published')
+  assert.equal(this.published, this.consumed[group], 'Event hasn\'t been exclusively consumed')
+}

package/features/steps/hooks.js

@@ -1,12 +1,11 @@
 'use strict'
 
-const { AfterAll } = require('@cucumber/cucumber')
-const { Context } = require('./context')
+const { After } = require('@cucumber/cucumber')
 
-AfterAll(
+After(
   /**
    * @this {comq.features.Context}
    */
   async function () {
-    await Context.disconnect()
+    await this.disconnect()
   })

package/lerna.json

@@ -1,5 +1,5 @@
 {
   "useWorkspaces": true,
-  "version": "0.4.0-dev.6",
+  "version": "0.4.1-dev.0",
   "conventionalCommits": true
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "comq",
-  "version": "0.4.0-dev.6",
+  "version": "0.4.1-dev.0",
   "description": "ComQ",
   "author": {
     "name": "Artem Gurtovoi",
@@ -37,7 +37,7 @@
     "standard": "17.0.0"
   },
   "dependencies": {
-    "@toa.io/generic": "0.3.0",
+    "@toa.io/generic": "0.4.0-dev.3",
     "amqplib": "0.10.3",
     "msgpackr": "1.8.5"
   },

package/readme.md

@@ -10,7 +10,7 @@ Node.js.
 3. Events (pub/sub)
 4. Content encoding
 5. Flow control and back pressure handling
-6. Consumer acknowledgements and publisher confirms
+6. Consumer acknowledgments and publisher confirms
 7. Poison message handling
 8. Connection tolerance
 9. Broker restart resilience
@@ -109,19 +109,22 @@ const sum = await io.request('add_numbers', { a: 1, b: 2 })
 
 ## Consumption
 
-`async IO.consume(exchange: string, group: string, consumer)`
+`async IO.consume(exchange: string, [group: string], consumer)`
 
 `consumer` function's signature is `async? (payload: any): void`
 
 Start consuming decoded Events.
 
-Asserts fanout `exchange` (once per unique `exchange`) and queue for the Consumer `group` (once per
-unique `exchange` and `group` pair), and then binds the queue to the exchange. That is, one Event
-message is delivered to a single Consumer within *each group*.
+Asserts fanout `exchange` (once per unique `exchange`) and the queue for the Consumer `group` (once
+per unique `exchange` and `group` pair), and then binds the queue to the exchange. That is, one
+Event message is delivered to a single Consumer within *each group*.
 
 > Typically, the value of `group` refers to the name of a microservice running in multiple
 > instances.
 
+If the `group` is `undefined` or omitted, a unique value is generated and the queue is declared as
+exclusive.
+
 ### Example
 
 ```javascript
@@ -222,7 +225,7 @@ requests and are expecting replies.
   *persistent* ([delivery mode 2](https://www.rabbitmq.com/publishers.html#message-properties)),
   while Requests and Replies are not (mode 1).
 - Events and Requests are consumed using
-  manual [acknowledgment mode](https://www.rabbitmq.com/confirms.html#acknowledgement-modes),
+  manual [acknowledgment mode](https://www.rabbitmq.com/confirms.html#acknowledgment-modes),
   and Replies are consumed using automatic mode.
 
 If incoming message causes an exception, then it is "negative acknowledged" and requeued. If it
@@ -234,13 +237,13 @@ causes an exception again, it will be discarded.
 
 See:
 
-- [Consumer Acknowledgements and Publisher Confirms](https://www.rabbitmq.com/confirms.html).
-- [Negative Acknowledgement and Requeuing of Deliveries](https://www.rabbitmq.com/confirms.html#consumer-nacks-requeue)
+- [Consumer Acknowledgments and Publisher Confirms](https://www.rabbitmq.com/confirms.html).
+- [Negative Acknowledgment and Requeuing of Deliveries](https://www.rabbitmq.com/confirms.html#consumer-nacks-requeue)
 - [Dead Letter Exchanges](https://www.rabbitmq.com/dlx.html)
 
 ### Cheatsheet
 
-| Message | Prefetch  | Confirms | Queue     | Acknowledgement | Persistent |
+| Message | Prefetch  | Confirms | Queue     | Acknowledgment | Persistent |
 |---------|-----------|----------|-----------|-----------------|------------|
 | Request | limited   | no       | durable   | manual          | no         |
 | Reply   | unlimited | no       | exclusive | automatic       | no         |

package/source/channel.js

@@ -126,12 +126,15 @@ class Channel {
 
   /**
    * @param {string} name
-   * @returns {Promise<void>}
+   * @returns {Promise<string[]>}
    */
   async #assertQueue (name) {
-    const options = this.#topology.durable ? DURABLE : EXCLUSIVE
+    const passed = arguments.length === 2 ? arguments[1] : undefined
+    const options = passed ?? (this.#topology.durable ? DURABLE : EXCLUSIVE)
+
+    const { queue } = await this.#channel.assertQueue(name, options)
 
-    await this.#channel.assertQueue(name, options)
+    return [queue]
   }
 
   /**
@@ -149,11 +152,18 @@ class Channel {
    *
    * @param {string} exchange
    * @param {string} queue
-   * @returns {Promise<void>}
+   * @returns {Promise<string[]>}
    */
   async #assertBoundQueue (exchange, queue) {
-    await this.#assertQueue(queue)
+    /** @type {comq.amqp.options.Consume} */
+    let options
+
+    if (queue === undefined) options = { exclusive: true }
+
+    queue = (await this.#assertQueue(queue, options))[0]
     await this.#channel.bindQueue(queue, exchange, '')
+
+    return [exchange, queue]
   }
 
   // endregion
@@ -201,7 +211,7 @@ class Channel {
     /** @type {import('amqplib').Options.Consume} */
     const options = {}
 
-    if (this.#topology.acknowledgements) consumer = this.#getAcknowledgingConsumer(consumer)
+    if (this.#topology.acknowledgments) consumer = this.#getAcknowledgingConsumer(consumer)
     else options.noAck = true
 
     const response = await this.#channel.consume(queue, consumer, options)
@@ -220,6 +230,8 @@ class Channel {
 
         this.#channel.ack(message)
       } catch (exception) {
+        if (exception.message === 'Channel closed') return // message will be requeued by the broker
+
         if (message.fields.redelivered) this.#discard(message, exception)
         else this.#requeue(message)
       }

package/source/connection.js

@@ -37,7 +37,11 @@ class Connection {
   }
 
   async close () {
-    await this.#connection.close()
+    try {
+      await this.#connection.close()
+    } catch (e) {
+      // connection already closed
+    }
   }
 
   createChannel = failsafe(this, this.#recover,

package/source/io.js

@@ -81,7 +81,8 @@ class IO {
 
   consume = lazy(this, this.#createEventChannel,
     async (exchange, group, callback) => {
-      const queue = io.concat(exchange, group)
+      const exclusive = group === undefined || callback === undefined // 2 arguments passed
+      const queue = exclusive ? undefined : io.concat(exchange, group)
       const consumer = this.#getEventConsumer(callback)
 
       await this.#events.subscribe(exchange, queue, consumer)

package/source/presets/event.json

@@ -2,6 +2,6 @@
   "prefetch": 300,
   "confirms": true,
   "durable": true,
-  "acknowledgements": true,
+  "acknowledgments": true,
   "persistent": true
 }

package/source/presets/reply.json

@@ -2,6 +2,6 @@
   "prefetch": 0,
   "confirms": false,
   "durable": false,
-  "acknowledgements": false,
+  "acknowledgments": false,
   "persistent": false
 }

package/source/presets/request.json

@@ -2,6 +2,6 @@
   "prefetch": 300,
   "confirms": false,
   "durable": true,
-  "acknowledgements": true,
+  "acknowledgments": true,
   "persistent": false
 }

package/test/amqplib.mock.js

@@ -11,7 +11,7 @@ class Channel extends EventEmitter {
   cancel = jest.fn(async () => undefined)
   ack = jest.fn(() => undefined)
   nack = jest.fn(() => undefined)
-  assertQueue = jest.fn(async () => undefined)
+  assertQueue = jest.fn(async (name) => ({ queue: name ?? generate() }))
   assertExchange = jest.fn(async () => undefined)
   bindQueue = jest.fn(async () => undefined)
   publish = jest.fn((_0, _1, _2, _3, resolve) => resolve?.(null))

package/test/channel.fixtures.js

@@ -6,7 +6,7 @@ const preset = () => ({
   prefetch: random(10),
   confirms: flip(),
   durable: flip(),
-  acknowledgements: flip(),
+  acknowledgments: flip(),
   persistent: flip()
 })
 

package/test/channel.test.js

@@ -92,7 +92,7 @@ describe('consume', () => {
   })
 })
 
-describe('acknowledgements', () => {
+describe('acknowledgments', () => {
   const consumer = /** @type {comq.channel.consumer} */ jest.fn(async () => undefined)
   const queue = generate()
 
@@ -100,7 +100,7 @@ describe('acknowledgements', () => {
     ['', true],
     ['not ', false]
   ])('should %sack incoming messages', async (_, ack) => {
-    topology.acknowledgements = ack
+    topology.acknowledgments = ack
     channel = await create(connection, topology)
     chan = await getCreatedChannel()
 
@@ -119,8 +119,8 @@ describe('acknowledgements', () => {
   it.each([
     ['manual', true],
     ['automatic', false]
-  ])('should create consumer with %s acknowledgements', async (_, ack) => {
-    topology.acknowledgements = ack
+  ])('should create consumer with %s acknowledgments', async (_, ack) => {
+    topology.acknowledgments = ack
     channel = await create(connection, topology)
     chan = await getCreatedChannel()
 
@@ -136,7 +136,7 @@ describe('acknowledgements', () => {
     ['nack', true],
     ['discard', false]
   ])('should %s the message caused an exception', async (_, requeue) => {
-    topology.acknowledgements = true
+    topology.acknowledgments = true
 
     channel = await create(connection, topology)
     chan = await getCreatedChannel()
@@ -157,6 +157,28 @@ describe('acknowledgements', () => {
 
     expect(chan.nack).toHaveBeenCalledWith(message, false, requeue)
   })
+
+  it('should ignore Channel ended exception', async () => {
+    topology.acknowledgments = true
+
+    channel = await create(connection, topology)
+    chan = await getCreatedChannel()
+
+    const consumer = /** @type {Function} */ jest.fn(async () => generate())
+
+    await channel.consume(queue, consumer)
+
+    const callback = chan.consume.mock.calls[0][1]
+    const content = randomBytes(8)
+    const properties = {}
+    const fields = {}
+    const message = /** @type {import('amqplib').ConsumeMessage} */ { content, properties, fields }
+
+    chan.ack.mockImplementation(() => { throw new Error('Channel closed') })
+    chan.nack.mockImplementation(() => { throw new Error('Channel closed') })
+
+    await expect(callback(message)).resolves.not.toThrow()
+  })
 })
 
 describe('send', () => {
@@ -293,9 +315,10 @@ describe('throw', () => {
   })
 })
 
-describe('subscribe', () => {
+describe.each(['group', 'exclusive'])('%s subscribe', (option) => {
+  let queue = option === 'group' ? generate() : undefined
+
   const exchange = generate()
-  const queue = generate()
   const consumer = /** @type {comq.channel.consumer} */ jest.fn(() => undefined)
 
   beforeEach(async () => {
@@ -319,22 +342,42 @@ describe('subscribe', () => {
     else expect(options).toMatchObject({ durable: false })
   })
 
-  it('should assert queue', async () => {
-    const options = topology.durable ? { durable: true } : { exclusive: true }
+  if (option === 'group') {
+    it('should assert queue', async () => {
+      const options = topology.durable ? { durable: true } : { exclusive: true }
 
-    expect(chan.assertQueue).toHaveBeenCalledWith(queue, expect.objectContaining(options))
-  })
+      expect(chan.assertQueue).toHaveBeenCalledWith(queue, expect.objectContaining(options))
+    })
+  } else {
+    it.each([true, false])('should assert exclusive queue (topology.durable: %s)', async (durable) => {
+      jest.clearAllMocks()
+
+      topology.durable = durable
+
+      channel = await create(connection, topology)
+      chan = await getCreatedChannel()
+
+      await channel.subscribe(exchange, undefined, consumer)
+
+      expect(chan.assertQueue).toHaveBeenCalledWith(
+        undefined,
+        expect.objectContaining({ exclusive: true })
+      )
+    })
+  }
 
   it('should bind queue to exchange', async () => {
+    const { queue } = await chan.assertQueue.mock.results[0].value
+
     expect(chan.bindQueue).toHaveBeenCalledTimes(1)
     expect(chan.bindQueue).toHaveBeenCalledWith(queue, exchange, '')
   })
 
   it.each([
-    ['with acknowledgements', true],
-    ['without acknowledgements', false]
+    ['with acknowledgments', true],
+    ['without acknowledgments', false]
   ])('should start consuming %s', async (_, ack) => {
-    topology.acknowledgements = ack
+    topology.acknowledgments = ack
 
     jest.clearAllMocks()
 
@@ -345,6 +388,8 @@ describe('subscribe', () => {
 
     const options = ack ? {} : { noAck: true }
 
+    queue = (await chan.assertQueue.mock.results[0].value).queue
+
     expect(chan.consume).toHaveBeenCalledTimes(1)
     expect(chan.consume).toHaveBeenCalledWith(queue, expect.any(Function), expect.objectContaining(options))
 
@@ -741,7 +786,7 @@ describe('diagnostics', () => {
   ])('should%s emit `discard` event', async (_, redelivered) => {
     jest.clearAllMocks()
 
-    topology.acknowledgements = true
+    topology.acknowledgments = true
     channel = await create(connection, topology)
     chan = await getCreatedChannel()
 

package/test/connection.test.js

@@ -154,13 +154,26 @@ describe('create channel', () => {
   })
 })
 
-it('should close connection', async () => {
-  await connection.open()
-  await connection.close()
+describe('close', () => {
+  it('should close connection', async () => {
+    await connection.open()
+    await connection.close()
+
+    const amqp = await amqplib.connect.mock.results[0].value
+
+    expect(amqp.close).toHaveBeenCalled()
+  })
 
-  const amqp = await amqplib.connect.mock.results[0].value
+  it('should ignore exceptions', async () => {
+    await connection.open()
+
+    /** @type {jest.MockedObject<import('amqplib').Connection>} */
+    const amqp = await amqplib.connect.mock.results[0].value
 
-  expect(amqp.close).toHaveBeenCalled()
+    amqp.close.mockImplementation(async () => { throw new Error() })
+
+    await expect(connection.close()).resolves.not.toThrow()
+  })
 })
 
 describe('diagnostics', () => {

package/test/io.consume.test.js

@@ -1,5 +1,7 @@
 'use strict'
 
+// region setup
+
 const { generate } = require('randomstring')
 const { encode } = require('../source/encode')
 
@@ -21,6 +23,8 @@ beforeEach(async () => {
   io = new IO(connection)
 })
 
+// endregion
+
 it('should be', async () => {
   expect(io.consume).toBeDefined()
 })
@@ -32,36 +36,54 @@ const consumer = jest.fn(() => undefined)
 /** @type {jest.MockedObject<comq.Channel>} */
 let events
 
-beforeEach(async () => {
+beforeEach(() => {
   jest.clearAllMocks()
+})
 
-  await io.consume(exchange, group, consumer)
+describe('group consumption', () => {
+  beforeEach(async () => {
+    await io.consume(exchange, group, consumer)
 
-  events = await findChannel('event')
-})
+    events = await findChannel('event')
+  })
 
-it('should create events channel', async () => {
-  expect(connection.createChannel).toHaveBeenCalledWith('event')
-})
+  it('should create events channel', async () => {
+    expect(connection.createChannel).toHaveBeenCalledWith('event')
+  })
+
+  it('should subscribe', async () => {
+    expect(events).toBeDefined()
+
+    const queue = exchange + '..' + group
+
+    expect(events.subscribe).toHaveBeenCalledWith(exchange, queue, expect.any(Function))
+  })
 
-it('should subscribe', async () => {
-  expect(events).toBeDefined()
+  it.each(encodings)('should pass decoded event (%s)', async (contentType) => {
+    const payload = generate()
+    const content = encode(payload, contentType)
+    const properties = { contentType }
+    const message = /** @type {import('amqplib').ConsumeMessage} */ { content, properties }
+    const callback = events.subscribe.mock.calls[0][2]
 
-  const queue = exchange + '..' + group
+    await callback(message)
 
-  expect(events.subscribe).toHaveBeenCalledWith(exchange, queue, expect.any(Function))
+    expect(consumer).toHaveBeenCalledWith(payload)
+  })
 })
 
-it.each(encodings)('should pass decoded event (%s)', async (contentType) => {
-  const payload = generate()
-  const content = encode(payload, contentType)
-  const properties = { contentType }
-  const message = /** @type {import('amqplib').ConsumeMessage} */ { content, properties }
-  const callback = events.subscribe.mock.calls[0][2]
+describe.each(['omitted', 'undefined'])('exclusive consumption (group is %s)', (option) => {
+  beforeEach(async () => {
+    if (option === 'omitted') await io.consume(exchange, consumer)
+    else await io.consume(exchange, undefined, consumer)
 
-  await callback(message)
+    events = await findChannel('event')
+  })
 
-  expect(consumer).toHaveBeenCalledWith(payload)
+  it('should subscribe', async () => {
+    expect(events).toBeDefined()
+    expect(events.subscribe).toHaveBeenCalledWith(exchange, undefined, expect.any(Function))
+  })
 })
 
 /**

package/test/presets.test.js

@@ -7,7 +7,7 @@ it('should define request preset', async () => {
     prefetch: 300,
     confirms: false,
     durable: true,
-    acknowledgements: true,
+    acknowledgments: true,
     persistent: false
   })
 })
@@ -17,7 +17,7 @@ it('should define reply preset', async () => {
     prefetch: 0,
     confirms: false,
     durable: false,
-    acknowledgements: false,
+    acknowledgments: false,
     persistent: false
   })
 })
@@ -27,7 +27,7 @@ it('should define event preset', async () => {
     prefetch: 300,
     confirms: true,
     durable: true,
-    acknowledgements: true,
+    acknowledgments: true,
     persistent: true
   })
 })

package/types/io.d.ts

@@ -30,6 +30,8 @@ declare namespace comq {
 
     consume(exchange: string, group: string, consumer: consumer): Promise<void>
 
+    consume(exchange: string, consumer: consumer): Promise<void>
+
     emit(exchange: string, payload: any, encoding?: _encoding.encoding): Promise<void>
 
     seal(): Promise<void>

package/types/topology.d.ts

@@ -10,7 +10,7 @@ declare namespace comq {
     prefetch: number
     confirms: boolean
     durable: boolean
-    acknowledgements: boolean
+    acknowledgments: boolean
     persistent: boolean
   }