comq 0.18.0 → 0.20.0

package/features/steps/call.js

@@ -0,0 +1,462 @@
+'use strict'
+
+const assert = require('node:assert')
+const amqplib = require('amqplib')
+const { Given, When, Then, After } = require('@cucumber/cucumber')
+
+const { connect, Unroutable } = require('../../')
+const { parse } = require('./yaml')
+const { getAddress, USER, PASSWORD } = require('./brokers')
+const { timeout, until } = require('../../test/helpers')
+
+Given('a holder answering {token} under the {token} key:',
+  /**
+   * @param {string} exchange
+   * @param {string} key
+   * @param {string} javascript
+   * @this {comq.features.Context}
+   */
+  async function (exchange, key, javascript) {
+    // eslint-disable-next-line no-new-func
+    const producer = new Function('return ' + javascript)()
+
+    this.io.diagnose('taken', () => (this.taken = true))
+
+    await this.io.back(exchange, key, producer)
+  })
+
+Given('a holder on another connection answering {token} under the {token} key',
+  /**
+   * @param {string} exchange
+   * @param {string} key
+   * @this {comq.features.Context}
+   */
+  async function (exchange, key) {
+    this.holder = await another(this)
+
+    await this.holder.back(exchange, key, echo)
+  })
+
+Given('a holder on another connection answering {token} under the {token} key in {number}ms',
+  /**
+   * @param {string} exchange
+   * @param {string} key
+   * @param {number} delay
+   * @this {comq.features.Context}
+   */
+  async function (exchange, key, delay) {
+    this.holder = await another(this)
+
+    await this.holder.back(exchange, key, async (payload) => {
+      await timeout(delay)
+
+      return echo(payload)
+    })
+  })
+
+Given('a holder connected to broker {number} answering {token} under the {token} key',
+  /**
+   * @param {number} broker
+   * @param {string} exchange
+   * @param {string} key
+   * @this {comq.features.Context}
+   */
+  async function (broker, exchange, key) {
+    this.holder = await another(this, broker)
+
+    await this.holder.back(exchange, key, echo)
+  })
+
+Given('a holder never answering {token} under the {token} key',
+  /**
+   * Holds the key as comq does, and takes a Request without ever answering it, so that losing
+   * its connection loses the Request with it.
+   *
+   * @param {string} exchange
+   * @param {string} key
+   * @this {comq.features.Context}
+   */
+  async function (exchange, key) {
+    const connection = await amqplib.connect(url(0))
+    const channel = await connection.createChannel()
+    const queue = exchange + '.' + key
+
+    await channel.assertExchange(exchange, 'direct', { durable: true })
+    await channel.assertQueue(queue, { exclusive: true })
+    await channel.bindQueue(queue, exchange, key)
+    await channel.consume(queue, () => undefined)
+
+    this.silent = connection
+  })
+
+When('the silent holder crashes',
+  /**
+   * Its socket is destroyed without a word, as a process that dies leaves it.
+   *
+   * @this {comq.features.Context}
+   */
+  function () {
+    const connection = this.silent
+
+    this.silent = undefined
+
+    connection.on('error', () => undefined)
+    connection.connection.stream.destroy()
+  })
+
+When('the consumer calls {token} under the {token} key',
+  /**
+   * @param {string} exchange
+   * @param {string} key
+   * @this {comq.features.Context}
+   */
+  async function (exchange, key) {
+    call(this, this.io.call(exchange, key, { key }))
+  })
+
+When('the consumer calls {token} under the {token} key with:',
+  /**
+   * @param {string} exchange
+   * @param {string} key
+   * @param {string} yaml
+   * @this {comq.features.Context}
+   */
+  async function (exchange, key, yaml) {
+    call(this, this.io.call(exchange, key, parse(yaml)))
+  })
+
+When('the consumer calls {token} under the {token} key with a {number}ms timeout',
+  /**
+   * @param {string} exchange
+   * @param {string} key
+   * @param {number} ms
+   * @this {comq.features.Context}
+   */
+  async function (exchange, key, ms) {
+    call(this, this.io.call(exchange, key, { key }, { timeout: ms }))
+  })
+
+When('the consumer calls {token} under the {token} key {number} times',
+  /**
+   * @param {string} exchange
+   * @param {string} key
+   * @param {number} times
+   * @this {comq.features.Context}
+   */
+  async function (exchange, key, times) {
+    const calls = Array.from({ length: times }, (_, n) => this.io.call(exchange, key, n))
+
+    this.replies = await Promise.all(calls)
+  })
+
+When('the consumer sends a request to the {token} queue with a {number}ms timeout',
+  /**
+   * @param {string} queue
+   * @param {number} ms
+   * @this {comq.features.Context}
+   */
+  async function (queue, ms) {
+    call(this, this.io.request(queue, { queue }, { timeout: ms }))
+  })
+
+When('the holder is sealed',
+  /**
+   * @this {comq.features.Context}
+   */
+  async function () {
+    await this.holder.seal()
+  })
+
+When('a second holder on another connection holds {token} under the {token} key',
+  /**
+   * @param {string} exchange
+   * @param {string} key
+   * @this {comq.features.Context}
+   */
+  async function (exchange, key) {
+    const second = await another(this)
+
+    second.diagnose('taken', () => (this.taken = true))
+
+    this.holding = second.back(exchange, key, echo)
+
+    // asserted on by a later step, and an unhandled rejection would end the run before it
+    this.holding.catch(() => undefined)
+  })
+
+When('the first holder disconnects',
+  /**
+   * @this {comq.features.Context}
+   */
+  async function () {
+    await this.holder.close()
+  })
+
+When('a producer counting requests to the {token} queue',
+  /**
+   * @param {string} queue
+   * @this {comq.features.Context}
+   */
+  async function (queue) {
+    this.produced = 0
+
+    await this.io.reply(queue, () => {
+      this.produced++
+
+      return null
+    })
+  })
+
+Then('the call is refused as unroutable',
+  /**
+   * @this {comq.features.Context}
+   */
+  async function () {
+    await assert.rejects(this.reply, (error) => error instanceof Unroutable)
+  })
+
+Then('the consumer stops waiting',
+  /**
+   * @this {comq.features.Context}
+   */
+  async function () {
+    await assert.rejects(this.reply, (error) => error.name === 'TimeoutError')
+  })
+
+Given('a holder connected to broker {number} answering {token} under the {token} key as {token}',
+  /**
+   * @param {number} broker
+   * @param {string} exchange
+   * @param {string} key
+   * @param {string} name
+   * @this {comq.features.Context}
+   */
+  async function (broker, exchange, key, name) {
+    this.holder = await another(this, broker)
+
+    await this.holder.back(exchange, key, () => name)
+  })
+
+When('a second holder on another connection holds {token} under the {token} key as {token}',
+  /**
+   * @param {string} exchange
+   * @param {string} key
+   * @param {string} name
+   * @this {comq.features.Context}
+   */
+  async function (exchange, key, name) {
+    const second = await another(this)
+
+    second.diagnose('taken', () => (this.taken = true))
+
+    await second.back(exchange, key, () => name)
+  })
+
+Then('the second holder finds the key taken',
+  /**
+   * @this {comq.features.Context}
+   */
+  async function () {
+    assert.equal(await until(() => this.taken === true), true, 'The key was not found taken')
+  })
+
+Then('every call to {token} under the {token} key is answered by {token} within {number} seconds', { timeout: 120_000 },
+  /**
+   * @param {string} exchange
+   * @param {string} key
+   * @param {string} name
+   * @param {number} seconds
+   * @this {comq.features.Context}
+   */
+  async function (exchange, key, name, seconds) {
+    const answered = await eventually(async () => {
+      const calls = Array.from({ length: 20 }, () => this.io.call(exchange, key, null, { timeout: 1000 }))
+      const replies = await Promise.all(calls)
+
+      if (!replies.every((reply) => reply === name)) throw new Error('Answered by another')
+    }, seconds)
+
+    assert.equal(answered, true, `Calls were not all answered by ${name}`)
+  })
+
+Then('the second holder holds the key',
+  /**
+   * @this {comq.features.Context}
+   */
+  async function () {
+    await this.holding
+  })
+
+Then('the holder finds its key taken while the broker holds the silent connection', { timeout: 60_000 },
+  /**
+   * @this {comq.features.Context}
+   */
+  async function () {
+    assert.equal(await until(() => this.taken === true, 50_000), true, 'The key was not found taken')
+  })
+
+Then('a call to {token} under the {token} key is answered within {number} seconds', { timeout: 120_000 },
+  /**
+   * @param {string} exchange
+   * @param {string} key
+   * @param {number} seconds
+   * @this {comq.features.Context}
+   */
+  async function (exchange, key, seconds) {
+    const answered = await eventually(() => this.io.call(exchange, key, { key }, { timeout: 1000 }), seconds)
+
+    assert.equal(answered, true, 'The call was not answered')
+  })
+
+Then('a call to {token} under the {token} key from another connection is answered within {number} seconds', { timeout: 120_000 },
+  /**
+   * @param {string} exchange
+   * @param {string} key
+   * @param {number} seconds
+   * @this {comq.features.Context}
+   */
+  async function (exchange, key, seconds) {
+    const caller = await another(this)
+    const answered = await eventually(() => caller.call(exchange, key, { key }, { timeout: 1000 }), seconds)
+
+    assert.equal(answered, true, 'The call was not answered')
+  })
+
+Then('a call to {token} under the {token} key is refused within {number} seconds', { timeout: 60_000 },
+  /**
+   * @param {string} exchange
+   * @param {string} key
+   * @param {number} seconds
+   * @this {comq.features.Context}
+   */
+  async function (exchange, key, seconds) {
+    const refused = await eventually(async () => {
+      try {
+        await this.io.call(exchange, key, { key }, { timeout: 1000 })
+      } catch (error) {
+        if (error instanceof Unroutable) return
+
+        throw error
+      }
+
+      throw new Error('Answered')
+    }, seconds)
+
+    assert.equal(refused, true, 'The call was not refused')
+  })
+
+Then('the call ends', { timeout: 90_000 },
+  /**
+   * @this {comq.features.Context}
+   */
+  async function () {
+    await this.reply.catch(() => undefined)
+  })
+
+Then('the consumer stops waiting within {number} second(s)', { timeout: 90_000 },
+  /**
+   * @param {number} seconds
+   * @this {comq.features.Context}
+   */
+  async function (seconds) {
+    const stopped = this.reply.then(() => 'answered', (error) => error.name === 'TimeoutError' ? 'stopped' : error.message)
+    const late = timeout(seconds * 1000).then(() => 'still waiting')
+
+    assert.equal(await Promise.race([stopped, late]), 'stopped')
+  })
+
+Then('every call is answered',
+  /**
+   * @this {comq.features.Context}
+   */
+  async function () {
+    assert.deepEqual(this.replies, this.replies.map((_, n) => n))
+  })
+
+Then('the producer receives nothing',
+  /**
+   * @this {comq.features.Context}
+   */
+  async function () {
+    await timeout(500)
+
+    assert.equal(this.produced, 0, 'An expired request was processed')
+  })
+
+After(
+  /**
+   * @this {comq.features.Context}
+   */
+  async function () {
+    await Promise.all((this.holders ?? []).map((io) => io.close()))
+    await this.silent?.close().catch(() => undefined)
+
+    this.holders = []
+    this.silent = undefined
+  })
+
+/**
+ * Another connection, to the brokers the consumer is connected to, or to one of them.
+ *
+ * @param {comq.features.Context} context
+ * @param {number} [broker]
+ * @returns {Promise<comq.IO>}
+ */
+async function another (context, broker) {
+  const urls = broker !== undefined
+    ? [url(broker)]
+    : context.sharded ? [url(0), url(1)] : [url(0)]
+
+  const io = await connect(...urls)
+
+  context.holders ??= []
+  context.holders.push(io)
+
+  return io
+}
+
+/**
+ * @param {comq.features.Context} context
+ * @param {Promise<any>} reply
+ */
+function call (context, reply) {
+  // asserted on by a later step, and an unhandled rejection would end the run before it
+  reply.catch(() => undefined)
+
+  context.reply = reply
+}
+
+/**
+ * @param {number} broker
+ * @returns {string}
+ */
+function url (broker) {
+  return `amqp://${USER}:${PASSWORD}@${getAddress(broker)}`
+}
+
+/**
+ * Makes an attempt until it succeeds, or until the time is up.
+ *
+ * @param {() => Promise<unknown>} attempt
+ * @param {number} seconds
+ * @returns {Promise<boolean>} whether it succeeded
+ */
+async function eventually (attempt, seconds) {
+  const deadline = Date.now() + seconds * 1000
+
+  while (Date.now() < deadline) {
+    try {
+      await attempt()
+
+      return true
+    } catch {
+      await timeout(500)
+    }
+  }
+
+  return false
+}
+
+function echo (payload) {
+  return payload
+}

