comq 0.4.1 → 0.5.0-dev.0

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

@@ -2,7 +2,7 @@
 
 const { AssertionError } = require('node:assert')
 const { generate } = require('randomstring')
-const { promex } = require('@toa.io/generic')
+const { promex, timeout, random } = require('@toa.io/generic')
 const tomato = require('@toa.io/tomato')
 const { io } = require('./io.mock')
 const mock = { tomato }
@@ -57,8 +57,8 @@ describe('Given {token} consuming events from the {token} exchange is expected',
   it('should be', async () => undefined)
 })
 
-describe('Given that events are exclusively consumed from the {token} exchange', () => {
-  tomato.steps.Gi('that events are exclusively consumed from 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)
 })
@@ -152,3 +152,66 @@ describe('Then the event is received', () => {
     await expect(step.call(context, group)).resolves.not.toThrow()
   })
 })
+
+
+describe('Given I\'m publishing {quantity}B events to the {token} exchange at {quantity}Hz', () => {
+  const step = tomato.steps.Gi('I\'m publishing {quantity}B events to the {token} exchange at {quantity}Hz')
+
+  it('should be', async () => undefined)
+
+  it('should publish events continuously', async () => {
+    context = /** @type {comq.features.Context} */  {
+      io: /** @type {jest.MockedObject<comq.IO>} */ { emit: jest.fn() },
+      requestsSent: [],
+      eventsPublishedCount: 0
+    }
+
+    const bytesQ = '1k'
+    const exchange = generate()
+    const frequencyQ = '100'
+
+    step.call(context, bytesQ, exchange, frequencyQ)
+
+    await timeout(100 + 11)
+
+    expect(context.io.emit).toHaveBeenCalledTimes(10)
+    expect(context.publishing).toBeDefined()
+    expect(context.eventsPublishedCount).toStrictEqual(10)
+
+    clearInterval(context.publishing)
+  })
+})
+
+describe('Then all events have been received', () => {
+  const step = tomato.steps.Th('all events have been received')
+
+  /** @type {jest.MockedObject<comq.features.Context>} */
+  let context
+
+  it('should be', async () => undefined)
+
+  beforeEach(async () => {
+    context = /** @type {jest.MockedObject<comq.features.Context>} */ {
+      eventsPublishedCount: random(100),
+      eventsConsumedCount: 100 + random()
+    }
+  })
+
+  it('should pass if events received', async () => {
+    context.eventsConsumedCount = context.eventsPublishedCount
+
+    await expect(step.call(context)).resolves.not.toThrow()
+  })
+
+  it('should fail if events are not received', async () => {
+    await expect(step.call(context)).rejects.toThrow(AssertionError)
+  })
+
+  it('should wait for last events (50ms)', async () => {
+    setTimeout(() => {
+      context.eventsConsumedCount = context.eventsPublishedCount
+    }, 49)
+
+    await expect(step.call(context)).resolves.not.toThrow()
+  })
+})

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

@@ -2,7 +2,7 @@
 
 const { AssertionError } = require('node:assert')
 const { generate } = require('randomstring')
-const { promex } = require('@toa.io/generic')
+const { promex, timeout } = require('@toa.io/generic')
 const { dump } = require('@toa.io/yaml')
 const tomato = require('@toa.io/tomato')
 const { io } = require('./io.mock')
@@ -42,6 +42,24 @@ describe('Given function replying {token} queue:', () => {
   })
 })
 
+describe('Given a producer replying {token} queue', () => {
+  const step = tomato.steps.Gi('a producer replying {token} queue')
+
+  it('should be', async () => undefined)
+
+  it('should reply', async () => {
+    await step.call(context, queue)
+
+    expect(io.reply).toHaveBeenCalledWith(queue, expect.any(Function))
+
+    const producer = io.reply.mock.calls[0][1]
+    const message = generate()
+    const reply = await producer(message)
+
+    expect(reply).toStrictEqual(message)
+  })
+})
+
 describe('Given function replying {token} queue is expected:', () => {
   tomato.steps.Gi('function replying {token} queue is expected:')
 
@@ -140,6 +158,30 @@ describe('Then the consumer receives the reply:', () => {
   })
 })
 
+describe('Then the consumer receives the reply', () => {
+  const step = tomato.steps.Th('the consumer receives the reply')
+
+  it('should be', async () => undefined)
+
+  it('should await reply', async () => {
+    context.reply = promex()
+
+    let completed = false
+
+    setImmediate(() => {
+      expect(completed).toStrictEqual(false)
+
+      context.reply.resolve()
+
+      completed = true
+    })
+
+    await step.call(context)
+
+    expect(completed).toStrictEqual(true)
+  })
+})
+
 describe('Then the consumer does not receive the reply', () => {
   const step = tomato.steps.Th('the consumer does not receive the reply')
 
@@ -159,3 +201,59 @@ describe('Then the consumer does not receive the reply', () => {
     await expect(step.call(context)).resolves.not.toThrow(AssertionError)
   })
 })
