Fixing logger (#29)

Author: aliabbasrizvi

optimizely/optimizely.py

@@ -1,4 +1,3 @@
-import logging
 import sys
 
 from . import bucketer
@@ -12,6 +11,7 @@
 from .helpers import experiment as experiment_helper
 from .helpers import validator
 from .logger import NoOpLogger as noop_logger
+from .logger import SimpleLogger
 
 
 class Optimizely(object):
@@ -39,15 +39,17 @@ def __init__(self, datafile, event_dispatcher=None, logger=None, error_handler=N
       self._validate_inputs(datafile, skip_json_validation)
     except exceptions.InvalidInputException as error:
       self.is_valid = False
-      logging.error(str(error))
+      self.logger = SimpleLogger()
+      self.logger.log(enums.LogLevels.ERROR, str(error))
       return
 
     try:
       self.config = project_config.ProjectConfig(datafile, self.logger, self.error_handler)
     except:
       self.is_valid = False
       self.config = None
-      logging.error(enums.Errors.INVALID_INPUT_ERROR.format('datafile'))
+      self.logger = SimpleLogger()
+      self.logger.log(enums.LogLevels.ERROR, enums.Errors.INVALID_INPUT_ERROR.format('datafile'))
       return
 
     self.bucketer = bucketer.Bucketer(self.config)
@@ -56,7 +58,8 @@ def __init__(self, datafile, event_dispatcher=None, logger=None, error_handler=N
       self.event_builder = event_builder.get_event_builder(self.config, self.bucketer)
     except:
       self.is_valid = False
-      logging.error(enums.Errors.UNSUPPORTED_DATAFILE_VERSION)
+      self.logger = SimpleLogger()
+      self.logger.log(enums.LogLevels.ERROR, enums.Errors.UNSUPPORTED_DATAFILE_VERSION)
 
   def _validate_inputs(self, datafile, skip_json_validation):
     """ Helper method to validate all input parameters.
@@ -128,7 +131,7 @@ def activate(self, experiment_key, user_id, attributes=None):
     """
 
     if not self.is_valid:
-      logging.error(enums.Errors.INVALID_DATAFILE.format('activate'))
+      self.logger.log(enums.LogLevels.ERROR, enums.Errors.INVALID_DATAFILE.format('activate'))
       return None
 
     experiment = self.config.get_experiment_from_key(experiment_key)
@@ -171,7 +174,7 @@ def track(self, event_key, user_id,  attributes=None, event_value=None):
     """
 
     if not self.is_valid:
-      logging.error(enums.Errors.INVALID_DATAFILE.format('track'))
+      self.logger.log(enums.LogLevels.ERROR, enums.Errors.INVALID_DATAFILE.format('track'))
       return
 
     if attributes and not validator.are_attributes_valid(attributes):
@@ -224,7 +227,7 @@ def get_variation(self, experiment_key, user_id, attributes=None):
     """
 
     if not self.is_valid:
-      logging.error(enums.Errors.INVALID_DATAFILE.format('get_variation'))
+      self.logger.log(enums.LogLevels.ERROR, enums.Errors.INVALID_DATAFILE.format('get_variation'))
       return None
 
     experiment = self.config.get_experiment_from_key(experiment_key)

tests/test_optimizely.py

@@ -23,43 +23,43 @@ def _validate_event_object(self, event_obj, expected_url, expected_params, expec
   def test_init__invalid_datafile__logs_error(self):
     """ Test that invalid datafile logs error on init. """
 
-    with mock.patch('logging.error') as mock_log_error:
+    with mock.patch('optimizely.logger.SimpleLogger.log') as mock_logging:
       optimizely.Optimizely('invalid_datafile')
 
-    mock_log_error.assert_called_once_with('Provided "datafile" is in an invalid format.')
+    mock_logging.assert_called_once_with(enums.LogLevels.ERROR, 'Provided "datafile" is in an invalid format.')
 
   def test_init__invalid_event_dispatcher__logs_error(self):
     """ Test that invalid event_dispatcher logs error on init. """
 
     class InvalidDispatcher(object):
       pass
 
-    with mock.patch('logging.error') as mock_log_error:
+    with mock.patch('optimizely.logger.SimpleLogger.log') as mock_logging:
       optimizely.Optimizely(json.dumps(self.config_dict), event_dispatcher=InvalidDispatcher)
 
-    mock_log_error.assert_called_once_with('Provided "event_dispatcher" is in an invalid format.')
+    mock_logging.assert_called_once_with(enums.LogLevels.ERROR, 'Provided "event_dispatcher" is in an invalid format.')
 
   def test_init__invalid_logger__raises(self):
     """ Test that invalid logger logs error on init. """
 
     class InvalidLogger(object):
       pass
 
-    with mock.patch('logging.error') as mock_log_error:
+    with mock.patch('optimizely.logger.SimpleLogger.log') as mock_logging:
       optimizely.Optimizely(json.dumps(self.config_dict), logger=InvalidLogger)
 
-    mock_log_error.assert_called_once_with('Provided "logger" is in an invalid format.')
+    mock_logging.assert_called_once_with(enums.LogLevels.ERROR, 'Provided "logger" is in an invalid format.')
 
   def test_init__invalid_error_handler__raises(self):
     """ Test that invalid error_handler logs error on init. """
 
     class InvalidErrorHandler(object):
       pass
 
-    with mock.patch('logging.error') as mock_log_error:
+    with mock.patch('optimizely.logger.SimpleLogger.log') as mock_logging:
       optimizely.Optimizely(json.dumps(self.config_dict), error_handler=InvalidErrorHandler)
 
-    mock_log_error.assert_called_once_with('Provided "error_handler" is in an invalid format.')
+    mock_logging.assert_called_once_with(enums.LogLevels.ERROR, 'Provided "error_handler" is in an invalid format.')
 
   def test_skip_json_validation_true(self):
     """ Test that on setting skip_json_validation to true, JSON schema validation is not performed. """
@@ -73,23 +73,23 @@ def test_invalid_json_raises_schema_validation_off(self):
     """ Test that invalid JSON logs error if schema validation is turned off. """
 
     # Not  JSON
-    with mock.patch('logging.error') as mock_log_error:
+    with mock.patch('optimizely.logger.SimpleLogger.log') as mock_logging:
       optimizely.Optimizely('invalid_json', skip_json_validation=True)
 
-    mock_log_error.assert_called_once_with('Provided "datafile" is in an invalid format.')
+    mock_logging.assert_called_once_with(enums.LogLevels.ERROR, 'Provided "datafile" is in an invalid format.')
 
     # JSON, but missing version
-    with mock.patch('logging.error') as mock_log_error:
+    with mock.patch('optimizely.logger.SimpleLogger.log') as mock_logging:
       optimizely.Optimizely(json.dumps({'some_field': 'some_value'}), skip_json_validation=True)
 
-    mock_log_error.assert_called_once_with(enums.Errors.UNSUPPORTED_DATAFILE_VERSION)
+    mock_logging.assert_called_once_with(enums.LogLevels.ERROR, enums.Errors.UNSUPPORTED_DATAFILE_VERSION)
 
     # JSON having valid version, but entities have invalid format
-    with mock.patch('logging.error') as mock_log_error:
+    with mock.patch('optimizely.logger.SimpleLogger.log') as mock_logging:
       optimizely.Optimizely({'version': '2', 'events': 'invalid_value', 'experiments': 'invalid_value'},
                             skip_json_validation=True)
 
-    mock_log_error.assert_called_once_with('Provided "datafile" is in an invalid format.')
+    mock_logging.assert_called_once_with(enums.LogLevels.ERROR, 'Provided "datafile" is in an invalid format.')
 
   def test_activate(self):
     """ Test that activate calls dispatch_event with right params and returns expected variation. """
@@ -213,10 +213,10 @@ def test_activate__invalid_object(self):
 
     opt_obj = optimizely.Optimizely('invalid_file')
 
-    with mock.patch('logging.error') as mock_logging_error:
+    with mock.patch('optimizely.logger.SimpleLogger.log') as mock_logging:
       self.assertIsNone(opt_obj.activate('test_experiment', 'test_user'))
 
-    mock_logging_error.assert_called_once_with('Datafile has invalid format. Failing "activate".')
+    mock_logging.assert_called_once_with(enums.LogLevels.ERROR, 'Datafile has invalid format. Failing "activate".')
 
   def test_track__with_attributes(self):
     """ Test that track calls dispatch_event with right params when attributes are provided. """
@@ -337,10 +337,10 @@ def test_track__invalid_object(self):
 
     opt_obj = optimizely.Optimizely('invalid_file')
 
-    with mock.patch('logging.error') as mock_logging_error:
+    with mock.patch('optimizely.logger.SimpleLogger.log') as mock_logging:
       opt_obj.track('test_event', 'test_user')
 
-    mock_logging_error.assert_called_once_with('Datafile has invalid format. Failing "track".')
+    mock_logging.assert_called_once_with(enums.LogLevels.ERROR, 'Datafile has invalid format. Failing "track".')
 
   def test_get_variation__audience_match_and_experiment_running(self):
     """ Test that get variation retrieves expected variation
@@ -409,10 +409,10 @@ def test_get_variation__invalid_object(self):
 
     opt_obj = optimizely.Optimizely('invalid_file')
 
-    with mock.patch('logging.error') as mock_logging_error:
+    with mock.patch('optimizely.logger.SimpleLogger.log') as mock_logging:
       self.assertIsNone(opt_obj.get_variation('test_experiment', 'test_user'))
 
-    mock_logging_error.assert_called_once_with('Datafile has invalid format. Failing "get_variation".')
+    mock_logging.assert_called_once_with(enums.LogLevels.ERROR, 'Datafile has invalid format. Failing "get_variation".')
 
   def test_custom_logger(self):
     """ Test creating Optimizely object with a custom logger. """
@@ -450,10 +450,10 @@ def _validate_event_object(self, event_obj, expected_url, expected_params, expec
   def test_init__invalid_datafile__raises(self):
     """ Test that invalid datafile raises Exception on init. """
 
-    with mock.patch('logging.error') as mock_log_error:
+    with mock.patch('optimizely.logger.SimpleLogger.log') as mock_logging:
       optimizely.Optimizely('invalid_datafile')
 
-    mock_log_error.assert_called_once_with('Provided "datafile" is in an invalid format.')
+    mock_logging.assert_called_once_with(enums.LogLevels.ERROR, 'Provided "datafile" is in an invalid format.')
 
   def test_activate(self):
     """ Test that activate calls dispatch_event with right params and returns expected variation. """
@@ -598,10 +598,10 @@ def test_activate__invalid_object(self):
 
     opt_obj = optimizely.Optimizely('invalid_file')
 
-    with mock.patch('logging.error') as mock_logging_error:
+    with mock.patch('optimizely.logger.SimpleLogger.log') as mock_logging:
       self.assertIsNone(opt_obj.activate('test_experiment', 'test_user'))
 
-    mock_logging_error.assert_called_once_with('Datafile has invalid format. Failing "activate".')
+    mock_logging.assert_called_once_with(enums.LogLevels.ERROR, 'Datafile has invalid format. Failing "activate".')
 
   def test_track__with_attributes(self):
     """ Test that track calls dispatch_event with right params when attributes are provided. """
@@ -755,20 +755,20 @@ def test_track__invalid_object(self):
 
     opt_obj = optimizely.Optimizely('invalid_file')
 
-    with mock.patch('logging.error') as mock_logging_error:
+    with mock.patch('optimizely.logger.SimpleLogger.log') as mock_logging:
       opt_obj.track('test_event', 'test_user')
 
-    mock_logging_error.assert_called_once_with('Datafile has invalid format. Failing "track".')
+    mock_logging.assert_called_once_with(enums.LogLevels.ERROR, 'Datafile has invalid format. Failing "track".')
 
   def test_get_variation__invalid_object(self):
     """ Test that get_variation logs error if Optimizely object is not created correctly. """
 
     opt_obj = optimizely.Optimizely('invalid_file')
 
-    with mock.patch('logging.error') as mock_logging_error:
+    with mock.patch('optimizely.logger.SimpleLogger.log') as mock_logging:
       self.assertIsNone(opt_obj.get_variation('test_experiment', 'test_user'))
 
-    mock_logging_error.assert_called_once_with('Datafile has invalid format. Failing "get_variation".')
+    mock_logging.assert_called_once_with(enums.LogLevels.ERROR, 'Datafile has invalid format. Failing "get_variation".')
 
 
 class OptimizelyWithExceptionTest(base.BaseTestV1):