Logger class for Angular so you can turn it off. // TODO: add production mode for warnings and errors only

Logger.js

angular.module('logging', ['ngResource'])
  .factory('Logger', function($log)
  {
    var Logger = {

      enabled: true,
      _consoleObject: $log,

      _console: function(type, first, second)
      {
        try
        {
          if(this.enabled === false)
          {
            return false;
          }

          var logObject = this._consoleObject;
          var logFunction;
          switch(type)
          {
            case "log":
              logFunction = logObject.log;
              break;

            case "debug":
              logFunction = logObject.debug;
              break;

            case "info":
              logFunction = logObject.info;
              break;

            case "warn":
              logFunction = logObject.warn;
              break;

            case "error":
              logFunction = logObject.error;
              break;

            case "fatal":
              logFunction = logObject.fatal;
              break;

            default:
              logFunction = logObject.log;
              break;
          }

          if(typeof second != 'undefined')
          {
            logFunction.apply(logObject, arguments);
          }
          else
          {
            logFunction.call(logObject, first);
          }
        }
        catch(error)
        {
          // swallow error since we don't want to cause older browsers problems
          // (i.e. IE8 with closed developer console, or <IE7)
        }
      },

      log: function(first, second)
      {
        this._console("log", first, second);
      },

      debug: function(first, second)
      {
        this._console("debug", first, second);
      },

      info: function(first, second)
      {
        this._console("info", first, second);
      },

      warn: function(first, second)
      {
        this._console("warn", first, second);
      },

      error: function(first, second)
      {
        this._console("error", first, second);
      },

      fatal: function(first, second)
      {
        this._console("fatal", first, second);
      }

    };
    return Logger;
  });
  
  // spec
  describe( 'Logger', function() {

    var Logger;
    beforeEach(function()
    {
        var $injector = angular.injector([ 'logging' ]);
        Logger = $injector.get( 'Logger' );
    });

    afterEach(function()
    {
        Logger = null;
    });

    it( 'should have a dummy test', inject( function() {
        expect( true ).toBeTruthy();
    }));

    it('Logger should not be null', function()
    {
        expect(Logger).not.toBe(null);
    });

    it("Logger's log method works", function()
    {
        Logger.log("test");
        expect(true).toBe(true);
    });

    it("Logger's debug method works", function()
    {
        Logger.debug("test");
        expect(true).toBe(true);
    });

    it("Logger's info method works", function()
    {
        Logger.info("test");
        expect(true).toBe(true);
    });

    it("Logger's warn method works", function()
    {
        Logger.warn("test");
        expect(true).toBe(true);
    });

    it("Logger's error method works", function()
    {
        Logger.error("test");
        expect(true).toBe(true);
    });

    it("should have console called with log", function()
    {
        spyOn(Logger, '_console');
        Logger.log('test');

        expect(Logger._console).toHaveBeenCalledWith('log', 'test', undefined);
    });

    it("should have proxy logger called with log", function()
    {
        Logger._consoleObject = {
            called: false,
            log: function()
            {
                this.called = true;
            }
        };
        Logger.log("test");
        expect(Logger._consoleObject.called).toBe(true);
    });


});