openstapps/test/logger.spec.ts

/*
 * Copyright (C) 2018, 2019 StApps
 * This program is free software: you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the Free
 * Software Foundation, version 3.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program. If not, see <https://www.gnu.org/licenses/>.
 */
import * as chai from 'chai';
import {expect} from 'chai';
import * as chaiAsPromised from 'chai-as-promised';
import * as chaiSpies from 'chai-spies';
import {suite} from 'mocha-typescript';
import {Logger} from '../src/logger';
import {AddLogLevel} from '../src/transformations/add-log-level';
import {DummyTransport} from './dummyTransport';

chai.should();
chai.use(chaiSpies);
chai.use(chaiAsPromised);

@suite()
export class LoggerSpec {
  static sandbox: ChaiSpies.Sandbox;

  static before() {
    LoggerSpec.sandbox = chai.spy.sandbox();
  }

  before() {
    Logger.setTransformations([
      new AddLogLevel(),
    ]);
  }

  after() {
    LoggerSpec.sandbox.restore();
  }

  @test
  async 'default log level'() {
    expect((Logger as any).getLogLevel()).to.be.equal(31);
  }

  @test
  async error() {
    const spy = LoggerSpec.sandbox.on(console, 'error', () => {
      // noop
    });

    await Logger.error('Foobar');

    expect(spy).to.have.been.called();
    expect(spy.__spy.calls[0][0]).to.contain('[ERROR]');
    expect(spy.__spy.calls[0][0]).to.contain('Foobar');
  }

  @test
  async 'error in productive environment'() {
    const spy = LoggerSpec.sandbox.on(console, 'error', () => {
      // noop
    });

    const nodeEnv = process.env.NODE_ENV;
    process.env.NODE_ENV = 'production';

    await Logger.error('Foobar').should.be.rejectedWith(Error);
    expect(spy).to.have.been.called.exactly(1);

    process.env.ALLOW_NO_TRANSPORT = 'true';

    await Logger.error('Foobar').should.not.be.rejectedWith(Error);
    expect(spy).to.have.been.called.exactly(2);

    delete process.env.ALLOW_NO_TRANSPORT;

    Logger.setTransport(new DummyTransport());

    await Logger.error('Foobar').should.not.be.rejectedWith(Error);
    expect(spy).to.have.been.called.exactly(3);

    Logger.setTransport();

    process.env.NODE_ENV = nodeEnv;
  }

  @test
  async 'error without output'() {
    const spy = LoggerSpec.sandbox.on(console, 'error', () => {
      // noop
    });

    process.env.STAPPS_LOG_LEVEL = '0';

    await Logger.error('Foobar');

    delete process.env.STAPPS_LOG_LEVEL;

    expect(spy).not.to.have.been.called();
  }

  @test
  async 'error with Error'() {
    const spy = LoggerSpec.sandbox.on(console, 'error', () => {
      // noop
    });

    await Logger.error(new Error());

    expect(spy).to.have.been.called();
    expect(spy.__spy.calls[0][0]).to.contain('Error');
    expect(spy.__spy.calls[0][0]).to.contain(process.cwd());
  }

  @test
  info() {
    const spy = LoggerSpec.sandbox.on(console, 'info', () => {
      // noop
    });

    Logger.info('Foobar');

    expect(spy).to.have.been.called();
    expect(spy.__spy.calls[0][0]).to.contain('[INFO]');
    expect(spy.__spy.calls[0][0]).to.contain('Foobar');
  }

  @test
  'info without output'() {
    const spy = LoggerSpec.sandbox.on(console, 'info', () => {
      // noop
    });

    process.env.STAPPS_LOG_LEVEL = '0';

    Logger.info('Foobar');

    delete process.env.STAPPS_LOG_LEVEL;

    expect(spy).not.to.have.been.called;
  }

  @test
  initialized() {
    Logger.setTransport(new DummyTransport());

    expect(() => {
      Logger.initialized();
    }).not.to.throw();

    Logger.setTransport();
  }