+
+describe('Given I\'m sending {quantity}B requests to the {token} queue at {quantity}Hz', () => {
+  const step = tomato.steps.Gi('I\'m sending {quantity}B requests to the {token} queue at {quantity}Hz')
+
+  it('should be', async () => undefined)
+
+  it('should send requests continuously', async () => {
+    context = /** @type {comq.features.Context} */  {
+      io: /** @type {jest.MockedObject<comq.IO>} */ { request: jest.fn() },
+      requestsSent: []
+    }
+
+    const bytesQ = '1k'
+    const queue = generate()
+    const frequencyQ = '100'
+
+    step.call(context, bytesQ, queue, frequencyQ)
+
+    await timeout(100 + 11)
+
+    expect(context.io.request).toHaveBeenCalledTimes(10)
+    expect(context.sending).toBeDefined()
+    expect(context.requestsSent.length).toStrictEqual(10)
+
+    clearInterval(context.sending)
+  })
+})
+
+describe('Then all replies have been received', () => {
+  const step = tomato.steps.Th('all replies have been received')
+
+  /** @type {jest.MockedObject<comq.features.Context>} */
+  let context
+
+  it('should be', async () => undefined)
+
+  beforeEach(async () => {
+    context = /** @type {jest.MockedObject<comq.features.Context>} */ {
+      requestsSent: [promex(), promex()]
+    }
+  })
+
+  it('should pass if replies received', async () => {
+    let completed = false
+
+    setImmediate(() => {
+      completed = true
+
+      for (const promise of context.requestsSent) promise.resolve()
+    })
+
+    await step.call(context)
+
+    expect(completed).toStrictEqual(true)
+  })
+})

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

