llamajs/dist/transports/file/file.transport.spec.js

A dynamic logger for the dynamic developer

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const chai_1 = require("chai");
const mockFs = require("mock-fs");
const fs = require("fs");
const file_transport_1 = require("../file/file.transport");
const severityLevels_1 = require("../../severityLevels/severityLevels");
const formats_1 = require("../../formats/formats");
const fileName = 'test_file_transport.txt';
const fileTransportConfigNewLine = {
    fileName,
    noNewLine: false,
    format: new formats_1.CsvFormat(),
    levels: [
        severityLevels_1.syslogSeverityLevels[6],
        severityLevels_1.syslogSeverityLevels[1],
    ],
};
const fileTransportConfigNoNewLine = {
    fileName,
    format: new formats_1.CsvFormat(),
    noNewLine: true,
    levels: [
        severityLevels_1.syslogSeverityLevels[6],
        severityLevels_1.syslogSeverityLevels[1],
    ],
};
const validAlertMessage = {
    name: 'validAlert',
    severity: severityLevels_1.syslogSeverityLevels[6],
};
const validInfoMessage = {
    name: 'validInfo',
    severity: severityLevels_1.syslogSeverityLevels[1],
};
const invalidMessage = {
    name: 'invalid',
    severity: severityLevels_1.IbmTivoliSeverityLevels[0],
};
describe('File Transport Module', function () {
    describe('#pass()', function () {
        let fileTransport;
        context('When all values are valid', function () {
            context('On noNewLine set to false', function () {
                beforeEach(function () {
                    fileTransport = new file_transport_1.FileTransport(fileTransportConfigNewLine);
                    mockFs();
                });
                it('Should write a single messages to the file with newline', async function () {
                    await fileTransport.send(validAlertMessage);
                    const fileString = fs.readFileSync(fileName, 'UTF8');
                    chai_1.expect(fileString)
                        .to
                        .equal(new formats_1.CsvFormat().getMessage(validAlertMessage) + '\n');
                });
                /*
                    This test case works on the file system, however, mock-fs
                    has a problem with promises since node > 10.4.1
                    Issue number 245: https://github.com/tschaub/mock-fs/issues/245
                */
                /*
                 it(
                     'Should write multiple messages in seperate lines in the file',
                     async function () {
                         await fileTransport.send(validInfoMessage);
                         await fileTransport.send(validAlertMessage);

                         const fileStringArray = fs.readFileSync(fileName, 'UTF8')
                             .toString()
                             .split('\n');

                         expect(fileStringArray[0])
                             .to
                             .equal(new CsvFormat().getMessage(validInfoMessage));
                         expect(fileStringArray[1])
                             .to
                             .equal(new CsvFormat().getMessage(validAlertMessage));
                     });
                     */
                afterEach(function () {
                    mockFs.restore();
                });
            });
            context('On noNewLine set to true', function () {
                beforeEach(function () {
                    fileTransport = new file_transport_1.FileTransport(fileTransportConfigNoNewLine);
                    mockFs();
                });
                it('Should write a single messages to the file without newline', async function () {
                    await fileTransport.send(validAlertMessage);
                    const fileString = fs.readFileSync(fileName, 'UTF8');
                    chai_1.expect(fileString)
                        .to
                        .equal(new formats_1.CsvFormat().getMessage(validAlertMessage));
                });
                /*
                    This test case works on the file system, however, mock-fs
                    has a problem with promises since node > 10.4.1
                    Issue number 245: https://github.com/tschaub/mock-fs/issues/245
                */
                /*
                 it(
                     'Should write multiple messages in seperate lines in the file',
                     async function () {
                         await fileTransport.send(validInfoMessage);
                         await fileTransport.send(validAlertMessage);

                         const fileString = fs.readFileSync(fileName, 'UTF8');

                         expect(fileString)
                             .to
                             .equal(new CsvFormat().getMessage(validInfoMessage) +
                                 new CsvFormat().getMessage(validAlertMessage));
                     });
                     */
                afterEach(function () {
                    mockFs.restore();
                });
            });
        });
        context('When values are invalid', function () {
            context('On noNewLine set to true', function () {
                beforeEach(function () {
                    fileTransport = new file_transport_1.FileTransport(fileTransportConfigNoNewLine);
                    mockFs({ 'test_file_transport.txt': '' });
                });
                it('Should not send the message if the severity is not compatible', async function () {
                    await fileTransport.send(invalidMessage);
                    const fileString = fs.readFileSync(fileName, 'UTF8');
                    chai_1.expect(fileString).to.equal('');
                });
                afterEach(function () {
                    mockFs.restore();
                });
            });
            context('On noNewLine set to false', function () {
                beforeEach(function () {
                    fileTransport = new file_transport_1.FileTransport(fileTransportConfigNewLine);
                    mockFs({ 'test_file_transport.txt': '' });
                });
                it('Should not send the message if the severity is not compatible', async function () {
                    await fileTransport.send(invalidMessage);
                    const fileString = fs.readFileSync(fileName, 'UTF8');
                    chai_1.expect(fileString).to.equal('');
                });
                afterEach(function () {
                    mockFs.restore();
                });
            });
        });
    });
});
//# sourceMappingURL=file.transport.spec.js.map