comq 0.10.1 → 0.10.2

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)
-    })
-})

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

@@ -1,279 +0,0 @@
-'use strict'
-
-const { AssertionError } = require('node:assert')
-const { randomBytes } = require('node:crypto')
-const { generate } = require('randomstring')
-const { promex, timeout, random } = require('@toa.io/generic')
-const tomato = require('@toa.io/tomato')
-const { dump } = require('@toa.io/yaml')
-const { io } = require('./io.mock')
-const mock = { tomato }
-
-jest.mock('@cucumber/cucumber', () => mock.tomato)
-
-require('../events')
-
-/** @type {comq.features.Context} */
-let context
-
-beforeEach(() => {
-  jest.clearAllMocks()
-
-  context = /** @type {comq.features.Context} */ { io }
-})
-
-describe('Given (that ){token} is consuming events from the {token} exchange', () => {
-  const step = tomato.steps.Gi('(that ){token} is consuming events from the {token} exchange')
-
-  it('should be', async () => undefined)
-
-  const exchange = generate()
-  const group = generate()
-
-  let consumer
-
-  beforeEach(async () => {
-    await step.call(context, group, exchange)
-
-    consumer = io.consume.mock.calls[0]?.[2]
-
-    expect(consumer).toBeInstanceOf(Function)
-  })
-
-  it('should consume', async () => {
-    expect(io.consume).toHaveBeenCalledTimes(1)
-  })
-
-  it('should store event in context', async () => {
-    const payload = generate()
-
-    await consumer(payload)
-
-    expect(context.consumed[group]).toStrictEqual(expect.objectContaining({ payload }))
-  })
-
-  it('should store event properties', async () => {
-    const payload = generate()
-    const properties = generate()
-
-    await consumer(payload, properties)
-
-    expect(context.consumed[group]).toStrictEqual({ payload, properties })
-  })
-})
-
-describe('Given {token} consuming events from the {token} exchange is expected', () => {
-  tomato.steps.Gi('{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')
-
-  it('should be', async () => undefined)
-})
-
-describe('When an event is emitted to the {token} exchange', () => {
-  const step = tomato.steps.Wh('an event is emitted to the {token} exchange')
-
-  it('should be', async () => undefined)
-
-  const exchange = generate()
-
-  beforeEach(async () => {
-    await step.call(context, exchange)
-  })
-
-  it('should store event', async () => {
-    expect(context.published).toBeDefined()
-  })
-
-  it('should emit event', async () => {
-    expect(io.emit.mock.calls[0][0]).toStrictEqual(exchange)
-  })
-
-  it('should wait for context.expected', async () => {
-    jest.clearAllMocks()
-
-    context.consumptionPromise = promex()
-
-    let resolved = false
-
-    setImmediate(() => {
-      expect(io.emit).not.toHaveBeenCalled()
-
-      resolved = true
-      context.consumptionPromise.resolve()
-    })
-
-    await step.call(context, exchange)
-
-    expect(io.emit).toHaveBeenCalled()
-    expect(resolved).toStrictEqual(true)
-  })
-})
-
-describe('When an event is emitted to the {token} exchange with properties:', () => {
-  const step = tomato.steps.Wh('an event is emitted to the {token} exchange with properties:')
-
-  it('should be', async () => undefined)
-
-  const exchange = generate()
-  const properties = { [generate()]: generate() }
-  const yaml = dump(properties)
-
-  beforeEach(async () => {
-    await step.call(context, exchange, yaml)
-  })
-
-  it('should store event', async () => {
-    expect(context.published).toBeDefined()
-  })
-
-  it('should emit event', async () => {
-    expect(io.emit).toHaveBeenCalledWith(exchange, expect.anything(), properties)
-  })
-})
-
-describe('Then {token} receives the event', () => {
-  const step = tomato.steps.Th('{token} receives the event')
-
-  const payload = randomBytes(8)
-  const group = generate()
-
-  beforeEach(() => {
-    context.consumed = { [group]: { payload } }
-  })
-
-  it('should be', async () => undefined)
-
-  it('should throw if not consumed', async () => {
-    context.published = randomBytes(8)
-
-    await expect(step.call(context, group)).rejects.toThrow(AssertionError)
-  })
-
-  it('should pass if consumed', async () => {
-    context.published = payload
-
-    await expect(step.call(context, group)).resolves.not.toThrow()
-  })
-})
-
-describe('Then {token} receives the event with properties:', () => {
-  const step = tomato.steps.Th('{token} receives the event with properties:')
-
-  it('should be', async () => undefined)
-
-  const payload = randomBytes(8)
-  const properties = { headers: { [generate()]: generate() } }
-  const yaml = dump(properties)
-  const group = generate()
-
-  beforeEach(() => {
-    context.consumed = { [group]: { payload, properties } }
-    context.published = payload
-  })
-
-  it('should throw if does not match', async () => {
-    const properties = { headers: { [generate()]: generate() } }
-    const yaml = dump(properties)
-
-    await expect(step.call(context, group, yaml)).rejects.toThrow(AssertionError)
-  })
-
-  it('should pass if matches', async () => {
-    await expect(step.call(context, group, yaml)).resolves.not.toThrow()
-  })
-})
-
-describe('Then the event is received', () => {
-  const step = tomato.steps.Th('the event is received')
-
-  const payload = randomBytes(8)
-  const group = undefined
-
-  beforeEach(() => {
-    context.consumed = { [group]: { payload } }
-  })
-
-  it('should be', async () => undefined)
-
-  it('should throw if not consumed', async () => {
-    context.published = randomBytes(8)
-
-    await expect(step.call(context, group)).rejects.toThrow(AssertionError)
-  })
-
-  it('should pass if consumed', async () => {
-    context.published = payload
-
-    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)
-
-    const callsAmountExpected = [8, 9, 10, 11]
-
-    expect(callsAmountExpected).toContain(context.io.emit.mock.calls.length)
-    expect(context.publishing).toBeDefined()
-    expect(callsAmountExpected).toContain(context.eventsPublishedCount)
-
-    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/io.mock.js

@@ -1,14 +0,0 @@
-'use strict'
-
-const { generate } = require('randomstring')
-
-const io = /** @type {jest.MockedObject<comq.IO>} */ {
-  reply: jest.fn(async () => undefined),
-  request: jest.fn(async () => generate()),
-  consume: jest.fn(async () => generate()),
-  emit: jest.fn(async () => generate()),
-  close: jest.fn(async () => undefined),
-  diagnose: jest.fn(() => undefined)
-}
-
-exports.io = io

package/features/steps/.test/poison.test.js

@@ -1,40 +0,0 @@
-'use strict'
-
-const { AssertionError } = require('node:assert')
-const tomato = require('@toa.io/tomato')
-const mock = { tomato }
-
-jest.mock('@cucumber/cucumber', () => mock.tomato)
-
-require('../poison')
-
-/** @type {comq.features.Context} */
-let context
-
-beforeEach(() => {
-  context = /** @type {comq.features.Context} */ { events: {} }
-})
-
-describe('Then the message is discarded', () => {
-  const step = tomato.steps.Th('the message is discarded')
-
-  it('should be', async () => undefined)
-
-  it('should throw if not discarded', async () => {
-    await expect(step.call(context)).rejects.toThrow(AssertionError)
-  })
-
-  it('should not throw if discarded', async () => {
-    context.events.discard = true
-
-    await expect(step.call(context)).resolves.not.toThrow()
-  })
-
-  it('should wait for discard event', async () => {
-    setTimeout(() => {
-      context.events.discard = true
-    }, 10)
-
-    await expect(step.call(context)).resolves.not.toThrow()
-  })
-})