comq 0.5.2 → 0.5.3-dev.1

package/.github/dependabot.yml

@@ -6,12 +6,11 @@ updates:
       interval: "weekly"
     target-branch: "dev"
     labels:
-      - "dependency"
-      - "actions"
+      - "Bump"
   - package-ecosystem: "npm"
     directory: "/"
     schedule:
       interval: "daily"
     target-branch: "dev"
     labels:
-      - "dependency"
+      - "Bump"

package/features/steps/.test/broker.test.js

@@ -10,6 +10,8 @@ jest.mock('@toa.io/command', () => mock.command)
 
 jest.setTimeout(10000)
 
+global.COMQ_TESTING_HEALTHCHECK_INTERVAL = 0
+
 require('../broker')
 
 const context = /** @type {comq.features.Context} */ {}

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

@@ -172,11 +172,13 @@ describe('Given I\'m publishing {quantity}B events to the {token} exchange at {q
 
     step.call(context, bytesQ, exchange, frequencyQ)
 
-    await timeout(100 + 11)
+    await timeout(100 + 12)
 
-    expect(context.io.emit).toHaveBeenCalledTimes(10)
+    const callsAmountExpected = [10, 11]
+
+    expect(callsAmountExpected).toContain(context.io.emit.mock.calls.length)
     expect(context.publishing).toBeDefined()
-    expect(context.eventsPublishedCount).toStrictEqual(10)
+    expect(callsAmountExpected).toContain(context.eventsPublishedCount)
 
     clearInterval(context.publishing)
   })

package/features/steps/.test/rpc.test.js

@@ -219,11 +219,13 @@ describe('Given I\'m sending {quantity}B requests to the {token} queue at {quant
 
     step.call(context, bytesQ, queue, frequencyQ)
 
-    await timeout(100 + 11)
+    await timeout(100 + 12)
 
-    expect(context.io.request).toHaveBeenCalledTimes(10)
+    const callsAmountExpected = [10, 11]
+
+    expect(callsAmountExpected).toContain(context.io.request.mock.calls.length)
     expect(context.sending).toBeDefined()
-    expect(context.requestsSent.length).toStrictEqual(10)
+    expect(callsAmountExpected).toContain(context.requestsSent.length)
 
     clearInterval(context.sending)
   })

package/features/steps/broker.js

@@ -46,10 +46,11 @@ async function healthy () {
   let process
 
   do {
-    await timeout(1000)
+    await timeout(HEALTHCHECK_INTERVAL)
 
     process = await execute('docker inspect -f {{.State.Health.Status}} comq-rmq-0')
   } while (process.output !== 'healthy')
 }
 
 const BROKERS_AMOUNT = 2
+const HEALTHCHECK_INTERVAL = global.COMQ_TESTING_HEALTHCHECK_INTERVAL ?? 1000

package/lerna.json

