@condor-labs/ec-events-gateway/src/events/events.test.js

Client to send events to events gateway API

require('dotenv').config();
const axios = require('@condor-labs/axios');
const sinon = require('sinon');
const { expect } = require('chai');
const dateFns = require('date-fns');
const mockDate = require('mockdate');
const logger = require('../logger');
const validate = require('../validate');
const events = require('./events');

const {
  URL_REQUIRED,
  PAYLOAD_REQUIRED,
  PATH,
  DATE_FORMAT
} = require('../utils/constants');

describe('Events module', () => {
  describe('When save function is called', () => {
    let validateParamsStub = {},
      formatDataStub = {},
      validateDataStub = {},
      axiosStub = {},
      formatDateStub = {},
      createLoggerStub = {};

    beforeEach(() => {
      validateParamsStub = sinon.stub(validate, 'validateParams');
      formatDataStub = sinon.stub(validate, 'formatData');
      validateDataStub = sinon.stub(validate, 'validateData');
      axiosStub = sinon.stub(axios, 'post');
      formatDateStub = sinon.stub(dateFns, 'format');
      createLoggerStub = sinon.stub(logger, 'generateLog');
    });

    afterEach(() => {
      validateParamsStub.restore();
      formatDataStub.restore();
      validateDataStub.restore();
      axiosStub.restore();
      formatDateStub.restore();
      createLoggerStub.restore();
    });

    const fakeParams = {
      type: 'AUDIT_LOGS',
      payload: {},
      topic: 'topicfake',
      url: 'www.fake.com'
    };

    it('Should calls validateParams function once with the right params', async () => {
      process.env.EVENTS_GATEWAY_URL = 'http://localhost';
      const { topic, type, payload } = fakeParams;

      const data = {
        topic,
        type,
        data: payload
      };

      await events.save(fakeParams);

      expect(validateParamsStub.calledOnce).to.be.true;
      expect(validateParamsStub.calledWith(data, null)).to.be.true;
    });

    it('Should returns errors when validateParams function returns any error', async () => {
      const errors = { error: PAYLOAD_REQUIRED };
      validateParamsStub.returns(errors);

      const result = await events.save(fakeParams);

      expect(result).to.be.deep.equal(errors);
    });

    it(`Should returns an object with an error property with the message '${URL_REQUIRED}' when not url is provided via params or environment variable`, async () => {
      delete process.env.EVENTS_GATEWAY_URL;
      delete fakeParams.url;

      const expectedError = { error: URL_REQUIRED };
      const result = await events.save(fakeParams);

      expect(result).to.be.deep.equal(expectedError);
    });

    it('Should calls validate.formatData function once with the right params', async () => {
      process.env.EVENTS_GATEWAY_URL = 'http://localhost';
      const { topic, type, payload } = fakeParams;

      const data = {
        topic,
        type,
        data: payload
      };

      await events.save(fakeParams);
      expect(formatDataStub.calledOnce).to.be.true;
      expect(formatDataStub.calledWith(data)).to.be.true;
    });

    it('Should calls validate.validateData function once with the right params', async () => {
      const { topic, type, payload } = fakeParams;
      const formattedData = {
        topic,
        message: payload,
        messageAttributes: {
          name: 'event',
          dataType: 'String',
          type
        }
      };

      formatDataStub.returns(formattedData);

      await events.save(fakeParams);
      expect(validateDataStub.calledOnce).to.be.true;
      expect(validateDataStub.calledWith(formattedData)).to.be.true;
    });

    it('Should returns an object with an error when some error returned from validateData function', async () => {
      const expectedError = { error: 'some error' };
      validateDataStub.returns(expectedError);

      const result = await events.save(fakeParams);

      expect(result).to.be.deep.equal(expectedError);
    });

    it('Should calls axios.post function once with the right params', async () => {
      const { topic, type, payload } = fakeParams;
      const formattedData = {
        topic,
        message: payload,
        messageAttributes: {
          name: 'event',
          dataType: 'String',
          type
        }
      };

      formatDataStub.returns(formattedData);
      validateDataStub.returns(null);

      await events.save(fakeParams);
      expect(axiosStub.calledOnce).to.be.true;
      expect(
        axiosStub.calledWith(process.env.EVENTS_GATEWAY_URL, formattedData, {
          headers: {}
        })
      ).to.be.true;
    });

    it('Should return the response from the request send by axios', async () => {
      const { topic, type, payload } = fakeParams;
      const formattedData = {
        topic,
        message: payload,
        messageAttributes: {
          name: 'event',
          dataType: 'String',
          type
        }
      };

      const expectedResponse = { statusCode: 200 };

      formatDataStub.returns(formattedData);
      validateDataStub.returns(null);
      axiosStub.returns(Promise.resolve(expectedResponse));

      const response = await events.save(fakeParams);

      expect(response).to.be.deep.equal(expectedResponse);

    });

    it('Should calls dateFns.format function once with the right params when an error occurs', async () => {
      mockDate.set(1687989261397);
      const error = 'some error';
      validateParamsStub.throws(new Error(error));

      await events.save(fakeParams);

      expect(formatDateStub.calledOnce).to.be.true;
      expect(formatDateStub.calledWith(new Date(), DATE_FORMAT)).to.be.true;
      mockDate.reset();
    });

    it('Should calls logger.generateLog function once with the right params when an error occurs', async () => {
      const error = 'some error';
      const filename = 'filename.log';

      validateParamsStub.throws(new Error(error));
      formatDateStub.returns(filename);

      await events.save(fakeParams);

      expect(createLoggerStub.calledOnce).to.be.true;
      expect(
        createLoggerStub.calledWith(
          filename,
          fakeParams.type,
          'error',
          JSON.stringify(error),
          PATH
        )
      ).to.be.true;
    });
  });
});