iamqp/src/test/tests/common_class_tests.js

RabbitMQ wrapper for NodeJS with several produce(reply)/consume scenarios

const CommonClass = require('../../../src/main/common')
const assert = require('chai').assert
const lodash = require('lodash')

function fanoutTest () {
  const amqpURL = 'amqp://localhost'
  const commonClass = new CommonClass(amqpURL, 'common-class-test')

  describe('CommonClass openConnection', () => {
    const commonClass = new CommonClass(amqpURL, 'common-class-test-a')

    it('should not be ready', () => {
      assert.strictEqual(commonClass.isReady(), false)
    })

    it('should open the connection', (pDone) => {
      commonClass.openConnection()
      setTimeout(() => {
        assert.strictEqual(commonClass.isReady(), true)
        pDone()
      }, 500)
    }).timeout(1100)

    it('should close the connection', (pDone) => {
      assert.strictEqual(commonClass.closeConnection(), true)
      setTimeout(() => {
        assert.strictEqual(commonClass.isReady(), false)
        pDone()
      }, 1000)
    }).timeout(1100)
  })

  describe('CommonClass _parseConsumedMessage', () => {
    it('should parse string', () => {
      const data = 'test-string'
      assert.strictEqual(commonClass._parseConsumedMessage({
        content: Buffer.from(JSON.stringify(data))
      }), data)
    })

    it('should parse number', () => {
      const data = 10
      assert.strictEqual(commonClass._parseConsumedMessage({
        content: Buffer.from(JSON.stringify(data))
      }), data)
    })

    it('should parse boolean', () => {
      const data = true
      assert.strictEqual(commonClass._parseConsumedMessage({
        content: Buffer.from(JSON.stringify(data))
      }), data)
    })

    it('should parse Object', () => {
      const data = {
        a: 1
      }
      assert.deepEqual(commonClass._parseConsumedMessage({
        content: Buffer.from(JSON.stringify(data))
      }), data)
    })

    it('should parse Array', () => {
      const data = [1, 'test']
      assert.deepEqual(commonClass._parseConsumedMessage({
        content: Buffer.from(JSON.stringify(data))
      }), data)
    })

    it('should not parse - not buffer', () => {
      const data = [1, 'test']
      assert.deepEqual(commonClass._parseConsumedMessage({
        content: data
      }), null)
    })

    it('should not parse - missing key', () => {
      assert.deepEqual(commonClass._parseConsumedMessage({}), null)
    })
  })

  describe('CommonClass _preparePublishingMessage', () => {
    it('should parse string', () => {
      assert.strictEqual(lodash.isBuffer(commonClass._preparePublishingMessage('test-string')), true)
    })

    it('should parse number', () => {
      assert.strictEqual(lodash.isBuffer(commonClass._preparePublishingMessage(10)), true)
    })

    it('should parse boolean', () => {
      assert.strictEqual(lodash.isBuffer(commonClass._preparePublishingMessage(true)), true)
    })

    it('should parse Object', () => {
      assert.strictEqual(lodash.isBuffer(commonClass._preparePublishingMessage({
        a: 1
      })), true)
    })

    it('should parse Array', () => {
      assert.strictEqual(lodash.isBuffer(commonClass._preparePublishingMessage([1, 'test'])), true)
    })
  })
}

module.exports.run = fanoutTest