comq 0.10.0 → 0.10.2

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

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

@@ -1,261 +0,0 @@
-'use strict'
-
-const { AssertionError } = require('node:assert')
-const { generate } = require('randomstring')
-const { promex, timeout } = require('@toa.io/generic')
-const { dump } = require('@toa.io/yaml')
-const tomato = require('@toa.io/tomato')
-const { io } = require('./io.mock')
-const mock = { tomato }
-
-jest.mock('@cucumber/cucumber', () => mock.tomato)
-
-require('../rpc')
-
-/** @type {comq.features.Context} */
-let context
-
-const queue = generate()
-
-beforeEach(() => {
-  jest.clearAllMocks()
-
-  context = /** @type {comq.features.Context} */ { io }
-})
-
-describe('Given function replying {token} queue:', () => {
-  const step = tomato.steps.Gi('function replying {token} queue:')
-
-  it('should be', () => undefined)
-
-  it('should assign given function as producer', async () => {
-    const javascript = '({ a, b }) => a + b'
-
-    await step.call(context, queue, javascript)
-
-    expect(io.reply).toHaveBeenCalledWith(queue, expect.any(Function))
-
-    const producer = io.reply.mock.calls[0][1]
-    const sum = producer({ a: 1, b: 2 })
-
-    expect(sum).toStrictEqual(3)
-  })
-})
-
-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:')
-
-  it('should be', () => undefined)
-})
-
-describe('When the consumer sends the following request to the {token} queue:', () => {
-  const step = tomato.steps.Wh('the consumer sends the following request to the {token} queue:')
-
-  it('should be', async () => undefined)
-
-  const payload = { [generate()]: generate() }
-  const yaml = dump(payload)
-
-  beforeEach(async () => {
-    await step.call(context, queue, yaml)
-  })
-
-  it('should send request', async () => {
-    expect(io.request).toHaveBeenCalledWith(queue, payload)
-  })
-
-  it('should store reply promise', async () => {
-    const reply = await io.request.mock.results[0].value
-
-    expect(await context.reply).toStrictEqual(reply)
-  })
-
-  it('should wait for context.expected', async () => {
-    context.expected = promex()
-
-    let completed = false
-
-    setImmediate(() => {
-      expect(completed).toStrictEqual(false)
-
-      completed = true
-
-      context.expected.resolve()
-    })
-
-    await step.call(context, queue, yaml)
-
-    expect(completed).toStrictEqual(true)
-  })
-})
-
-describe('When the consumer sends a request to the {token} queue', () => {
-  const step = tomato.steps.Wh('the consumer sends a request to the {token} queue')
-
-  it('should be', async () => undefined)
-
-  it('should send request', async () => {
-    await step.call(context, queue)
-
-    expect(io.request).toHaveBeenCalledWith(queue, expect.any(Buffer))
-  })
-})
-
-describe('Then the consumer receives the reply:', () => {
-  const step = tomato.steps.Th('the consumer receives the reply:')
-
-  it('should be', async () => undefined)
-
-  const replies = [
-    ['primitive', generate()],
-    ['object', { ok: 1 }],
-    ['array', [1, 'foo']]
-  ]
-
-  describe.each(replies)('%s reply comparison', (type, value) => {
-    let yaml
-
-    beforeEach(() => {
-      yaml = dump(value)
-    })
-
-    it('should throw if differ', async () => {
-      const promise = promex()
-
-      context.reply = promise
-      promise.resolve(generate())
-
-      await expect(step.call(context, yaml)).rejects.toThrow(AssertionError)
-    })
-
-    it('should pass if equals', async () => {
-      const promise = promex()
-
-      context.reply = promise
-
-      promise.resolve(value)
-
-      await expect(step.call(context, yaml)).resolves.not.toThrow()
-    })
-  })
-})
-
-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')
-
-  it('should be', async () => undefined)
-
-  it('should throw if reply is received within 50ms', async () => {
-    context.reply = promex()
-
-    setTimeout(() => {
-      context.reply.resolve(generate())
-    }, 10)
-
-    await expect(step.call(context)).rejects.toThrow(AssertionError)
-  })
-
-  it('should not throw if reply is not received', async () => {
-    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 + 12)
-
-    const callsAmountExpected = [9, 10, 11, 12]
-
-    expect(callsAmountExpected).toContain(context.io.request.mock.calls.length)
-    expect(context.sending).toBeDefined()
-    expect(callsAmountExpected).toContain(context.requestsSent.length)
-
-    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)
-  })
-})