test.spec.js

'use strict';

/*global describe, it*/

var semlog = require('../');
var log = semlog.log;
var expect = require('chai').expect;

describe('semlog logger', function() {

    it('logs a string message to the console', function() {

        console.log('');
        console.log('-------------------------------------------------------------');
        console.log(' Testing Log Messages');
        console.log('-------------------------------------------------------------');

        log('[i] info log entry ');
        log('[W] warning log entry');
        log('[E] error log entry');
        log('[S] success log entry');
        log('[D] debug log entry');
        log('[+] added log entry');
        log('[-] removed log entry');
        log('[C] changed log entry');
        log('[TODO] todo log entry');
        log('unknown todo log entry');

        console.dir(semlog.getLogHistory());

        console.log('');
        console.log('-------------------------------------------------------------');
        console.log(' Testing Numbers and Datatypes');
        console.log('-------------------------------------------------------------');

        log(3);
        log([1, 2, 3]);
        log(true);
        log(false);
        log(null);
        log(Infinity);


        console.log('');
        console.log('-------------------------------------------------------------');
        console.log(' Testing Log Objects and Errors');
        console.log('-------------------------------------------------------------');

        // Create a new object, that prototypical inherits from the Error constructor.
        function MyError(message) {
            this.name = 'MyError';
            this.message = message || 'Default Message';
        }
        MyError.prototype = Object.create(Error.prototype);
        MyError.prototype.constructor = MyError;

        log({title: 'Object log entry', number: 10});
        log(new Error('error log entry'));
        log(new TypeError('error log entry'));
        log(new MyError('error log entry'));

        console.log('-------------------------------------------------------------');
        console.log('');
    });

    it('prints objects as colorized YAML', function() {
        semlog.updateConfig({printYaml: true});
        log({
            text: 'text',
            number: 42,
            array: [1, '2'],
            object: {
                key: 'value'
            }
        });
        semlog.updateConfig({printYaml: false});
    });

    it('prints errors', function() {
        semlog.error(new Error('Test Error'));
    });

    it('handles various invalid log objects', function() {
        log(undefined);
        log(null);
        log(Error);
        log(Infinity);
    });

    it('returns the log history as an array', function() {
        var logArchive = semlog.getLogHistory();

        expect(logArchive).to.be.instanceof(Array);
        expect(logArchive.length).to.be.least(1);
    });

    it('clears global log object', function() {
        semlog.clearLogHistory();
        var logArchive = semlog.getLogHistory();

        expect(logArchive).to.be.instanceof(Array);
        expect(logArchive.length).to.equal(0);
    });

    it('logs silently', function() {
        semlog.log(' [i] info log entry ', true);
        semlog.log(' [W] warning log entry', true);
        semlog.log(' [E] error log entry', true);

        var logArchive = semlog.getLogHistory();

        expect(logArchive).to.be.instanceof(Array);
        expect(logArchive.length).to.equal(3);
    });

    it('gets config', function() {
        var config = semlog.getConfig();

        expect(config).to.be.instanceof(Object);
        expect(Object.keys(config).length).to.be.least(3);
    });

    it('updates the config', function() {

        var config = semlog.getConfig();
        var newConfig = semlog.updateConfig({printTime: false});

        expect(newConfig).to.be.instanceof(Object);
        expect(newConfig.printTime).to.equal(false);
        expect(newConfig.historySize).to.equal(config.historySize);
    });

    it('keeps the log object at a specific size', function() {

        var historySize = 7;
        var newConfig = semlog.updateConfig({historySize: historySize, logDateTime: true});

        for (var i = 0; i < 32; i++) {
            log('[i] Index added: ' + i, true);
        }

        var logHistory = semlog.getLogHistory();
        expect(newConfig.historySize).to.equal(logHistory.length);
        expect(logHistory.length).to.equal(historySize);
    });

    it('returns the log archive as non circular array', function() {

        log(semlog.getLogHistory());
        var logHistory = semlog.getLogHistory();

        expect(JSON.stringify(logHistory)).to.be.a('string');

    });

    it('returns log statistics', function() {

        log(semlog.getStatistics());
        var statistics = semlog.getStatistics();

        expect(statistics.total).to.be.a('number');

    });

});

describe('semlog utilities', function() {

    it('pad numbers', function() {
        expect(semlog.pad(7, 1)).to.equal('7');
        expect(semlog.pad(7, 2)).to.equal('07');
        expect(semlog.pad(7, 3)).to.equal('007');
    });

    it('pretty prints numbers', function() {
        expect(semlog.prettyNumber(1)).to.equal('1');
        expect(semlog.prettyNumber(100000)).to.equal('100.000');
        expect(semlog.prettyNumber(-100000)).to.equal('-100.000');
    });

    it('pretty prints bytes', function() {
        expect(semlog.prettyBytes(1024)).to.be.a('string');
        expect(semlog.prettyBytes(1024)).to.equal('1.0 KiB');
        expect(semlog.prettyBytes(1024, true)).to.equal('1.0 kB');
    });

    it('strips trailing slashes from URLs', function() {
        expect(semlog.stripTrailingSlash('http://fannon.de/')).to.equal('http://fannon.de');
    });

    it('strips leading and ending slashes from URLs / URL paths', function() {
        expect(semlog.cleanUrl('http://fannon.de/')).to.equal('http://fannon.de');
        expect(semlog.cleanUrl('http://fannon.de  ')).to.equal('http://fannon.de');
        expect(semlog.cleanUrl('/test/')).to.equal('test');
        expect(semlog.cleanUrl('/test/ ')).to.equal('test');
        expect(semlog.cleanUrl('   test/ ')).to.equal('test');
    });

    it('creates date arrays', function() {
        expect(semlog.getDateArray().length).to.equal(7);
        expect(semlog.getDateArray()[0]).to.equal(new Date().getFullYear());
    });

    it('return human readable date-times', function() {
        expect(semlog.humanDate().length).to.equal(19);
        expect(semlog.humanDate(new Date('October 13, 2014 11:13:00'))).to.equal('2014-10-13 11:13:00');
    });

    it('return machine optimized date-times', function() {
        expect(semlog.roboDate().length).to.equal(19);
        expect(semlog.roboDate(new Date('October 13, 2014 11:13:00'))).to.equal('2014-10-13_11-13-00');
    });

    it('return human readable time', function() {
        expect(semlog.humanTime().length).to.equal(8);
        expect(semlog.humanTime(new Date('October 13, 2014 11:13:00'))).to.equal('11:13:00');
    });

    it('return machine optimized time', function() {
        expect(semlog.roboTime().length).to.equal(8);
        expect(semlog.roboTime(new Date('October 13, 2014 11:13:00'))).to.equal('11-13-00');
    });

    it('calculates the bytesize of strings', function() {
        expect(semlog.byteSize('internationalization')).to.be.a('number');
        expect(semlog.byteSize('internationalization')).to.equal(20);
    });

    it('calculates the bytesize of objects (parsed to JSON)', function() {
        expect(semlog.byteSize({title: 'internationalization'})).to.be.a('number');
        expect(semlog.byteSize({title: 'internationalization'})).to.equal(32);
    });


});