Run all stages always

[rbdr/cologne] / test / cologne.js

'use strict';

const Tap = require('tap');

const { Cologne } = require('..');

// Utility Functions

const createDummyLogger = function () {

  return {
    values: null,
    log(...logs) {

      this.values = [];

      for (const log of logs) {
        this.values.push(log);
      }
    }
  };
};

const levelChecker = function (level) {

  return (count, log) => (log._level === level ? count + 1 : count);
};


// Prepare the test

Tap.plan(19);

const dummyLoggerA = createDummyLogger();
const dummyLoggerB = createDummyLogger();
const dummyLoggerC = createDummyLogger();

const co = new Cologne({
  loggers: [
    dummyLoggerA,
    dummyLoggerB
  ]
});

const exampleLogs = ['example1', null, undefined, 1, { example: true }];

/**
 * TEST: #log()
 */
co.log(...exampleLogs);

// Calculate values
const valueCheck = dummyLoggerA.values.reduce((count, log) => (typeof log._cologneLog === 'string' ? count + 1 : count), 0);
let levelCheck = dummyLoggerA.values.reduce(levelChecker(6), 0);

// Now check the values

Tap.equal(dummyLoggerA.values.length, exampleLogs.length,
  '#log() should send every argument to the loggers');

Tap.similar(dummyLoggerA.values, dummyLoggerB.values,
  '#log() should send the same arguments to all the loggers');

Tap.equal(valueCheck, exampleLogs.length,
  '#log() should send all objects in cologne log format');

Tap.equal(levelCheck, exampleLogs.length,
  '#log() should default to level 6');

/**
 * TEST: #debug()
 */
co.debug(...exampleLogs);
levelCheck = dummyLoggerA.values.reduce(levelChecker(7), 0);

Tap.equal(levelCheck, exampleLogs.length,
  '#debug() should set to level 7');

/**
 * TEST: #info()
 */
co.info(...exampleLogs);
levelCheck = dummyLoggerA.values.reduce(levelChecker(6), 0);

Tap.equal(levelCheck, exampleLogs.length,
  '#info() should set to level 6');

/**
 * TEST: #notice()
 */
co.notice(...exampleLogs);
levelCheck = dummyLoggerA.values.reduce(levelChecker(5), 0);

Tap.equal(levelCheck, exampleLogs.length,
  '#notice() should set to level 5');

/**
 * TEST: #warn()
 */
co.warn(...exampleLogs);
levelCheck = dummyLoggerA.values.reduce(levelChecker(4), 0);

Tap.equal(levelCheck, exampleLogs.length,
  '#warn() should set to level 4');

/**
 * TEST: #error()
 */
co.error(...exampleLogs);
levelCheck = dummyLoggerA.values.reduce(levelChecker(3), 0);

Tap.equal(levelCheck, exampleLogs.length,
  '#error() should set to level 3');

/**
 * TEST: #buildLog()
 */
let builtLog = co.buildLog('example');

// With the default level
Tap.equal(typeof builtLog._cologneLog, 'string',
  '#buildLog() should return a cologne log');
Tap.equal(builtLog._level, 6,
  '#buildLog() should default to level 6');

// Now with a specific value
builtLog = co.buildLog('example', 1);

Tap.equal(builtLog._level, 1,
  '#buildLog() should use the specified level');

// Extending object properties
builtLog = co.buildLog({ message: 'example', rainbows: true }, 1);

Tap.equal(builtLog.message, 'example',
  '#buildLog() should use the message property as the message if available');
Tap.equal(builtLog.rainbows, true,
  '#buildLog() should extend the object with its properties');

/**
 * TEST: #log() with builtLog.
 */
co.log(builtLog);

levelCheck = dummyLoggerA.values.reduce(levelChecker(1), 0);

Tap.equal(levelCheck, 1,
  '#log() calls using a pre-built cologne log should maintain the log level');


/**
 * TEST: #removeLogger()
 */
co.removeLogger(dummyLoggerC);

Tap.equal(co.loggers.length, 2,
  '#removeLogger() should do nothing if it can\'t find a logger');

co.log(...exampleLogs);
co.removeLogger(dummyLoggerB);
co.log(1);

Tap.equal(co.loggers.length, 1,
  '#removeLogger() should remove a logger');

Tap.notEqual(dummyLoggerB.values.length, dummyLoggerA.values.length,
  '#removeLogger() should no longer affect removed logs');

/**
 * TEST: #addLogger()
 */

co.addLogger(dummyLoggerC);
co.log(...exampleLogs);

Tap.equal(dummyLoggerC.values.length, exampleLogs.length,
  '#addLogger() should add loggers after instance is live');