SymphonyElectron/spec/log.spec.ts

import * as os from 'os';

jest.mock('../src/common/utils.ts', () => {
  return {
    getCommandLineArgs: jest.fn(() => os.tmpdir()),
  };
});

jest.mock('../src/common/env', () => {
  return {
    isElectronQA: false,
  };
});

jest.mock('electron-log');

describe('logger', () => {
  let instance;
  beforeEach(() => {
    // I did it for reset module imported between tests
    const { logger } = require('../src/common/logger');
    instance = logger;
    jest.resetModules();
  });

  it('when no logger registered then queue items', () => {
    instance.debug('test');
    instance.debug('test2');
    const queue = instance.getLogQueue();
    expect(queue.length).toBe(2);
  });

  it('should call send when logger get registered', () => {
    instance.debug('test');
    instance.debug('test2');

    const mock = jest.fn<Electron.WebContents>(() => ({
      send: jest.fn(),
    }));
    const mockWin = new mock();
    instance.setLoggerWindow(mockWin);
    expect(mockWin.send).toHaveBeenCalled();
  });

  it('should call `logger.error` correctly', () => {
    const spy = jest.spyOn(instance, 'log');
    instance.error('test error', { error: 'test error' });
    expect(spy).toBeCalledWith('error', 'test error', [
      { error: 'test error' },
    ]);
  });

  it('should call `logger.warn` correctly', () => {
    const spy = jest.spyOn(instance, 'log');
    instance.warn('test warn', { warn: 'test warn' });
    expect(spy).toBeCalledWith('warn', 'test warn', [{ warn: 'test warn' }]);
  });

  it('should call `logger.debug` correctly', () => {
    const spy = jest.spyOn(instance, 'log');
    instance.debug('test debug', { debug: 'test debug' });
    expect(spy).toBeCalledWith('debug', 'test debug', [
      { debug: 'test debug' },
    ]);
  });

  it('should call `logger.info` correctly', () => {
    const spy = jest.spyOn(instance, 'log');
    instance.info('test info', { info: 'test info' });
    expect(spy).toBeCalledWith('info', 'test info', [{ info: 'test info' }]);
  });

  it('should call `logger.verbose` correctly', () => {
    const spy = jest.spyOn(instance, 'log');
    instance.verbose('test verbose', { verbose: 'test verbose' });
    expect(spy).toBeCalledWith('verbose', 'test verbose', [
      { verbose: 'test verbose' },
    ]);
  });

  it('should call `logger.silly` correctly', () => {
    const spy = jest.spyOn(instance, 'log');
    instance.silly('test silly', { silly: 'test silly' });
    expect(spy).toBeCalledWith('silly', 'test silly', [
      { silly: 'test silly' },
    ]);
  });

  it('should call `logger.sendToCloud` when `logger.debug` is called', () => {
    const spyLog = jest.spyOn(instance, 'log');
    const spySendToCloud = jest.spyOn(instance, 'sendToCloud');
    instance.debug('test');
    expect(spyLog).toBeCalled();
    expect(spySendToCloud).toBeCalled();
  });

  it('should cap at 100 queued log messages', () => {
    for (let i = 0; i < 110; i++) {
      instance.debug('test' + i);
    }
    const queue = instance.getLogQueue();
    expect(queue.length).toBe(100);
  });
});