package/features/steps/context.js

@@ -21,6 +21,8 @@ class Context extends World {
   attempts = []
   counts = {}
   parked = {}
+  awaited
+  answer
   processed
   enqueued
   tasksProcessedCount = 0
@@ -69,6 +71,8 @@ class Context extends World {
     this.attempts = []
     this.counts = {}
     this.parked = {}
+    this.awaited = undefined
+    this.answer = undefined
   }
 
   /**

package/features/steps/events.js

@@ -38,6 +38,21 @@ Given('(that )events are exclusively consumed from the {token} exchange',
     this.consumptionPromise = consume.call(this, undefined, exchange)
   })
 
+Given('(that )events from the {token} exchange are refused as poison',
+  /**
+   * @param {string} exchange
+   * @this {comq.features.Context}
+   */
+  async function (exchange) {
+    const { Park } = require('../../')
+
+    await this.io.consume(exchange, 'exceptions', (payload, properties) => {
+      this.attempts.push(properties.headers?.['x-comq-attempt'] ?? 1)
+
+      throw new Park('Expected refusal')
+    })
+  })
+
 Given('(that )events from the {token} exchange are causing exceptions',
   /**
    * @param {string} exchange

package/features/steps/network.js

@@ -26,6 +26,14 @@ When('the network goes silent',
     silence.call(this)
   })
 
+When('the silent connection is let go',
+  /**
+   * @this {comq.features.Context}
+   */
+  function () {
+    for (const network of this.networks) network.release()
+  })
+
 // a request that is answered over a connection that is already silent proves
 // nothing, hence the window between the two is left as short as a step boundary
 When('the consumer sends a request to the {token} queue as the network goes silent',

package/features/steps/networks.js

@@ -51,6 +51,14 @@ class Network {
     for (const tunnel of this.#tunnels) tunnel.silent = true
   }
 
+  /**
+   * Closes the tunnels that went silent, at both ends, so the broker learns that the
+   * connection it was still holding is gone — the moment its heartbeat would otherwise tell it.
+   */
+  release () {
+    for (const tunnel of this.#tunnels) if (tunnel.silent) this.#collapse(tunnel)
+  }
+
   async close () {
     for (const tunnel of this.#tunnels) this.#collapse(tunnel)
 
@@ -71,10 +79,22 @@ class Network {
     client.on('data', (chunk) => { if (!tunnel.silent) upstream.write(chunk) })
     upstream.on('data', (chunk) => { if (!tunnel.silent) client.write(chunk) })
 
-    for (const socket of [client, upstream]) {
-      socket.on('error', () => this.#collapse(tunnel))
-      socket.on('close', () => this.#collapse(tunnel))
-    }
+    // a silent network tells neither end that the other has gone: the client giving up on a
+    // silent connection leaves the broker holding its end, until the network is let go
+    client.on('error', () => this.#hangUp(tunnel))
+    client.on('close', () => this.#hangUp(tunnel))
+
+    upstream.on('error', () => this.#collapse(tunnel))
+    upstream.on('close', () => this.#collapse(tunnel))
+  }
+
+  /**
+   * @param {comq.features.Tunnel} tunnel
+   */
+  #hangUp (tunnel) {
+    if (!tunnel.silent) return this.#collapse(tunnel)
+
+    tunnel.client.destroy()
   }
 
   /**

package/features/steps/parked.js

@@ -0,0 +1,102 @@
+'use strict'
+
+const assert = require('node:assert')
+const amqplib = require('amqplib')
+const { Given, When, Then } = require('@cucumber/cucumber')
+
+const { getAddress, USER, PASSWORD } = require('./brokers')
+const { until, timeout } = require('../../test/helpers')
+
+Given('a producer failing every request to the {token} queue',
+  /**
+   * @param {string} queue
+   * @this {comq.features.Context}
+   */
+  async function (queue) {
+    await this.io.reply(queue, () => {
+      throw new Error('Expected failure')
+    })
+  })
+
+When('a request is sent to the {token} queue',
+  /**
+   * The caller is left waiting on purpose: the promise is what the last step asserts on.
+   *
+   * @param {string} queue
+   * @this {comq.features.Context}
+   */
+  async function (queue) {
+    this.awaited = this.io.request(queue, { question: 'the answer?' }, 'application/json')
+
+    // nothing settles it unless the parked request is answered, and an unhandled
+    // rejection would take the run down before the assertion is reached
+    this.awaited.catch(() => undefined)
+  })
+
+Then('the request is parked',
+  /**
+   * @this {comq.features.Context}
+   */
+  async function () {
+    await until(() => this.events.discard === true)
+
+    assert.equal(this.events.discard, true, 'The request was not parked')
+  })
+
+When('the parked request from the {token} queue is answered by hand',
+  /**
+   * What an operator draining the parking queue would do: take the message, read who
+   * was asking, and publish the reply they are still waiting for.
+   *
+   * @param {string} queue
+   * @this {comq.features.Context}
+   */
+  async function (queue) {
+    const connection = await amqplib.connect(`amqp://${USER}:${PASSWORD}@${getAddress(0)}`)
+    const channel = await connection.createChannel()
+
+    try {
+      let parked
+
+      await channel.consume('comq.parked.' + queue, (message) => {
+        parked = message
+        channel.ack(message)
+      })
+
+      await until(() => parked !== undefined)
+
+      assert.notEqual(parked, undefined, `Nothing was parked from ${queue}`)
+
+      const { replyTo, correlationId, contentType } = parked.properties
+
+      assert.notEqual(replyTo, undefined, 'The parked request lost its replyTo')
+      assert.notEqual(correlationId, undefined, 'The parked request lost its correlationId')
+
+      this.answer = { answered: true, was: JSON.parse(parked.content.toString()) }
+
+      channel.sendToQueue(replyTo, Buffer.from(JSON.stringify(this.answer)),
+        { correlationId, contentType })
+
+      // let the frame reach the broker before the connection goes
+      await timeout(100)
+    } finally {
+      await channel.close()
+      await connection.close()
+    }
+  })
+
+Then('the caller receives the reply',
+  /**
+   * @this {comq.features.Context}
+   */
+  async function () {
+    const reply = await Promise.race([
+      this.awaited,
+      timeout(5000).then(() => TIMED_OUT)
+    ])
+
+    assert.notEqual(reply, TIMED_OUT, 'The caller is still waiting')
+    assert.deepEqual(reply, this.answer, 'The caller received something else')
+  })
+
+const TIMED_OUT = Symbol('the caller was still waiting')

package/features/steps/poison.js

@@ -57,9 +57,10 @@ Then('the parked message is kept, and says it came from the {token} exchange',
     assert.equal(headers['x-comq-exchange'], exchange,
       `The parked message says it came from '${headers['x-comq-exchange']}'`)
 
+    // absent on a message parked from its first delivery, exactly as a consumer reads it;
     // derived rather than stated, so it cannot drift from the configured ladder
-    assert.equal(headers['x-comq-attempt'], this.attempts.length,
-      'The parked message was not retried to exhaustion')
+    assert.equal(headers['x-comq-attempt'] ?? 1, this.attempts.length,
+      'The parked message did not have as many attempts as the consumer saw')
   })
 
 Then('{token} has received {int} event(s)',

package/package.json

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