comq 0.6.0 → 0.7.0

package/features/connection.feature

@@ -3,14 +3,6 @@ Feature: Connection Tolerance
   Scenario: Connect
     Given an active connection to the broker
 
-  Scenario: Connecting to a broker before it was started
-    Given the broker is down
-    When I attempt to connect to the broker for 0.2 seconds
-    Then the connection is not established
-    And no exceptions are thrown
-    When the broker is up
-    Then the connection is established
-
   Scenario: Restoring connection after broker restart
     Given an active connection to the broker
     When the broker is down

package/features/shards.feature

@@ -3,25 +3,26 @@ Feature: Sharded Connection
   Scenario: Establishing sharded connection
     Given an active sharded connection
 
-  Scenario: Connecting and waiting for 'open' event
-    Given the connection to both shards is established
-
   Scenario: Connecting while a shard is down
     Given one of the brokers has crashed
     When I attempt to establish sharded connection
-    Then the connection is established
+    Then an exception is thrown: "ECONNREFUSED"
     Then the broker is up
 
+  Scenario: Connecting with wrong credentials
+    When I attempt to establish a sharded connection as "someone" with password "whatever"
+    Then an exception is thrown: "Handshake terminated by server: 403 (ACCESS-REFUSED)"
+
   Scenario: Sending a request to a sharded connection while one broker is down
-    Given one of the brokers has crashed
-    And an active sharded connection
+    Given an active sharded connection
+    And one of the brokers has crashed
     And a producer replying `add_numbers` queue
     When the consumer sends a request to the `add_numbers` queue
     Then the consumer receives the reply
     Then the broker is up
 
   Scenario: Publishing an event to a sharded connection missing one broker
-    Given the connection to both shards is established
+    Given an active sharded connection
     And events are exclusively consumed from the `numbers_added` exchange
     And one of the brokers has crashed
     When an event is emitted to the `numbers_added` exchange
@@ -29,7 +30,7 @@ Feature: Sharded Connection
     Then the broker is up
 
   Scenario: Shard crashes while sending requests
-    Given the connection to both shards is established
+    Given an active sharded connection
     And a producer replying `flood` queue
     And I'm sending 1kB requests to the `flood` queue at 1kHz
     When one of the brokers has crashed
@@ -38,7 +39,7 @@ Feature: Sharded Connection
     Then the broker is up
 
   Scenario: Shard crashes while publishing events
-    Given the connection to both shards is established
+    Given an active sharded connection
     And events are exclusively consumed from the `flood` exchange
     And I'm publishing 1kB events to the `flood` exchange at 100Hz
     When one of the brokers has crashed
@@ -47,7 +48,7 @@ Feature: Sharded Connection
     Then the broker is up
 
   Scenario: Sealing sharded connection while one broker is down
-    Given the connection to both shards is established
+    Given an active sharded connection
     And a producer replying `echo` queue
     And one of the brokers has crashed
     And the connection has started sealing
@@ -55,7 +56,3 @@ Feature: Sharded Connection
     And the broker is up
     Then the connection is sealed
     And the consumer does not receive the reply
-
-  Scenario: Connecting with wrong credentials
-    When I attempt to establish a sharded connection as "someone" with password "whatever"
-    Then an exception is thrown: "Handshake terminated by server: 403 (ACCESS-REFUSED)"

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

@@ -62,12 +62,6 @@ describe('Given an active sharded connection', () => {
   })
 })
 
