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

Client to send events to events gateway API

const sinon = require('sinon');
const { expect } = require('chai');
const winston = require('winston');
const fs = require('fs');
const logger = require('./');

process.env.running_test = true;

describe('Logger testing', () => {
  describe('When generateLog function is called', () => {
    let findOrCreateFolderStub = {};
    let createLoggerStub = {};
    let logStub = {};
    let consoleErrorStub = {};

    const filename = 'filename';
    const service = 'service';
    const level = 'level';
    const message = 'message';
    const path = 'some path';

    const loggerResponse = {
      log: () => { }
    };

    beforeEach(() => {
      findOrCreateFolderStub = sinon.stub(logger, 'findOrCreateFolder');
      createLoggerStub = sinon
        .stub(winston, 'createLogger')
        .callsFake(() => { })
        .returns(loggerResponse);
      logStub = sinon.stub(loggerResponse, 'log');

      consoleErrorStub = sinon.stub(console, 'error');
    });

    afterEach(() => {
      findOrCreateFolderStub.restore();
      createLoggerStub.restore();
      logStub.restore();
      consoleErrorStub.restore();
    });

    it('Should calls findOrCreateFolder function once with the right params', async () => {
      await logger.generateLog(
        undefined,
        undefined,
        undefined,
        undefined,
        path
      );
      expect(findOrCreateFolderStub.calledOnce).to.be.true;
      expect(findOrCreateFolderStub.calledWith(path)).to.be.true;
    });

    it('Should calls createLogger function once', async () => {
      await logger.generateLog(filename, service, level, undefined, path);
      expect(createLoggerStub.calledOnce).to.be.true;
    });

    it('Should calls logger.log function once with the right params', async () => {
      await logger.generateLog(filename, service, level, message, path);
      expect(logStub.calledOnce).to.be.true;
      expect(logStub.calledWith({ message, level })).to.be.true;
    });

    it('should handle en print error when they occur', async () => {
      const error = 'this is an error message';
      createLoggerStub.throws(new Error(error));

      await logger.generateLog(filename, service, level, message, path);
      expect(consoleErrorStub.calledOnce).to.be.true;
      expect(consoleErrorStub.calledWith(error)).to.be.true;
    });
  });

  describe('When findOrCreateFolder function is called', () => {
    let existsSyncStub = {};
    let mkdirSyncStub = {};
    let consoleErrorStub = {};

    beforeEach(done => {
      existsSyncStub = sinon.stub(fs, 'existsSync').callsFake(() => { });
      mkdirSyncStub = sinon.stub(fs, 'mkdirSync').callsFake(() => { });
      consoleErrorStub = sinon.stub(console, 'error');
      done();
    });

    afterEach(done => {
      existsSyncStub.restore();
      mkdirSyncStub.restore();
      consoleErrorStub.restore();
      done();
    });

    it('should calls existsSync with the right params', async () => {
      const path = 'test';
      await logger.findOrCreateFolder(path);
      expect(existsSyncStub.calledOnce).to.be.true;
      expect(existsSyncStub.calledWith(path)).to.be.true;
    });

    it('should call mkdirSync when file path does not exists', async () => {
      existsSyncStub.returns(false);
      const path = 'test';
      await logger.findOrCreateFolder(path);

      expect(mkdirSyncStub.calledOnce).to.be.true;
      expect(mkdirSyncStub.calledWith(path)).to.be.true;
    });

    it('should handle errors when they occur', async () => {
      const error = 'this is an error message';
      existsSyncStub.throws(new Error(error));

      await logger.findOrCreateFolder();
      expect(consoleErrorStub.calledOnce).to.be.true;
      expect(consoleErrorStub.calledWith(error)).to.be.true;
    });
  });
});