mirror of
https://gitlab.com/openstapps/openstapps.git
synced 2025-12-11 08:46:16 +00:00
483 lines
11 KiB
TypeScript
483 lines
11 KiB
TypeScript
/*
|
|
* Copyright (C) 2018, 2020 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 chai from 'chai';
|
|
import {expect} from 'chai';
|
|
import chaiAsPromised from 'chai-as-promised';
|
|
import chaiSpies from 'chai-spies';
|
|
import {suite, test} from '@testdeck/mocha';
|
|
import {Logger} from '../src/logger';
|
|
import {AddLogLevel} from '../src/transformations/add-log-level';
|
|
import {Colorize} from '../src/transformations/colorize';
|
|
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).getLevel('LOG')).to.be.equal(31);
|
|
expect((Logger as any).getLevel('EXIT')).to.be.equal(0);
|
|
}
|
|
|
|
@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
|
|
async exits() {
|
|
const infoSpy = LoggerSpec.sandbox.on(console, 'info', () => {
|
|
// noop
|
|
});
|
|
const logSpy = LoggerSpec.sandbox.on(console, 'log', () => {
|
|
// noop
|
|
});
|
|
const warnSpy = LoggerSpec.sandbox.on(console, 'warn', () => {
|
|
// noop
|
|
});
|
|
const errorSpy = LoggerSpec.sandbox.on(console, 'error', () => {
|
|
// noop
|
|
});
|
|
const processSpy = LoggerSpec.sandbox.on(process, 'exit', () => {
|
|
// noop
|
|
});
|
|
|
|
const exitLevel = process.env.STAPPS_EXIT_LEVEL;
|
|
process.env.STAPPS_EXIT_LEVEL = '31';
|
|
|
|
Logger.info('Foobar');
|
|
Logger.log('Foobar');
|
|
Logger.warn('Foobar');
|
|
Logger.ok('Foobar');
|
|
await Logger.error('Foobar');
|
|
|
|
expect(infoSpy).to.have.been.called.once;
|
|
expect(infoSpy.__spy.calls[0][0]).to.contain('[INFO]');
|
|
expect(infoSpy.__spy.calls[0][0]).to.contain('Foobar');
|
|
|
|
expect(logSpy).to.have.been.called.twice;
|
|
|
|
expect(warnSpy).to.have.been.called.once;
|
|
expect(warnSpy.__spy.calls[0][0]).to.contain('[WARN]');
|
|
expect(warnSpy.__spy.calls[0][0]).to.contain('Foobar');
|
|
|
|
expect(errorSpy).to.have.been.called.exactly(6);
|
|
|
|
expect(processSpy).to.have.been.called.exactly(5);
|
|
|
|
process.env.STAPPS_EXIT_LEVEL = exitLevel;
|
|
}
|
|
|
|
@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
|
|
'is compatible with log aggregation in productive environment'() {
|
|
Logger.setTransformations([new AddLogLevel(), new Colorize()]);
|
|
|
|
let spy = LoggerSpec.sandbox.on(console, 'log', () => {
|
|
// noop
|
|
});
|
|
|
|
Logger.log('Foo\nbar');
|
|
|
|
expect(spy).to.have.been.called.once;
|
|
expect(spy.__spy.calls[0][0]).to.equal('\u001B[37m[LOG] Foo\u001B[39m\n\u001B[37mbar\u001B[39m');
|
|
|
|
const nodeEnv = process.env.NODE_ENV;
|
|
process.env.NODE_ENV = 'production';
|
|
process.env.ALLOW_NO_TRANSPORT = 'true';
|
|
|
|
Logger.setTransformations([new AddLogLevel(), new Colorize()]);
|
|
|
|
Logger.log('Foo\nbar');
|
|
|
|
expect(spy).to.have.been.called.twice;
|
|
expect(spy.__spy.calls[1][0]).to.equal('[LOG] Foo bar');
|
|
|
|
process.env.NODE_ENV = nodeEnv;
|
|
delete process.env.ALLOW_NO_TRANSPORT;
|
|
}
|
|
|
|
@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
|
|
'log level exclusiveness'() {
|
|
const warnSpy = LoggerSpec.sandbox.on(console, 'warn', () => {
|
|
// noop WARN
|
|
});
|
|
const infoSpy = LoggerSpec.sandbox.on(console, 'info', () => {
|
|
// noop INFO
|
|
});
|
|
const okSpy = LoggerSpec.sandbox.on(console, 'log', () => {
|
|
// noop OK
|
|
});
|
|
|
|
// only warn and info = warn + info = 4 + 1 = 5
|
|
process.env.STAPPS_LOG_LEVEL = '5';
|
|
|
|
Logger.warn('Foo');
|
|
Logger.info('Bar');
|
|
Logger.ok('Baz');
|
|
|
|
expect(warnSpy).to.have.been.called();
|
|
expect(warnSpy.__spy.calls[0][0]).to.contain('[WARN]');
|
|
expect(warnSpy.__spy.calls[0][0]).to.contain('Foo');
|
|
|
|
expect(infoSpy).to.have.been.called();
|
|
expect(infoSpy.__spy.calls[0][0]).to.contain('[INFO]');
|
|
expect(infoSpy.__spy.calls[0][0]).to.contain('Bar');
|
|
|
|
expect(okSpy).to.not.have.been.called();
|
|
|
|
delete process.env.STAPPS_LOG_LEVEL;
|
|
}
|
|
|
|
@test
|
|
getExitLevel() {
|
|
const savedProcess = process;
|
|
|
|
// @ts-ignore
|
|
process = undefined;
|
|
|
|
(global as any).window = {
|
|
STAPPS_EXIT_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
|
|
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(new Logger(), 'applyTransformations');
|
|
|
|
Logger.log('Foobar');
|
|
|
|
expect(stub).to.have.been.called.with('Foobar');
|
|
expect(applyTransformationsSpy).not.to.have.been.called;
|
|
}
|
|
}
|