comq 0.16.0 → 0.16.1

package/features/connection.feature

@@ -18,6 +18,20 @@ Feature: Connection Tolerance
     When the broker is up
     Then the connection is restored
 
+  Scenario: Restoring singleton connection after broker restart
+    Given an active singleton connection
+    When the broker is down
+    Then the connection is lost
+    When the broker is up
+    Then the connection is restored
+
+  Scenario: Restoring sharded singleton connection after broker crash
+    Given an active sharded singleton connection
+    When the broker has crashed
+    Then the connection is lost
+    When the broker is up
+    Then the connection is restored
+
   Scenario: Connecting with wrong credentials
     When I attempt to connect to the broker as "someone" with password "whatever"
     Then an exception is thrown: "Handshake terminated by server: 403 (ACCESS-REFUSED)"

package/features/silence.feature

@@ -24,6 +24,22 @@ Feature: Silent Connection Tolerance
     When the consumer sends a request to the `echo` queue
     Then the consumer receives the reply
 
+  Scenario: Restoring a singleton connection that has gone silent
+    Given an active singleton connection
+    And a producer replying `echo` queue
+    When the network goes silent
+    Then the connection is lost within 10 seconds
+    When the consumer sends a request to the `echo` queue
+    Then the consumer receives the reply
+
+  Scenario: Restoring a sharded singleton connection whose every shard has gone silent
+    Given an active sharded singleton connection
+    And a producer replying `echo` queue
+    When the network goes silent
+    Then the connection is lost within 10 seconds
+    When the consumer sends a request to the `echo` queue
+    Then the consumer receives the reply
+
   Scenario: Answering a request sent as the connection goes silent
     Given an active connection to the broker
     And a producer replying `echo` queue

package/package.json

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

package/source/connection.js

@@ -64,17 +64,10 @@ class Connection {
   async open () {
     this.#closed = false
 
-    if (this.#opening !== null) return this.#opening
-
-    this.#opening = retry(this.#open).finally(() => { this.#opening = null })
-
-    await this.#opening
+    await this.#reopen()
 
     if (this.#closed) return
 
-    // close may have landed after this attempt succeeded but before `#opening` was cleared
-    if (this.#connection === undefined) return this.open()
-
     this.#running = true
   }
 
@@ -172,10 +165,29 @@ class Connection {
     this.#connection = undefined
 
     if (error !== undefined && !this.#closed) {
-      this.open().catch((exception) => this.#diagnostics.emit('error', exception))
+      this.#reopen().catch((exception) => this.#diagnostics.emit('error', exception))
     }
   }
 
+  /**
+   * Establishes the connection, or joins the attempt under way. A lost connection is
+   * restored through here and not through `open()`: what a subclass makes of `open()` is
+   * its own — the singleton answers it with the first opening, made once and remembered,
+   * which is no way to make a second one.
+   *
+   * @return {Promise<void>}
+   */
+  async #reopen () {
+    this.#opening ??= retry(this.#open).finally(() => { this.#opening = null })
+
+    await this.#opening
+
+    if (this.#closed) return
+
+    // close may have landed after this attempt succeeded but before `#opening` was cleared
+    if (this.#connection === undefined) return this.#reopen()
+  }
+
   /**
    * An AMQP connection is only closed once the broker has replied with Close-Ok,
    * which never happens on a connection that has already been lost.

package/test/connection.test.js

@@ -184,7 +184,7 @@ describe('reconnection', () => {
 
     const boom = new Error('reconnect failed')
 
-    connection.open = jest.fn(async () => { throw boom })
+    amqplib.connect.mockRejectedValueOnce(boom)
 
     conn.emit('close', new Error('broker down'))
 
@@ -194,8 +194,38 @@ describe('reconnection', () => {
 
     expect(errors).toContain(boom)
     expect(unhandled).not.toHaveBeenCalled()
+
+    // the attempt is retried in the background, and would connect in a later case
+    await connection.close()
   })
 
+  // the singleton answers `open()` with the first opening, made once and remembered
+  it('should reconnect a connection whose open() is remembered', async () => {
+    class Remembered extends Connection {
+      #opened = null
+
+      async open () {
+        this.#opened ??= super.open()
+
+        await this.#opened
+      }
+    }
+
+    const remembered = new Remembered(generate())
+
+    await remembered.open()
+
+    const first = await amqplib.connect.mock.results.at(-1).value
+
+    first.emit('close', new Error('lost'))
+
+    await expect(remembered.createChannel('event')).resolves.toBeDefined()
+
+    expect(amqplib.connect).toHaveBeenCalledTimes(3)
+
+    await remembered.close()
+  }, 10000)
+
   it('should reconnect when connection is lost while channels recover', async () => {
     const channel = await connection.createChannel('request')