@@ -1,5 +1,5 @@
 {
   "useWorkspaces": true,
-  "version": "0.5.2",
+  "version": "0.5.3-dev.1",
   "conventionalCommits": true
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "comq",
-  "version": "0.5.2",
+  "version": "0.5.3-dev.1",
   "description": "ComQ",
   "author": {
     "name": "Artem Gurtovoi",
@@ -27,7 +27,7 @@
   "main": "source/index.js",
   "types": "types/index.d.ts",
   "devDependencies": {
-    "@cucumber/cucumber": "9.0.1",
+    "@cucumber/cucumber": "9.1.0",
     "@toa.io/command": "0.3.0",
     "@toa.io/mock": "0.3.0",
     "@toa.io/tomato": "0.4.0-dev.2",
@@ -48,7 +48,7 @@
   "scripts": {
     "prepare": "husky install",
     "test": "standard && jest",
-    "test:features": "cucumber-js",
+    "features": "cucumber-js",
     "lint": "standard --fix --verbose | snazzy"
   },
   "standard": {

package/readme.md

@@ -83,11 +83,11 @@ The Reply message is encoded using the same encoding format as the Request messa
 `application/octet-stream` and the `producer` function returns something other than a `Buffer`, an
 exception will be thrown.
 
-> If the incoming message does not have a `replyTo` property, an exception is thrown without
-> calling `producer`.
-
 > The `replyTo` queue is not asserted, as it is expected to be done by the Consumer.
 
+> If the incoming message does not have a `replyTo` property, the result of the `producer` is
+> ignored.
+
 ### Example
 
 ```javascript

package/source/io.js

@@ -25,8 +25,8 @@ class IO {
   /** @type {comq.Channel} */
   #events
 
-  /** @type {Record<string, comq.ReplyEmitter>} */
-  #emitters = {}
+  /** @type {Map<string, comq.ReplyEmitter>} */
+  #emitters = new Map()
 
   /** @type {Set<toa.generic.Promex>} */
   #pendingReplies = new Set()
@@ -67,12 +67,13 @@ class IO {
        * @returns {Promise<void>}
        */
       async (queue, payload, encoding, replyToFormatter) => {
-        const [buffer, contentType] = this.#encode(payload, encoding)
-        const correlationId = randomBytes(8).toString('hex')
-        const emitter = this.#emitters[queue]
-        const replyTo = replyToFormatter?.(emitter.queue) ?? emitter.queue
-        const properties = { contentType, correlationId, replyTo }
+        const [buffer, properties] = this.#encode(payload, encoding)
+        const emitter = this.#emitters.get(queue)
         const reply = this.#createReply()
+        const correlationId = randomBytes(8).toString('hex')
+
+        properties.replyTo = replyToFormatter?.(emitter.queue) ?? emitter.queue
+        properties.correlationId = correlationId
 
         emitter.once(correlationId, reply.resolve)
 
@@ -103,8 +104,7 @@ class IO {
      * @returns {Promise<void>}
      */
     async (exchange, payload, encoding) => {
-      const [buffer, contentType] = this.#encode(payload, encoding)
-      const properties = { contentType }
+      const [buffer, properties] = this.#encode(payload, encoding)
 
       await this.#events.publish(exchange, buffer, properties)
     })
@@ -127,12 +127,16 @@ class IO {
   // region initializers
 
   async #createRequestReplyChannels () {
-    this.#requests = await this.#createChannel('request')
-    this.#replies = await this.#createChannel('reply')
+    await this.#createRequestChannel()
 
+    this.#replies = await this.#createChannel('reply')
     this.#setupRetransmission()
   }
 
+  async #createRequestChannel () {
+    this.#requests = await this.#createChannel('request')
+  }
+
   async #createEventChannel () {
     this.#events = await this.#createChannel('event')
   }
@@ -141,7 +145,7 @@ class IO {
     const emitter = io.createReplyEmitter(queue)
     const consumer = this.#getReplyConsumer(queue, emitter)
 
-    this.#emitters[queue] = emitter
+    this.#emitters.set(queue, emitter)
 
     await this.#replies.consume(emitter.queue, consumer)
   }
@@ -173,24 +177,36 @@ class IO {
    * @returns {comq.channels.consumer}
    */
   #getRequestConsumer = (producer) =>
-    track(this, async (message) => {
-      if (!('replyTo' in message.properties)) throw new Error('Request is missing the `replyTo` property')
+    track(this,
+      /**
+       * @param {comq.amqp.Message} request
+       * @returns {Promise<void>}
+       */
+      async (request) => {
+        const payload = decode(request)
+        const reply = await producer(payload)
 
-      const payload = decode(message)
-      const reply = await producer(payload)
+        if ('replyTo' in request.properties) await this.#reply(request, reply)
+      })
 
-      if (reply === undefined) throw new Error('The `producer` function must return a value')
+  /**
+   * @param {comq.amqp.Message} request
+   * @param {any} reply
+   * @returns {Promise<void>}
+   */
+  async #reply (request, reply) {
+    if (reply === undefined) throw new Error('The `producer` function must return a value')
 
-      let { correlationId, contentType } = message.properties
+    let { replyTo, correlationId, contentType } = request.properties
 
-      if (Buffer.isBuffer(reply)) contentType = OCTETS
-      if (contentType === undefined) throw new Error('Reply to a Request without the `contentType` property must be of type `Buffer`')
+    if (Buffer.isBuffer(reply)) contentType = OCTETS
+    if (contentType === undefined) throw new Error('Reply to a Request without the `contentType` property must be of type `Buffer`')
 
-      const buffer = contentType === OCTETS ? reply : encode(reply, contentType)
-      const properties = { contentType, correlationId }
+    const buffer = contentType === OCTETS ? reply : encode(reply, contentType)
+    const properties = { contentType, correlationId }
 
-      await this.#replies.fire(message.properties.replyTo, buffer, properties)
-    })
+    await this.#replies.fire(replyTo, buffer, properties)
+  }
 
   /**
    * @param {string} queue
@@ -198,9 +214,6 @@ class IO {
    * @returns {comq.channels.consumer}
    */
   #getReplyConsumer = (queue, emitter) =>
-    /**
-     * @param {comq.amqp.Message} message
-     */
     (message) => {
       const payload = decode(message)
 
@@ -226,7 +239,9 @@ class IO {
 
     this.#pendingReplies.add(reply)
 
-    reply.catch(noop).finally(() => this.#pendingReplies.delete(reply))
+    reply
+      .catch(noop)
+      .finally(() => this.#pendingReplies.delete(reply))
 
     return reply
   }
@@ -236,7 +251,7 @@ class IO {
   }
 
   #retransmit = () => {
-    for (const emitter of Object.values(this.#emitters)) emitter.clear()
+    for (const emitter of this.#emitters.values()) emitter.clear()
 
     // trigger failsafe attribute
     for (const reply of this.#pendingReplies) reply.reject(RETRANSMISSION)
@@ -244,17 +259,18 @@ class IO {
 
   /**
    * @param {any} payload
-   * @param {comq.encoding} [encoding]
-   * @returns [Buffer, string]
+   * @param {comq.encoding} [contentType]
+   * @returns [Buffer, comq.amqp.options.Publish]
    */
-  #encode (payload, encoding) {
+  #encode (payload, contentType) {
     const raw = Buffer.isBuffer(payload)
 
-    encoding ??= raw ? OCTETS : DEFAULT
+    contentType ??= raw ? OCTETS : DEFAULT
 
-    const buffer = raw ? payload : encode(payload, encoding)
+    const buffer = raw ? payload : encode(payload, contentType)
+    const properties = { contentType }
 
-    return [buffer, encoding]
+    return [buffer, properties]
   }
 }
 

package/test/channel.test.js

@@ -4,7 +4,7 @@
 
 const { randomBytes } = require('node:crypto')
 const { generate } = require('randomstring')
-const { flip, random } = require('@toa.io/generic')
+const { flip, random, timeout } = require('@toa.io/generic')
 
 const backpressure = require('./backpressure')
 const { amqplib } = require('./amqplib.mock')
@@ -712,6 +712,9 @@ describe('recovery', () => {
 
       const repl = await getCreatedChannel(replacement)
 
+      // await recovery effect
+      await timeout(5)
+
       expect(repl.publish).toHaveBeenCalled()
     })
 
@@ -730,7 +733,7 @@ describe('recovery', () => {
 
       const chan = await getCreatedChannel()
 
-      chan.publish.mockImplementation(() => true)
+      chan.publish.mockImplementation(() => true) // back pressure
 
       /** @type {jest.MockedObject<comq.amqp.Connection>} */
       let replacement
@@ -747,6 +750,8 @@ describe('recovery', () => {
 
       const repl = await getCreatedChannel(replacement)
 
+      await timeout(5)
+
       expect(repl.publish).toHaveBeenCalledWith(
         exchange, '', buffer, expect.objectContaining(options), expect.any(Function)
       )

package/test/io.reply.test.js

@@ -70,15 +70,6 @@ describe('queues', () => {
   it('should consume queue', async () => {
     expect(requests.consume).toHaveBeenCalledWith(queue, expect.any(Function))
   })
-
-  it('should throw if message is missing replyTo', async () => {
-    const content = randomBytes(10)
-    const properties = {}
-    const message = /** @type {comq.amqp.Message} */ { content, properties }
-    const producer = requests.consume.mock.calls[0][1]
-
-    await expect(producer(message)).rejects.toThrow('is missing the `replyTo` property')
-  })
 })
 
 describe('reply', () => {
@@ -89,14 +80,13 @@ describe('reply', () => {
   let replies
 
   beforeEach(async () => {
-  })
-
-  it('should `fire` reply', async () => {
     await io.reply(queue, produce)
 
     requests = await findChannel('request')
     replies = await findChannel('reply')
+  })
 
+  it('should `fire` reply', async () => {
     const content = randomBytes(10)
     const properties = { replyTo: generate(), contentType: 'text/plain' }
     const message = /** @type {comq.amqp.Message} */ { content, properties }
@@ -111,18 +101,39 @@ describe('reply', () => {
   })
 
   it('should throw if producer returned undefined', async () => {
+    jest.clearAllMocks()
+
     const produce = () => undefined
 
     await io.reply(queue, produce)
 
-    const requests = await findChannel('request')
     const callback = requests.consume.mock.calls[0][1]
-    const content = randomBytes(10)
-    const properties = { replyTo: generate() }
+    const content = generate()
+    const properties = { replyTo: generate(), contentType: 'text/plain' }
     const message = /** @type {comq.amqp.Message} */ { content, properties }
 
     await expect(callback(message)).rejects.toThrow('must return a value')
   })
+
+  it('should not throw if message is missing replyTo', async () => {
+    const content = generate()
+    const properties = { contentType: 'text/plain' }
+    const message = /** @type {comq.amqp.Message} */ { content, properties }
+    const producer = requests.consume.mock.calls[0][1]
+
+    await expect(producer(message)).resolves.not.toThrow()
+  })
+
+  it('should not send reply if request has no `replyTo` property', async () => {
+    const content = generate()
+    const properties = { contentType: 'text/plain' }
+    const message = /** @type {comq.amqp.Message} */ { content, properties }
+    const producer = requests.consume.mock.calls[0][1]
+
+    await producer(message)
+
+    expect(replies.fire).not.toHaveBeenCalled()
+  })
 })
 
 describe('encoding', () => {

package/test/io.request.test.js

@@ -43,8 +43,6 @@ let promise
 const REPLY = new RegExp(`^${queue}..[0-9a-f]+$`)
 
 beforeEach(async () => {
-  jest.clearAllMocks()
-
   promise = io.request(queue, payload)
 
   // allows initializers to run