@@ -6,12 +6,22 @@ declare namespace comq.features {
   interface Context {
     io?: _io.IO
     connected?: boolean
+    connecting: Promise<any>
+    requestsSent: Promise<any>[]
     reply?: Promise<any>
-    consumed?: Record<string, any>
     published?: any
+    eventsPublishedCount: number
+    eventsConsumedCount: number
+    consumed?: Record<string, any>
+    consumedCount: number
     events?: { [K in _diagnostics.event]?: boolean }
     exception?: Error
     expected?: Promise<any>
+    sharded: boolean
+    shard: number
+    sealing: Promise<any>
+    sending: any
+    publishing: any
 
     connect(user?: string, password?: string): Promise<void>
     disconnect(): Promise<void>

package/features/steps/backpressure.js

@@ -42,5 +42,5 @@ Then('back pressure was applied',
    * @this {comq.features.Context}
    */
   function () {
-    assert.equal(this.events?.flow, true, 'Back pressure hasn\'t been applied')
+    assert.equal(this.events.flow, true, 'Back pressure hasn\'t been applied')
   })

package/features/steps/broker.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const { timeout } = require('@toa.io/generic')
+const { timeout, random } = require('@toa.io/generic')
 const { execute } = require('@toa.io/command')
 
 const { Given } = require('@cucumber/cucumber')
@@ -11,19 +11,34 @@ Given('the broker is/has {status}',
    * @this {comq.features.Context}
    */
   async function (status) {
-    await actions[status](this)
+    const n = this.shard ?? 0
+
+    await actions[status](n)
+  })
+
+Given('one of the brokers is/has {status}',
+  /**
+   * @param {'up' | 'down'} status
+   * @this {comq.features.Context}
+   */
+  async function (status) {
+    const shard = random(BROKERS_AMOUNT)
+
+    this.shard = shard
+
+    await actions[status](shard)
   })
 
 const actions = {
-  up: async () => {
-    await execute('docker start comq-rmq')
+  up: async (n = 0) => {
+    await execute('docker start comq-rmq-' + n)
     await healthy()
   },
-  down: async () => {
-    await execute('docker stop comq-rmq')
+  down: async (n = 0) => {
+    await execute('docker stop comq-rmq-' + n)
   },
-  crashed: async () => {
-    await execute('docker kill comq-rmq')
+  crashed: async (n = 0) => {
+    await execute('docker kill comq-rmq-' + n)
   }
 }
 
@@ -33,6 +48,8 @@ async function healthy () {
   do {
     await timeout(1000)
 
-    process = await execute('docker inspect -f {{.State.Health.Status}} comq-rmq')
+    process = await execute('docker inspect -f {{.State.Health.Status}} comq-rmq-0')
   } while (process.output !== 'healthy')
 }
+
+const BROKERS_AMOUNT = 2

package/features/steps/connection.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const assert = require('node:assert')
-const { timeout } = require('@toa.io/generic')
+const { timeout, promex } = require('@toa.io/generic')
 
 const { Given, When, Then } = require('@cucumber/cucumber')
 
@@ -15,6 +15,35 @@ Given('an active connection to the broker',
     await this.connecting
   })
 
+Given('an active sharded connection',
+  /**
+   * @this {comq.features.Context}
+   */
+  async function () {
+    this.sharded = true
+    this.connecting = this.connect()
+
+    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
@@ -46,6 +75,28 @@ When('I attempt to connect to the broker as {string} with password {string}',
     await connect(this, user, password)
   })
 
+When('I attempt to establish sharded connection',
+  /**
+   * @this {comq.features.Context}
+   */
+  async function () {
+    this.sharded = true
+
+    await connect(this)
+  })
+
+When('I attempt to establish a sharded connection as {string} with password {string}',
+  /**
+   * @param {string} user
+   * @param {string} password
+   * @this {comq.features.Context}
+   */
+  async function (user, password) {
+    this.sharded = true
+
+    await connect(this, user, password)
+  })
+
 Then('the connection is not established',
   /**
    * @this {comq.features.Context}
@@ -98,6 +149,22 @@ Then('the connection is {connection-event}',
     assert.equal(this.events[event], true, 'connection was not ' + key)
   })
 
+Given('the connection has started sealing',
+  /**
+   * @this {comq.features.Context}
+   */
+  async function () {
+    this.sealing = this.io.seal()
+  })
+
+Then('the connection is sealed',
+  /**
+   * @this {comq.features.Context}
+   */
+  async function () {
+    await this.sealing
+  })
+
 /**
  * @param {comq.features.Context} context
  * @param {string} [user]
@@ -108,7 +175,7 @@ const connect = async (context, user, password) => {
   try {
     await context.connect(user, password)
   } catch (exception) {
-    context.exception = exception
+    context.exception = exception instanceof AggregateError ? exception.errors[0] : exception
   }
 }
 

package/features/steps/context.js

@@ -10,17 +10,23 @@ class Context extends World {
   io
   connected = false
   connecting
+  requestsSent = []
   reply
   consumed
   published
+  eventsPublishedCount = 0
+  eventsConsumedCount = 0
   events = {}
   exception
   expected
+  sharded
+  shard
+  sealing
 
   async connect (user, password) {
-    const url = locator(user, password)
+    const urls = this.#urls(user, password)
 
-    await this.#connect(url)
+    await this.#connect(...urls)
   }
 
   async disconnect () {
@@ -34,13 +40,13 @@ class Context extends World {
   }
 
   /**
-   * @param {string} url
+   * @param {...string} urls
    * @return {Promise<void>}
    */
-  async #connect (url) {
+  async #connect (...urls) {
     if (this.io !== undefined) await this.disconnect()
 
-    this.io = await connect(url)
+    this.io = await connect(...urls)
     this.connected = true
 
     for (const event of EVENTS) this.io.diagnose(event, () => (this.events[event] = true))
@@ -48,19 +54,29 @@ class Context extends World {
     this.io.diagnose('close', () => (this.connected = false))
     this.io.diagnose('open', () => (this.connected = true))
   }
-}
 
-const locator = (user, password) => {
-  if (user === undefined) {
-    user = USER
-    password = PASSWORD
+  #urls (user, password) {
+    if (user === undefined) {
+      user = USER
+      password = PASSWORD
+    }
+
+    const urls = []
+
+    urls.push(this.#url(0, user, password))
+
+    if (this.sharded) urls.push(this.#url(1, user, password))
+
+    return urls
   }
 
-  return PROTOCOL + user + ':' + password + '@' + HOST
+  #url (i, user, password) {
+    return PROTOCOL + user + ':' + password + '@' + SHARDS[i]
+  }
 }
 
 const PROTOCOL = 'amqp://'
-const HOST = 'localhost:5673'
+const SHARDS = ['localhost:5673', 'localhost:5674']
 const USER = 'developer'
 const PASSWORD = 'secret'
 

package/features/steps/events.js

@@ -2,8 +2,9 @@
 
 const assert = require('node:assert')
 const { generate } = require('randomstring')
-const { timeout } = require('@toa.io/generic')
+const { timeout, quantity } = require('@toa.io/generic')
 const { Given, When, Then } = require('@cucumber/cucumber')
+const { randomBytes } = require('node:crypto')
 
 Given('(that ){token} is consuming events from the {token} exchange',
   /**
@@ -27,7 +28,7 @@ Given('{token} consuming events from the {token} exchange is expected',
     this.expected = consume.call(this, group, exchange)
   })
 
-Given('that events are exclusively consumed from the {token} exchange',
+Given('(that )events are exclusively consumed from the {token} exchange',
   /**
    * @param {string} exchange
    * @this {comq.features.Context}
@@ -68,6 +69,43 @@ Then('the event is received',
     await consumed.call(this)
   })
 
+Given('I\'m publishing {quantity}B events to the {token} exchange at {quantity}Hz',
+  /**
+   * @param {string} bytesQ
+   * @param {string} queue
+   * @param {string} frequencyQ
+   * @this {comq.features.Context}
+   */
+  async function (bytesQ, queue, frequencyQ) {
+    const bytes = quantity(bytesQ)
+    const frequency = quantity(frequencyQ)
+    const buffer = randomBytes(bytes)
+
+    const delay = Math.max((1000 / frequency), 1)
+
+    const emit = async () => {
+      await this.io.emit(queue, buffer)
+
+      this.eventsPublishedCount++
+    }
+
+    this.publishing = setInterval(emit, delay)
+
+    await timeout(delay * 2) // send at least twice
+  })
+
+Then('all events have been received',
+  /**
+   * @this {comq.features.Context}
+   */
+  async function () {
+    clearInterval(this.publishing)
+
+    await timeout(50)
+
+    assert.equal(this.eventsPublishedCount, this.eventsConsumedCount, 'Not all events has been consumed')
+  })
+
 /**
  * @this {comq.features.Context} context
  * @param {string} group
@@ -79,6 +117,7 @@ async function consume (group, exchange) {
 
   return this.io.consume(exchange, group, async (payload) => {
     this.consumed[group] = payload
+    this.eventsConsumedCount++
   })
 }
 

package/features/steps/rpc.js

@@ -3,7 +3,7 @@
 const assert = require('node:assert')
 const { randomBytes } = require('node:crypto')
 const { parse } = require('@toa.io/yaml')
-const { match, timeout } = require('@toa.io/generic')
+const { match, timeout, quantity } = require('@toa.io/generic')
 const { Given, When, Then } = require('@cucumber/cucumber')
 
 Given('function replying {token} queue:',
@@ -19,6 +19,21 @@ Given('function replying {token} queue:',
     await this.io.reply(queue, producer)
   })
 
+Given('a producer replying {token} queue',
+  /**
+   * @param {string} queue
+   * @this {comq.features.Context}
+   */
+  async function (queue) {
+    const producer = async (request) => {
+      await timeout(10)
+
+      return request
+    }
+
+    await this.io.reply(queue, producer)
+  })
+
 Given('function replying {token} queue is expected:',
   /**
    * @param {string} queue
@@ -68,6 +83,14 @@ Then('the consumer receives the reply:',
     assert.equal(matches, true, 'Reply mismatch')
   })
 
+Then('the consumer receives the reply',
+  /**
+   * @this {comq.features.Context}
+   */
+  async function () {
+    await this.reply
+  })
+
 Then('the consumer does not receive the reply',
   /**
    * @this {comq.features.Context}
@@ -83,6 +106,40 @@ Then('the consumer does not receive the reply',
     assert.equal(reply, undefined, 'The reply was received')
   })
 
+Given('I\'m sending {quantity}B requests to the {token} queue at {quantity}Hz',
+  /**
+   * @param {string} bytesQ
+   * @param {string} queue
+   * @param {string} frequencyQ
+   * @this {comq.features.Context}
+   */
+  async function (bytesQ, queue, frequencyQ) {
+    const bytes = quantity(bytesQ)
+    const buffer = randomBytes(bytes)
+    const frequency = quantity(frequencyQ)
+    const delay = Math.max((1000 / frequency), 1)
+
+    const emit = () => {
+      const promise = this.io.request(queue, buffer)
+
+      this.requestsSent.push(promise)
+    }
+
+    this.sending = setInterval(emit, delay)
+
+    await timeout(delay) // send at least twice
+  })
+
+Then('all replies have been received',
+  /**
+   * @this {comq.features.Context}
+   */
+  async function () {
+    clearInterval(this.sending)
+
+    await Promise.all(this.requestsSent)
+  })
+
 async function send (queue, payload) {
   if (this.expected) await this.expected
 

package/lerna.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "comq",
-  "version": "0.4.1",
+  "version": "0.5.0-dev.0",
   "description": "ComQ",
   "author": {
     "name": "Artem Gurtovoi",
@@ -37,15 +37,15 @@
     "standard": "17.0.0"
   },
   "dependencies": {
-    "@toa.io/generic": "0.4.0-dev.3",
+    "@toa.io/generic": "0.4.0-dev.5",
     "amqplib": "0.10.3",
     "msgpackr": "1.8.5"
   },
   "scripts": {
     "prepare": "husky install",
-    "test": "npm run lint && jest",
-    "test:features": "npx cucumber-js",
-    "lint": "npx standard --verbose | npx snazzy"
+    "test": "standard && jest",
+    "test:features": "cucumber-js",
+    "lint": "standard --fix --verbose | snazzy"
   },
   "standard": {
     "env": [