comq 0.10.0 → 0.10.2

package/source/shards/channel.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const { promex, sample } = require('@toa.io/generic')
+const { Promex } = require('promex')
 const events = require('../events')
 const emitter = require('../emitter')
 
@@ -22,13 +22,13 @@ class Channel {
   /** @type {Set<Promise<comq.Channel>>} */
   #pending = new Set()
 
-  /** @type {Map<comq.Channel, toa.generic.Promex>} */
+  /** @type {Map<comq.Channel, Promex>} */
   #bench = new Map()
 
   /** @type {comq.topology.type} */
   #type
 
-  #recovery = promex()
+  #recovery = new Promex()
 
   #diagnostics = emitter.create()
 
@@ -134,7 +134,7 @@ class Channel {
   #remove (channel) {
     if (!this.#channels.has(channel)) return
 
-    this.#bench.set(channel, promex())
+    this.#bench.set(channel, new Promex())
     this.#channels.delete(channel)
     this.#update()
     this.#diagnostics.emit('remove', channel.index)
@@ -162,7 +162,7 @@ class Channel {
     this.#add(channel)
 
     this.#recovery.resolve()
-    this.#recovery = promex()
+    this.#recovery = new Promex()
   }
 
   #comeback (channel) {
@@ -209,7 +209,7 @@ class Channel {
   async #one (fn) {
     if (this.#pool.length === 0) await this.#recovery
 
-    const channel = sample(this.#pool)
+    const channel = this.#pool[Math.floor(Math.random() * this.#pool.length)]
 
     try {
       return await fn(channel)

package/types/io.d.ts

@@ -22,18 +22,15 @@ declare namespace comq {
     buffer: Buffer
     emitter: ReplyEmitter
     properties: _amqp.Properties
-    reply: any
   }
 
   interface IO extends _diagnostics.Diagnosable {
     reply (queue: string, produce: Producer): Promise<void>
 
-    request<Reply = any, Request = any> (queue: string, payload: Request, encoding?: _encoding.Encoding): Promise<Reply>
+    request<Reply = any, Request = any> (queue: string, payload: Request, encoding?: _encoding.Encoding): Promise<Reply> | Promise<Readable>
 
     request (queue: string, stream: Readable, encoding?: _encoding.Encoding): Promise<Readable>
 
-    fetch (queue: string, payload: any, encoding?: _encoding.Encoding): Promise<Readable>
-
     consume<T = any> (exchange: string, group: string, consumer: Consumer<T>): Promise<void>
 
     consume<T = any> (exchange: string, consumer: Consumer<T>): Promise<void>

package/features/steps/.test/backpressure.test.js

@@ -1,79 +0,0 @@
-'use strict'
-
-const { AssertionError } = require('node:assert')
-const { generate } = require('randomstring')
-const { random, quantity } = require('@toa.io/generic')
-const tomato = require('@toa.io/tomato')
-const { io } = require('./io.mock')
-const mock = { tomato }
-
-jest.mock('@cucumber/cucumber', () => mock.tomato)
-
-require('../backpressure')
-
-/** @type {comq.features.Context} */
-let context
-
-describe('When I\'m sending {quantity}B requests to the {token} queue at {quantity}Hz for {number} second(s)', () => {
-  const step = tomato.steps.Wh('I\'m sending {quantity}B requests to the {token} queue at {quantity}Hz for {number} second(s)')
-
-  it('should be', async () => undefined)
-
-  const bytesQ = (random(5) + 1) + 'k'
-  const frequencyQ = String((random(5) + 1) / 10) + 'k' // not too high
-  const seconds = (random(3) + 1) / 10
-  const queue = generate()
-
-  const bytes = quantity(bytesQ)
-  const frequency = quantity(frequencyQ)
-
-  beforeAll(async () => {
-    jest.clearAllMocks()
-
-    context = /** @type {comq.features.Context} */ { io, requestCount: 0, replyCount: 0 }
-
-    await step.call(context, bytesQ, queue, frequencyQ, seconds)
-  })
-
-  it('should send request', async () => {
-    expect(io.request).toHaveBeenCalled()
-  })
-
-  it('should sent request to specified queue', async () => {
-    const call = io.request.mock.calls[0]
-
-    expect(call[0]).toStrictEqual(queue)
-  })
-
-  it('should send buffer of given size', async () => {
-    const buffer = io.request.mock.calls[0][1]
-
-    expect(Buffer.byteLength(buffer)).toStrictEqual(bytes)
-  })
-
-  it('should send expected amount of requests', async () => {
-    const times = Math.ceil(seconds * frequency)
-
-    expect(io.request).toHaveBeenCalledTimes(times)
-  })
-})
-
-describe('Then back pressure was applied', () => {
-  const step = tomato.steps.Th('back pressure was applied')
-
-  beforeEach(() => {
-    context = /** @type {comq.features.Context} */ { io, events: {} }
-  })
-
-  it('should be', async () => undefined)
-
-  it('should fail if flag is not set', async () => {
-    expect(() => step.call(context)).toThrow(AssertionError)
-  })
-
-  it('should pass if flag is true', async () => {
-    context.events = { flow: true }
-
-    expect(() => step.call(context)).not.toThrow()
-  })
-})

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

@@ -1,101 +0,0 @@
-'use strict'
-
-const { generate } = require('randomstring')
-const tomato = require('@toa.io/tomato')
-const { command } = require('./command.mock')
-const mock = { tomato, command }
-
-jest.mock('@cucumber/cucumber', () => mock.tomato)
-jest.mock('@toa.io/command', () => mock.command)
-
-jest.setTimeout(10000)
-
-global.COMQ_TESTING_HEALTHCHECK_INTERVAL = 0
-
-require('../broker')
-
-const context = /** @type {comq.features.Context} */ {}
-
-beforeEach(() => {
-  jest.clearAllMocks()
-})
-
-describe.each([false, true])('Given the broker is/has {status} #shards:%s', (sharded) => {
-  const step = tomato.steps.Gi('the broker is/has {status}')
-
-  const containerNumber = sharded ? 1 : 0
-
-  it('should be', async () => undefined)
-
-  beforeEach(() => {
-    context.io = generate()
-
-    if (sharded) {
-      context.sharded = true
-      context.shard = containerNumber
-    }
-  })
-
-  it('should start comq-rmq container', async () => {
-    command.execute.mockImplementationOnce(async () => undefined)
-    command.execute.mockImplementationOnce(async () => ({ output: 'healthy' }))
-
-    await step.call(context, 'up')
-
-    expect(command.execute).toHaveBeenCalledWith('docker start comq-rmq-' + containerNumber)
-  })
-
-  it('should wait for healthy state', async () => {
-    let starting = false
-    let healthy = false
-
-    command.execute.mockImplementationOnce(async () => undefined)
-
-    command.execute.mockImplementationOnce(async () => {
-      starting = true
-
-      return { output: 'starting' }
-    })
-
-    command.execute.mockImplementationOnce(async () => {
-      healthy = true
-
-      return { output: 'healthy' }
-    })
-
-    await step.call(context, 'up')
-
-    expect(command.execute).toHaveBeenCalledTimes(3)
-  })
-
-  it('should stop comq-rmq container', async () => {
-    await step.call(context, 'down')
-
-    expect(command.execute).toHaveBeenCalledWith('docker stop comq-rmq-' + containerNumber)
-  })
-
-  it('should kill comq-rmq-0 container', async () => {
-    await step.call(context, 'crashed')
-
-    expect(command.execute).toHaveBeenCalledWith('docker kill comq-rmq-' + containerNumber)
-  })
-})
-
-describe('Given one of the brokers is/has {status}', () => {
-  const step = tomato.steps.Gi('one of the brokers is/has {status}')
-
-  it('should store picked broker', async () => {
-    await step.call(context, 'down')
-
-    expect(context.shard).toStrictEqual(expect.any(Number))
-  })
-
-  it('should start one of the containers', async () => {
-    command.execute.mockImplementationOnce(async () => undefined)
-    command.execute.mockImplementationOnce(async () => ({ output: 'healthy' }))
-
-    await step.call(context, 'up')
-
-    expect(command.execute).toHaveBeenCalledWith('docker start comq-rmq-' + context.shard)
-  })
-})

package/features/steps/.test/command.mock.js

@@ -1,5 +0,0 @@
-'use strict'
-
-const execute = jest.fn(async () => undefined)
-
-exports.command = { execute }

package/features/steps/.test/comq.mock.js

@@ -1,10 +0,0 @@
-'use strict'
-
-const io = () => ({
-  diagnose: jest.fn(() => undefined),
-  close: jest.fn(async () => undefined)
-})
-
-const connect = jest.fn(async () => io())
-
-exports.comq = { connect }

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

@@ -1,285 +0,0 @@
-'use strict'
-
-const { AssertionError } = require('node:assert')
-const { generate } = require('randomstring')
-const { random, promex } = require('@toa.io/generic')
-const tomato = require('@toa.io/tomato')
-const { comq } = require('./comq.mock')
-const world = require('./context.mock')
-const mock = { tomato, comq }
-
-jest.mock('@cucumber/cucumber', () => mock.tomato)
-jest.mock('comq', () => mock.comq)
-
-require('../connection')
-
-/** @type {jest.MockedObject<comq.features.Context>} */
-let context
-
-beforeEach(() => {
-  jest.clearAllMocks()
-
-  context = world.context()
-})
-
-describe('Given an active connection to the broker', () => {
-  const step = tomato.steps.Gi('an active connection to the broker')
-
-  it('should be', async () => undefined)
-
-  beforeEach(async () => {
-    await step.call(context)
-  })
-
-  it('should connect', async () => {
-    expect(context.connect).toHaveBeenCalled()
-  })
-
-  it('should store promise', async () => {
-    expect(context.connecting).toBeInstanceOf(Promise)
-  })
-})
-
-describe('Given an active sharded connection', () => {
-  const step = tomato.steps.Gi('an active sharded connection')
-
-  it('should be', async () => undefined)
-
-  beforeEach(async () => {
-    await step.call(context)
-  })
-
-  it('should set sharded to true', async () => {
-    expect(context.sharded).toStrictEqual(true)
-  })
-
-  it('should connect', async () => {
-    expect(context.connect).toHaveBeenCalled()
-  })
-
-  it('should store promise', async () => {
-    expect(context.connecting).toStrictEqual(expect.any(Promise))
-  })
-})
-
-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)')
-
-  it('should be', async () => undefined)
-
-  const interval = (random(2) + 1) / 10
-
-  describe('broker available', () => {
-    beforeEach(async () => {
-      await step.call(context, interval)
-    })
-
-    it('should call connect', async () => {
-      expect(context.connect).toHaveBeenCalled()
-    })
-  })
-
-  describe('broker unavailable', () => {
-    /** @type {toa.generic.Promex} */
-    let connection
-
-    beforeEach(() => {
-      connection = promex()
-
-      context.connect.mockImplementationOnce(async () => connection)
-    })
-
-    it('should quit after given interval', async () => {
-      const start = new Date().getTime()
-
-      await step.call(context, interval)
-
-      const end = new Date().getTime()
-      const inaccuracy = 1 // setTimeout is inaccurate
-
-      expect(end - start + inaccuracy).toBeGreaterThanOrEqual(interval * 1000)
-    })
-  })
-
-  describe('exceptions', () => {
-    it('should catch exception', async () => {
-      const exception = new Error(generate())
-
-      context.connect.mockImplementationOnce(async () => { throw exception })
-
-      await step.call(context, interval)
-
-      expect(context.exception).toStrictEqual(exception)
-    })
-  })
-})
-
-describe('When I attempt to connect to the broker', () => {
-  const step = tomato.steps.Wh('I attempt to connect to the broker')
-
-  it('should be', async () => undefined)
-
-  it('should connect', async () => {
-    await step.call(context)
-
-    expect(context.connect).toHaveBeenCalled()
-  })
-
-  it('should store exception', async () => {
-    const exception = new Error(generate())
-
-    context.connect.mockImplementationOnce(async () => { throw exception })
-
-    await step.call(context)
-
-    expect(context.exception).toStrictEqual(exception)
-  })
-})
-
-describe('When I attempt to connect to the broker as {string} with password {string}', () => {
-  const step = tomato.steps.Wh('I attempt to connect to the broker as {string} with password {string}')
-
-  it('should be', async () => undefined)
-
-  const user = generate()
-  const password = generate()
-
-  it('should connect with credentials', async () => {
-    await step.call(context, user, password)
-
-    expect(context.connect).toHaveBeenCalledWith(user, password)
-  })
-})
-
-describe('When I attempt to establish sharded connection', () => {
-  const step = tomato.steps.Wh('I attempt to establish sharded connection')
-
-  it('should be', async () => undefined)
-
-  it('should set context.sharded to true', async () => {
-    await step.call(context)
-
-    expect(context.sharded).toStrictEqual(true)
-  })
-
-  it('should connect', async () => {
-    await step.call(context)
-
-    expect(context.connect).toHaveBeenCalled()
-  })
-})
-
-describe('When I attempt to establish a sharded connection as {string} with password {string}', () => {
-  const step = tomato.steps.Wh('I attempt to establish a sharded connection as {string} with password {string}')
-
-  it('should be', async () => undefined)
-
-  const user = generate()
-  const password = generate()
-
-  it('should connect with credentials', async () => {
-    await step.call(context, user, password)
-
-    expect(context.sharded).toStrictEqual(true)
-    expect(context.connect).toHaveBeenCalledWith(user, password)
-  })
-})
-
-describe.each([['', true], [' not', false]])('Then the connection is%s established',
-  (not, connected) => {
-    const step = tomato.steps.Th(`the connection is${not} established`)
-
-    it('should be', async () => undefined)
-
-    it(`should fail if is${connected ? 'n\'t' : ''} connected`, async () => {
-      context.connected = !connected
-
-      await expect(step.call(context)).rejects.toThrow(AssertionError)
-    })
-
-    it(`should pass if is${connected ? '' : 'n\'t'} connected`, async () => {
-      context.connected = connected
-
-      await expect(step.call(context)).resolves.not.toThrow()
-    })
-  })
-
-describe('Then no exceptions are thrown', () => {
-  const step = tomato.steps.Th('no exceptions are thrown')
-
-  it('should be', async () => undefined)
-
-  it(`should fail if exception is defined`, async () => {
-    context.exception = new Error()
-
-    expect(() => step.call(context)).toThrow(AssertionError)
-  })
-
-  it(`should pass if exception isn't defined`, async () => {
-    expect(() => step.call(context)).not.toThrow()
-  })
-})
-
-describe('Then an exception is thrown: {string}', () => {
-  const step = tomato.steps.Th('an exception is thrown: {string}')
-
-  const message = generate()
-
-  it('should be', async () => undefined)
-
-  it(`should pass if exception is defined and message matches`, async () => {
-    context.exception = new Error(message)
-
-    const slice = message.slice(2, 6)
-
-    expect(() => step.call(context, slice)).not.toThrow()
-  })
-
-  it(`should fail if exception isn't defined`, async () => {
-    expect(() => step.call(context)).toThrow(AssertionError)
-  })
-
-  it('should fail if message doesn\'t match', async () => {
-    context.exception = new Error(generate())
-
-    expect(() => step.call(context)).toThrow(AssertionError)
-  })
-})
-
-describe('Given the connection has started sealing', () => {
-  const step = tomato.steps.Gi('the connection has started sealing')
-
-  it('should be', async () => undefined)
-
-  it('should seal the connection', async () => {
-    context.io = /** @type {jest.MockedObject<comq.IO>} */ {
-      seal: jest.fn(async () => undefined)
-    }
-
-    await step.call(context)
-
-    expect(context.io.seal).toHaveBeenCalled()
-    expect(context.sealing).toBeInstanceOf(Promise)
-  })
-})
-
-describe('Then the connection is sealed', () => {
-  const step = tomato.steps.Th('the connection is sealed')
-
-  it('should be', async () => undefined)
-
-  it('should await for sealing', async () => {
-    context.sealing = promex()
-
-    let sealed = false
-
-    setImmediate(() => {
-      context.sealing.resolve()
-      sealed = true
-    })
-
-    await step.call(context)
-
-    expect(sealed).toStrictEqual(true)
-  })
-})

package/features/steps/.test/context.mock.js

@@ -1,14 +0,0 @@
-'use strict'
-
-const { comq } = require('./comq.mock')
-
-const connect = jest.fn(() => comq.connect())
-const disconnect = jest.fn(async () => undefined)
-
-/**
- * @return {jest.MockedObject<comq.features.Context>}
- */
-exports.context = () => (/** @type {jest.MockedObject<comq.features.Context>} */{
-  connect,
-  disconnect
-})

package/features/steps/.test/context.test.js

@@ -1,74 +0,0 @@
-'use strict'
-
-const { generate } = require('randomstring')
-const { comq } = require('./comq.mock')
-const mock = { comq }
-
-jest.mock('comq', () => mock.comq)
-
-const { Context } = require('../context')
-
-it('should be', async () => {
-  expect(Context).toBeDefined()
-})
-
-/** @type {comq.features.Context} */
-let context
-
-beforeAll(async () => {
-  const _ = {}
-
-  // noinspection JSValidateTypes
-  context = new Context(_)
-})
-
-describe.each([false, true])('connect (shards: %s)', (sharded) => {
-  it('should be', async () => {
-    expect(context.connect).toBeDefined()
-  })
-
-  /** @type {jest.MockedObject<comq.IO>} */
-  let io
-
-  beforeEach(async () => {
-    context.sharded = sharded
-
-    await context.connect()
-
-    io = await comq.connect.mock.results[0].value
-  })
-
-  it('should connect', async () => {
-    const shards = ['amqp://developer:secret@localhost:5673', 'amqp://developer:secret@localhost:5674']
-
-    if (sharded) expect(comq.connect).toHaveBeenCalledWith(...shards)
-    else expect(comq.connect).toHaveBeenCalledWith(shards[0])
-  })
-
-  it('should connect with credentials', async () => {
-    const user = generate()
-    const password = generate()
-
-    await context.connect(user, password)
-
-    const shards = [`amqp://${user}:${password}@localhost:5673`, `amqp://${user}:${password}@localhost:5674`]
-
-    if (sharded) expect(comq.connect).toHaveBeenCalledWith(...shards)
-    else expect(comq.connect).toHaveBeenCalledWith(shards[0])
-  })
-
-  it.each(['open', 'close', 'flow', 'discard'])('should store %s event',
-    /**
-     * @param {comq.diagnostics.Event} event
-     */
-    async (event) => {
-      expect(io.diagnose).toHaveBeenCalledWith(event, expect.any(Function))
-      expect(context.events[event]).not.toStrictEqual(true)
-
-      const listener = io.diagnose.mock.calls.find((call) => call[0] === event)[1]
-
-      listener()
-
-      expect(context.events[event]).toStrictEqual(true)
-    })
-})