'use strict';

var expect = require('expect');

var sparklesLegacy = require('sparkles/legacy');

var glogg = require('../');

describe('glogg', function () {
  var logger;

  beforeEach(function (done) {
    logger = glogg('glogg-test');
    done();
  });

  afterEach(function (done) {
    logger.remove();
    done();
  });

  it('emits a debug event when debug method is called', function (done) {
    logger.on('debug', function (msg) {
      expect(msg).toEqual('test');
      done();
    });

    logger.debug('test');
  });

  it('emits a info event when info method is called', function (done) {
    logger.on('info', function (msg) {
      expect(msg).toEqual('test');
      done();
    });

    logger.info('test');
  });

  it('emits a warn event when warn method is called', function (done) {
    logger.on('warn', function (msg) {
      expect(msg).toEqual('test');
      done();
    });

    logger.warn('test');
  });

  it('emits a error event when error method is called', function (done) {
    logger.on('error', function (msg) {
      expect(msg).toEqual('test');
      done();
    });

    logger.error('test');
  });

  it('formats a string message with util.format syntax', function (done) {
    logger.on('debug', function (msg) {
      expect(msg).toEqual('test something');
      done();
    });

    logger.debug('test %s', 'something');
  });

  it('does not format a non-string message', function (done) {
    var expected = { test: 'something' };

    logger.on('debug', function (msg) {
      expect(msg).toEqual(expected);
      done();
    });

    logger.debug(expected);
  });

  it('emits all arguments to the log if non-string message', function (done) {
    var expected = { test: 'something' };

    logger.on('debug', function (msg, extra) {
      expect(msg).toEqual(expected);
      expect(extra).toEqual(true);
      done();
    });

    logger.debug(expected, true);
  });

  it('allows you to "destructure" the individual log-level functions', function (done) {
    var debug = logger.debug;

    logger.on('debug', function (msg) {
      expect(msg).toEqual('test');
      done();
    });

    debug('test');
  });
});

describe('events on legacy namespace', function () {
  var logger;
  var legacy;

  beforeEach(function (done) {
    var namespace = 'glogg-test';
    logger = glogg(namespace);
    legacy = sparklesLegacy(namespace);
    done();
  });

  afterEach(function (done) {
    logger.remove();
    legacy.remove();
    done();
  });

  it('emits deprecated event and forwards debug to logger', function (done) {
    var deprecated = false;
    logger.on('deprecated', function () {
      deprecated = true;
    });

    logger.on('debug', function (msg) {
      expect(deprecated).toEqual(true);
      expect(msg).toEqual('test');
      done();
    });

    legacy.emit('debug', 'test');
  });

  it('emits deprecated event and forwards info to logger', function (done) {
    var deprecated = false;
    logger.on('deprecated', function () {
      deprecated = true;
    });

    logger.on('info', function (msg) {
      expect(deprecated).toEqual(true);
      expect(msg).toEqual('test');
      done();
    });

    legacy.emit('info', 'test');
  });

  it('emits deprecated event and forwards warn to logger', function (done) {
    var deprecated = false;
    logger.on('deprecated', function () {
      deprecated = true;
    });

    logger.on('warn', function (msg) {
      expect(deprecated).toEqual(true);
      expect(msg).toEqual('test');
      done();
    });

    legacy.emit('warn', 'test');
  });

  it('emits deprecated event and forwards error to logger', function (done) {
    var deprecated = false;
    logger.on('deprecated', function () {
      deprecated = true;
    });

    logger.on('error', function (msg) {
      expect(deprecated).toEqual(true);
      expect(msg).toEqual('test');
      done();
    });

    legacy.emit('error', 'test');
  });
});
