roarr/dist/test/roarr/roarr.js

"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const ava_1 = __importStar(require("ava"));
const globalthis_1 = __importDefault(require("globalthis"));
const createLogger_1 = require("../../src/factories/createLogger");
const createRoarrInitialGlobalState_1 = require("../../src/factories/createRoarrInitialGlobalState");
const time = -1;
const version = '2.0.0';
(0, ava_1.beforeEach)(() => {
    const globalThis = (0, globalthis_1.default)();
    globalThis.ROARR = (0, createRoarrInitialGlobalState_1.createRoarrInitialGlobalState)({});
});
const createLoggerWithHistory = () => {
    const messages = [];
    const log = (0, createLogger_1.createLogger)((message) => {
        messages.push({
            ...message,
            time,
        });
    });
    log.messages = messages;
    return log;
};
(0, ava_1.default)('creates a simple message', (t) => {
    const log = createLoggerWithHistory();
    log('foo');
    t.deepEqual(log.messages, [
        {
            context: {},
            message: 'foo',
            sequence: '0',
            time,
            version,
        },
    ]);
});
(0, ava_1.default)('logs an empty message when first parameter is an object and the second parameter is undefined', (t) => {
    const log = createLoggerWithHistory();
    // @ts-expect-error Invalid invocation
    log({});
    t.deepEqual(log.messages, [
        {
            context: {},
            message: '',
            sequence: '0',
            time,
            version,
        },
    ]);
});
(0, ava_1.default)('throws in case of invalid invocation', (t) => {
    const log = createLoggerWithHistory();
    t.throws(() => {
        // @ts-expect-error Invalid invocation
        log({}, {});
    }, {
        message: 'Message must be a string. Received object.',
    });
});
(0, ava_1.default)('throws in case of invalid invocation (2)', (t) => {
    const log = createLoggerWithHistory();
    t.throws(() => {
        // @ts-expect-error Invalid invocation
        log('test', 123);
    });
});
(0, ava_1.default)('formats message using sprintf', (t) => {
    const log = createLoggerWithHistory();
    log('foo %s', 'bar');
    t.deepEqual(log.messages, [
        {
            context: {},
            message: 'foo bar',
            sequence: '0',
            time,
            version,
        },
    ]);
});
(0, ava_1.default)('formats message using sprintf (multiple variables)', (t) => {
    const log = createLoggerWithHistory();
    log('foo %s %s %s', 'bar', 'baz', 'qux');
    t.deepEqual(log.messages, [
        {
            context: {},
            message: 'foo bar baz qux',
            sequence: '0',
            time,
            version,
        },
    ]);
});
(0, ava_1.default)('formats message using sprintf (digit variables)', (t) => {
    const log = createLoggerWithHistory();
    log('foo %d %d %d', '1', '2', '3');
    t.deepEqual(log.messages, [
        {
            context: {},
            message: 'foo 1 2 3',
            sequence: '0',
            time,
            version,
        },
    ]);
});
(0, ava_1.default)('creates message with a context', (t) => {
    const log = createLoggerWithHistory();
    log({
        foo: 'bar',
    }, 'baz');
    t.deepEqual(log.messages, [
        {
            context: {
                foo: 'bar',
            },
            message: 'baz',
            sequence: '0',
            time,
            version,
        },
    ]);
});
(0, ava_1.default)('formats message using sprintf (with context)', (t) => {
    const log = createLoggerWithHistory();
    log({
        foo: 'bar',
    }, 'baz %s', 'qux');
    t.deepEqual(log.messages, [
        {
            context: {
                foo: 'bar',
            },
            message: 'baz qux',
            sequence: '0',
            time,
            version,
        },
    ]);
});
(0, ava_1.default)('creates logger with a context', (t) => {
    const log = createLoggerWithHistory();
    log.child({ foo: 'bar' })('baz');
    t.deepEqual(log.messages, [
        {
            context: {
                foo: 'bar',
            },
            message: 'baz',
            sequence: '0',
            time,
            version,
        },
    ]);
});
(0, ava_1.default)('prepends context to the message context', (t) => {
    const log = createLoggerWithHistory();
    log.child({ foo: 'bar' })({ baz: 'qux' }, 'quux');
    t.deepEqual(log.messages, [
        {
            context: {
                baz: 'qux',
                foo: 'bar',
            },
            message: 'quux',
            sequence: '0',
            time,
            version,
        },
    ]);
});
(0, ava_1.default)('prepends context to the message context (is overridden)', (t) => {
    const log = createLoggerWithHistory();
    log.child({ foo: 'bar 0' })({ foo: 'bar 1' }, 'quux');
    t.deepEqual(log.messages, [
        {
            context: {
                foo: 'bar 1',
            },
            message: 'quux',
            sequence: '0',
            time,
            version,
        },
    ]);
});
(0, ava_1.default)('appends context to the previous child context', (t) => {
    const log = createLoggerWithHistory();
    log.child({ foo: 'bar' }).child({ baz: 'qux' })('quux');
    t.deepEqual(log.messages, [
        {
            context: {
                baz: 'qux',
                foo: 'bar',
            },
            message: 'quux',
            sequence: '0',
            time,
            version,
        },
    ]);
});
(0, ava_1.default)('appends context to the previous child context (overrides)', (t) => {
    const log = createLoggerWithHistory();
    log.child({ foo: 'bar 0' }).child({ foo: 'bar 1' })('qux');
    t.deepEqual(log.messages, [
        {
            context: {
                foo: 'bar 1',
            },
            message: 'qux',
            sequence: '0',
            time,
            version,
        },
    ]);
});
(0, ava_1.default)('translates child message', (t) => {
    const log = createLoggerWithHistory();
    log
        .child((message) => {
        return {
            ...message,
            message: message.message + 'bar',
        };
    })('foo');
    t.deepEqual(log.messages, [
        {
            context: {},
            message: 'foobar',
            sequence: '0',
            time,
            version,
        },
    ]);
});
(0, ava_1.default)('serializes context using a transformer', (t) => {
    const log = createLoggerWithHistory();
    const log1 = log.child((message) => {
        if (!message.context.error1) {
            return message;
        }
        return {
            ...message,
            context: {
                ...message.context,
                error1: 'log1 error',
            },
        };
    });
    log1.error({
        error1: new Error('foo'),
    }, 'log1');
    // @ts-expect-error error2 is not allowed
    log1.error({
        error2: new Error('foo'),
    }, 'log1');
    const log2 = log1.child((message) => {
        return {
            ...message,
            context: {
                ...message.context,
                error2: 'log2 error',
            },
        };
    });
    log2.error({
        error1: new Error('foo'),
        error2: new Error('foo'),
    }, 'log2');
    // @ts-expect-error error2 is not allowed
    log2.error({
        error3: new Error('foo'),
    }, 'log2');
    t.like(log.messages[0], {
        context: {
            error1: 'log1 error',
        },
        message: 'log1',
    });
    t.like(log.messages[1], {
        context: {
            error2: new Error('foo'),
        },
        message: 'log1',
    });
    t.like(log.messages[2], {
        context: {
            error1: 'log1 error',
            error2: 'log2 error',
        },
        message: 'log2',
    });
    t.like(log.messages[3], {
        context: {
            error3: new Error('foo'),
        },
        message: 'log2',
    });
});
(0, ava_1.default)('does not allow to extend context without a transformer', (t) => {
    const log = createLoggerWithHistory();
    // @ts-expect-error cannot type child without a translator
    log.child({});
    log.child({});
    t.true(true);
});
(0, ava_1.default)('throws an error if child does not return an object', (t) => {
    const log = createLoggerWithHistory();
    t.throws(() => {
        log
            // @ts-expect-error result must be an object
            .child(() => {
            return '';
        })('foo');
    }, {
        message: 'Message transform function must return a message object.',
    });
});
(0, ava_1.default)('convenience methods trace, debug, info, warn, error and fatal prepend a logLevel property', (t) => {
    const log = createLoggerWithHistory();
    log.trace('foo 0');
    log.debug('foo 1');
    log.info('foo 2');
    log.warn('foo 3');
    log.error('foo 4');
    log.fatal('foo 5');
    t.deepEqual(log.messages, [
        {
            context: {
                logLevel: 10,
            },
            message: 'foo 0',
            sequence: '0',
            time,
            version,
        },
        {
            context: {
                logLevel: 20,
            },
            message: 'foo 1',
            sequence: '1',
            time,
            version,
        },
        {
            context: {
                logLevel: 30,
            },
            message: 'foo 2',
            sequence: '2',
            time,
            version,
        },
        {
            context: {
                logLevel: 40,
            },
            message: 'foo 3',
            sequence: '3',
            time,
            version,
        },
        {
            context: {
                logLevel: 50,
            },
            message: 'foo 4',
            sequence: '4',
            time,
            version,
        },
        {
            context: {
                logLevel: 60,
            },
            message: 'foo 5',
            sequence: '5',
            time,
            version,
        },
    ]);
});
(0, ava_1.default)('does not produce an error when message contains % without an associated parameter', (t) => {
    const log = createLoggerWithHistory();
    log.trace('http://commons.wikimedia.org/wiki/Special:FilePath/Cucumis%20anguria.JPG');
    t.deepEqual(log.messages, [
        {
            context: {
                logLevel: 10,
            },
            message: 'http://commons.wikimedia.org/wiki/Special:FilePath/Cucumis%20anguria.JPG',
            sequence: '0',
            time,
            version,
        },
    ]);
});