-describe('Given the connection to both shards is established', () => {
-  tomato.steps.Gi('the connection to both shards is established')
-
-  it('should be', async () => undefined)
-})
-
 describe('When I attempt to connect to the broker for {number} second(s)', () => {
   const step = tomato.steps.Wh('I attempt to connect to the broker for {number} second(s)')
 

package/features/steps/connection.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const assert = require('node:assert')
-const { timeout, promex } = require('@toa.io/generic')
+const { timeout } = require('@toa.io/generic')
 
 const { Given, When, Then } = require('@cucumber/cucumber')
 
@@ -26,24 +26,6 @@ Given('an active sharded connection',
     await this.connecting
   })
 
-Given('the connection to both shards is established',
-  /**
-   * @this {comq.features.Context}
-   */
-  async function () {
-    const promise = promex()
-
-    this.sharded = true
-    this.connecting = this.connect()
-
-    await this.connecting
-
-    // second shard is connected
-    this.io.diagnose('open', () => promise.resolve())
-
-    return promise
-  })
-
 When('I attempt to connect to the broker for {number} second(s)',
   /**
    * @param {number} interval
@@ -185,6 +167,6 @@ const CONNECTION_EVENTS = {
 }
 
 const CONNECTION_GAPS = {
-  lost: global.COMQ_TESTING_CONNECTION_GAP_LOST ?? 10,
-  restored: global.COMQ_TESTING_CONNECTION_GAP_RESTORED ?? 5000
+  lost: 10,
+  restored: 5000
 }

package/lerna.json

@@ -1,5 +1,5 @@
 {
   "useWorkspaces": true,
-  "version": "0.6.0",
+  "version": "0.7.0",
   "conventionalCommits": true
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "comq",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "ComQ",
   "author": {
     "name": "Artem Gurtovoi",

package/source/channel.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const { EventEmitter } = require('node:events')
-const { lazy, recall, promex, failsafe, immediate } = require('@toa.io/generic')
+const { lazy, recall, promex, failsafe, timeout } = require('@toa.io/generic')
 
 /**
  * @implements {comq.Channel}
@@ -137,8 +137,7 @@ class Channel {
 
     for (const confirmation of this.#confirmations) confirmation.reject(INTERRUPTION)
 
-    // let unpause and confirmation interruptions be handled
-    await immediate()
+    await timeout(0) // let unpause and confirmation interruptions be handled
 
     this.#recovery.resolve()
     this.#recovery = promex()

package/source/connection.js

@@ -23,6 +23,9 @@ class Connection {
   /** @type {toa.generic.Promex} */
   #recovery = promex()
 
+  /** @type {boolean} */
+  #running = false
+
   #diagnostics = new EventEmitter()
 
   /**
@@ -34,6 +37,8 @@ class Connection {
 
   async open () {
     await retry(this.#open, RETRY)
+
+    this.#running = true
   }
 
   async close () {
@@ -70,11 +75,11 @@ class Connection {
     try {
       this.#connection = await amqp.connect(this.#url)
     } catch (exception) {
-      if (transient(exception)) return retry()
+      if (this.#transient(exception)) return retry()
       else throw exception
     }
 
-    // prevents process crash, 'close' will be emitted next
+    // prevents the process crash, 'close' will be emitted next
     // https://amqp-node.github.io/amqplib/channel_api.html#model_events
     this.#connection.on('error', noop)
 
@@ -101,6 +106,12 @@ class Connection {
   #recover () {
     return this.#recovery
   }
+
+  #transient (exception) {
+    const abruptly = exception.message === 'Socket closed abruptly during opening handshake'
+
+    return this.#running || abruptly
+  }
 }
 
 /** @type {toa.generic.retry.Options} */
@@ -108,17 +119,6 @@ const RETRY = {
   retries: Infinity
 }
 
-/**
- * @param {Error} exception
- * @returns {boolean}
- */
-const transient = (exception) => {
-  const refused = exception.code === 'ECONNREFUSED'
-  const handshake = exception.message === 'Socket closed abruptly during opening handshake'
-
-  return refused || handshake
-}
-
 function noop () {}
 
 exports.Connection = Connection

package/source/shards/connection.js

@@ -23,9 +23,13 @@ class Connection {
   }
 
   async open () {
-    const opening = this.#connections.map((connection) => connection.open())
+    const openings = this.#connections.map((connection) => connection.open())
 
-    await Promise.any(opening)
+    try {
+      await Promise.all(openings)
+    } catch (exception) {
+      await this.#cancel(openings, exception)
+    }
   }
 
   async close () {
@@ -51,6 +55,21 @@ class Connection {
       connection.diagnose(event, (...args) => this.#diagnostics.emit(event, ...args, index))
     }
   }
+
+  /**
+   * @param {Promise<any>[]} openings
+   * @param {Error} exception
+   */
+  async #cancel (openings, exception) {
+    const settled = await Promise.allSettled(openings)
+    const indexes = settled.map((result, index) => result.status === 'fulfilled' ? index : -1)
+    const opened = indexes.filter((index) => index !== -1)
+    const closings = opened.map((index) => this.#connections[index].close())
+
+    await Promise.all(closings)
+
+    throw exception
+  }
 }
 
 exports.Connection = Connection

package/test/channel.test.js

@@ -577,7 +577,7 @@ describe('recovery', () => {
       if (sealed) await channel.seal()
     })
 
-    it('should re-assert queue after recovery', async () => {
+    it('should re-assert queue', async () => {
       chan.assertQueue.mockImplementation(async () => { throw new Error('Channel closed') })
 
       /** @type {comq.amqp.Connection} */
@@ -598,7 +598,7 @@ describe('recovery', () => {
       expect(repl.assertQueue).toHaveBeenCalled()
     })
 
-    it('should re-assert exchange after exception', async () => {
+    it('should re-assert exchange', async () => {
       chan.assertExchange.mockImplementation(async () => { throw new Error('Channel ended, no reply will be forthcoming') })
 
       /** @type {comq.amqp.Connection} */
@@ -619,7 +619,7 @@ describe('recovery', () => {
       expect(repl.assertExchange).toHaveBeenCalled()
     })
 
-    it('should re-bind queue after exception', async () => {
+    it('should re-bind queue', async () => {
       chan.bindQueue.mockImplementation(async () => { throw new Error('Channel ended, no reply will be forthcoming') })
 
       /** @type {comq.amqp.Connection} */
@@ -642,7 +642,7 @@ describe('recovery', () => {
       expect(repl.bindQueue).toHaveBeenCalled()
     })
 
-    it(`should${not} re-consume after recovery`, async () => {
+    it(`should${not} re-consume`, async () => {
       await channel.consume(queue, consumer)
 
       const replacement = await amqplib.connect()
@@ -655,7 +655,7 @@ describe('recovery', () => {
       else expect(chan.consume).toHaveBeenCalledWith(queue, expect.any(Function), expect.anything())
     })
 
-    it(`should${not} re-consume after exception `, async () => {
+    it(`should${not} re-consume`, async () => {
       chan.consume.mockImplementation(async () => { throw new Error('Channel ended, no reply will be forthcoming') })
 
       /** @type {comq.amqp.Connection} */
@@ -677,7 +677,7 @@ describe('recovery', () => {
       else expect(repl.consume).toHaveBeenCalled()
     })
 
-    it(`should${not} re-subscribe after recovery`, async () => {
+    it(`should${not} re-subscribe`, async () => {
       await channel.subscribe(exchange, queue, consumer)
 
       const replacement = await amqplib.connect()
@@ -690,7 +690,7 @@ describe('recovery', () => {
       else expect(repl.consume).toHaveBeenCalledWith(queue, expect.any(Function), expect.anything())
     })
 
-    it('should re-send after exception', async () => {
+    it('should re-send', async () => {
       const queue = generate()
       const buffer = Buffer.from(generate())
 
@@ -702,7 +702,6 @@ describe('recovery', () => {
       setImmediate(async () => {
         expect(chan.publish).toHaveBeenCalled()
 
-        chan.publish.mockImplementation(async () => {})
         replacement = await amqplib.connect()
 
         await channel.recover(replacement)
@@ -712,9 +711,6 @@ describe('recovery', () => {
 
       const repl = await getCreatedChannel(replacement)
 
-      // await recovery effect
-      await timeout(5)
-
       expect(repl.publish).toHaveBeenCalled()
     })
 
@@ -757,7 +753,7 @@ describe('recovery', () => {
       )
     })
 
-    it('should unpause on recovery', async () => {
+    it('should unpause', async () => {
       jest.clearAllMocks()
 
       topology.confirms = false

package/test/connection.test.js

@@ -30,12 +30,6 @@ beforeEach(() => {
   connection = new Connection(url)
 })
 
-/** @type {[string, Partial<Error>][]} */
-const TRANSIENT_ERRORS = [
-  ['ECONNREFUSED', { code: 'ECONNREFUSED' }],
-  ['Socket closed', { message: 'Socket closed abruptly during opening handshake' }]
-]
-
 // endregion
 
 describe('initial connection', () => {
@@ -45,7 +39,9 @@ describe('initial connection', () => {
     expect(amqplib.connect).toHaveBeenCalledWith(url)
   })
 
-  it.each(TRANSIENT_ERRORS)('should reconnect on %s',
+  it.each(/** @type {[string, Partial<Error>][]} */[
+    ['Socket closed', { message: 'Socket closed abruptly during opening handshake' }]
+  ])('should reconnect on %s',
     async (_, error) => {
       amqplib.connect.mockImplementationOnce(async () => { throw error })
 
@@ -54,12 +50,13 @@ describe('initial connection', () => {
       expect(amqplib.connect).toHaveBeenCalledTimes(2)
     })
 
-  it('should throw if error is permanent', async () => {
-    const error = new Error()
-
-    amqplib.connect.mockImplementationOnce(async () => { throw error })
+  it.each(/** @type {[string, Partial<Error>][]} */[
+    ['ECONNREFUSED', { code: 'ECONNREFUSED' }],
+    ['any exception', new Error(generate())]
+  ])('should throw if error is %s', async (_, exception) => {
+    amqplib.connect.mockImplementationOnce(async () => { throw exception })
 
-    await expect(connection.open()).rejects.toThrow(error)
+    await expect(connection.open()).rejects.toStrictEqual(exception)
   })
 })
 
@@ -77,7 +74,7 @@ describe('reconnection', () => {
     expect(amqplib.connect).toHaveBeenCalledTimes(1)
 
     // const clear = jest.spyOn(conn, 'removeAllListeners')
-    const error = { message: generate() }
+    const error = { code: 'ECONNREFUSED' }
 
     conn.emit('close', error)
 

package/test/shards/channel.test.js

@@ -374,20 +374,21 @@ it('should remove channel with back pressure from the pool', async () => {
   }
 
   await send()
+
   expect(chan.send).toHaveBeenCalled()
+
   chan.send.mockClear()
 
-  // emit 'flow'
-  for (const listener of flowListeners) listener()
+  for (const flow of flowListeners) flow()
 
   await send()
+
   expect(chan.send).not.toHaveBeenCalled()
-  chan.send.mockClear()
 
-  // emit 'drain'
-  for (const listener of drainListeners) listener()
+  for (const drain of drainListeners) drain()
 
   await send()
+
   expect(chan.send).toHaveBeenCalled()
 })
 

package/test/shards/connection.test.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const { generate } = require('randomstring')
-const { random, promex, sample } = require('@toa.io/generic')
+const { random, promex, immediate } = require('@toa.io/generic')
 
 const { Connection } = require('../../source/shards')
 
@@ -16,7 +16,7 @@ it('should be', async () => {
 })
 
 /** @type {jest.MockedObject<comq.Connection>[]} */
-const connections = [mock.connection(), mock.connection()]
+let connections
 
 /** @type {comq.Connection} */
 let connection
@@ -24,12 +24,13 @@ let connection
 beforeEach(() => {
   jest.clearAllMocks()
 
+  connections = [mock.connection(), mock.connection()]
   connection = new Connection(connections)
 })
 
 describe('open', () => {
-  it('should resolve when one of connections is established', async () => {
-    expect.assertions(1)
+  it('should resolve when all of the connections are established', async () => {
+    expect.assertions(2)
 
     /** @type {toa.generic.Promex[]} */
     const promises = []
@@ -41,19 +42,45 @@ describe('open', () => {
       promises.push(promise)
     }
 
-    let connected = false
+    let resolved = false
 
-    setImmediate(() => {
-      expect(connected).toStrictEqual(false)
+    setImmediate(async () => {
+      expect(resolved).toStrictEqual(false)
 
-      const any = sample(promises)
+      const first = promises.shift()
 
-      any.resolve()
+      first.resolve()
+
+      await immediate()
+
+      promises.forEach((promise) => promise.resolve())
+
+      resolved = true
     })
 
     await connection.open()
 
-    connected = true
+    expect(resolved).toStrictEqual(true)
+  })
+
+  it('should close opened connection if one fails', async () => {
+    connections.push(mock.connection())
+
+    const [one, bad, two] = connections
+    const exception = new Error(generate())
+
+    one.open.mockImplementation(() => Promise.resolve())
+    two.open.mockImplementation(() => Promise.resolve())
+
+    bad.open.mockImplementation(async () => {
+      await immediate()
+      throw exception
+    })
+
+    await expect(connection.open()).rejects.toThrow(exception)
+
+    expect(one.close).toHaveBeenCalled()
+    expect(two.close).toHaveBeenCalled()
   })
 })
 
@@ -81,9 +108,9 @@ describe('createChannel', () => {
 
 describe.each(/** @type {comq.diagnostics.event[]} */ ['open', 'close'])('diagnose %s event',
   (event) => {
-    const index = random(connections.length)
-
     it('should re-emit event', async () => {
+      const index = random(connections.length)
+
       for (const conn of connections) {
         expect(conn.diagnose).toHaveBeenCalledWith(event, expect.any(Function))
       }