test: adjust tests

test/logger.spec.ts

@@ -0,0 +1,314 @@
+/*
+ * 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 {slow, suite, timeout} from 'mocha-typescript';
+import {Logger} from '../src/logger';
+import {DummyTransport} from './dummyTransport';
+
+chai.should();
+chai.use(chaiSpies);
+chai.use(chaiAsPromised);
+
+@suite(timeout(2000), slow(1000))
+export class LoggerSpec {
+  static sandbox: any;
+
+  static before() {
+    LoggerSpec.sandbox = chai.spy.sandbox();
+  }
+
+  before() {
+    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', () => {
+    });
+
+    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', () => {
+    });
+
+    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', () => {
+    });
+
+    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', () => {
+    });
+
+    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', () => {
+    });
+
+    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', () => {
+    });
+
+    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', () => {
+    });
+
+    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', () => {
+    });
+
+    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', () => {
+    });
+
+    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', () => {
+    });
+
+    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', () => {
+    });
+
+    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', () => {
+    });
+
+    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', () => {
+    });
+
+    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', () => {
+    });
+
+    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', () => {
+    });
+
+    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', () => {
+    });
+
+    Logger.info('Foobar');
+
+    process = savedProcess;
+
+    delete (global as any).window;
+
+    expect(stub).not.to.have.been.called();
+  }
+}