  @test
  'initialized in productive environment'() {
    const nodeEnv = process.env.NODE_ENV;
    process.env.NODE_ENV = 'production';

    Logger.setTransport(new DummyTransport());

    expect(() => {
      Logger.initialized();
    }).not.to.throw();

    Logger.setTransport();

    expect(() => {
      Logger.initialized();
    }).to.throw();

    const spy = LoggerSpec.sandbox.on(console, 'warn', () => {
      // noop
    });

    process.env.ALLOW_NO_TRANSPORT = 'true';

    expect(() => {
      Logger.initialized();
    }).not.to.throw();

    delete process.env.ALLOW_NO_TRANSPORT;

    expect(spy).to.have.been.called();

    process.env.NODE_ENV = nodeEnv;
  }

  @test
  log() {
    const spy = LoggerSpec.sandbox.on(console, 'log', () => {
      // noop
    });

    Logger.log('Foobar');

    expect(spy).to.have.been.called();
    expect(spy.__spy.calls[0][0]).to.contain('[LOG]');
    expect(spy.__spy.calls[0][0]).to.contain('Foobar');
  }

  @test
  'log without output'() {
    const spy = LoggerSpec.sandbox.on(console, 'log', () => {
      // noop
    });

    process.env.STAPPS_LOG_LEVEL = '0';

    Logger.log('Foobar');

    delete process.env.STAPPS_LOG_LEVEL;

    expect(spy).to.not.have.been.called();
  }

  @test
  ok() {
    const spy = LoggerSpec.sandbox.on(console, 'log', () => {
      // noop
    });

    Logger.ok('Foobar');

    expect(spy).to.have.been.called();
    expect(spy.__spy.calls[0][0]).to.contain('[OK]');
    expect(spy.__spy.calls[0][0]).to.contain('Foobar');
  }

  @test
  'ok without output'() {
    const spy = LoggerSpec.sandbox.on(console, 'log', () => {
      // noop
    });

    process.env.STAPPS_LOG_LEVEL = '0';

    Logger.ok('Foobar');

    delete process.env.STAPPS_LOG_LEVEL;

    expect(spy).not.to.have.been.called();
  }

  @test
  setTransport() {
    expect(() => {
      Logger.setTransport(new DummyTransport());
      Logger.setTransport();
    }).not.to.throw();
  }

  @test
  'stringify'() {
    const spy = LoggerSpec.sandbox.on(console, 'log', () => {
      // noop
    });

    Logger.log('foo', 'bar');

    expect(spy).to.have.been.called();
    expect(spy.__spy.calls[0][0]).to.contain('foo');
    expect(spy.__spy.calls[0][0]).to.contain('bar');
  }

  @test
  'stringify object'() {
    const spy = LoggerSpec.sandbox.on(console, 'log', () => {
      // noop
    });

    Logger.log({
      foo: 'bar',
    });

    expect(spy).to.have.been.called();
    expect(spy.__spy.calls[0][0]).to.contain('foo');
    expect(spy.__spy.calls[0][0]).to.contain('bar');
  }

  @test
  warn() {
    const spy = LoggerSpec.sandbox.on(console, 'warn', () => {
      // noop
    });

    Logger.warn('Foobar');

    expect(spy).to.have.been.called();
    expect(spy.__spy.calls[0][0]).to.contain('[WARN]');
    expect(spy.__spy.calls[0][0]).to.contain('Foobar');
  }

  @test
  'warn without output'() {
    const spy = LoggerSpec.sandbox.on(console, 'warn', () => {
      // noop
    });

    process.env.STAPPS_LOG_LEVEL = '0';

    Logger.warn('Foobar');

    delete process.env.STAPPS_LOG_LEVEL;

    expect(spy).not.to.have.been.called();
  }

  @test
  getLogLevel() {
    const savedProcess = process;

    // @ts-ignore
    process = undefined;

    (global as any).window = {
      STAPPS_LOG_LEVEL: 0,
    };

    const stub = LoggerSpec.sandbox.on(console, 'info', () => {
      // noop
    });

    Logger.info('Foobar');

    process = savedProcess;

    delete (global as any).window;

    expect(stub).not.to.have.been.called();
  }

  @test
  'output without transformations'() {
    Logger.setTransformations([]);

    const stub = LoggerSpec.sandbox.on(console, 'log', () => {
      // noop
    });
    const applyTransformationsSpy = LoggerSpec.sandbox.on(Logger, 'applyTransformations');

    Logger.log('Foobar');

    expect(stub).to.have.been.called.with('Foobar');
    expect(applyTransformationsSpy).not.to.have.been.called;
  }
}