Gracefully handle v1 datafile (#44)

Author: aliabbasrizvi

optimizely/helpers/enums.py

@@ -39,4 +39,5 @@ class Errors(object):
   INVALID_DATAFILE = 'Datafile has invalid format. Failing "{}".'
   INVALID_GROUP_ID_ERROR = 'Provided group is not in datafile.'
   INVALID_VARIATION_ERROR = 'Provided variation is not in datafile.'
-  UNSUPPORTED_DATAFILE_VERSION = 'Provided datafile has unsupported version.'
+  UNSUPPORTED_DATAFILE_VERSION = 'Provided datafile has unsupported version. ' \
+                                 'Please use SDK version 1.1.0 or earlier for datafile version 1.'

optimizely/optimizely.py

@@ -66,14 +66,14 @@ def __init__(self, datafile, event_dispatcher=None, logger=None, error_handler=N
       self.logger.log(enums.LogLevels.ERROR, enums.Errors.INVALID_INPUT_ERROR.format('datafile'))
       return
 
-    self.bucketer = bucketer.Bucketer(self.config)
-
-    try:
-      self.event_builder = event_builder.EventBuilder(self.config, self.bucketer)
-    except:
+    if not self.config.was_parsing_successful():
       self.is_valid = False
       self.logger = SimpleLogger()
       self.logger.log(enums.LogLevels.ERROR, enums.Errors.UNSUPPORTED_DATAFILE_VERSION)
+      return
+
+    self.bucketer = bucketer.Bucketer(self.config)
+    self.event_builder = event_builder.EventBuilder(self.config, self.bucketer)
 
   def _validate_inputs(self, datafile, skip_json_validation):
     """ Helper method to validate all input parameters.

optimizely/project_config.py

@@ -22,6 +22,9 @@
 V1_CONFIG_VERSION = '1'
 V2_CONFIG_VERSION = '2'
 
+SUPPORTED_VERSIONS = [V2_CONFIG_VERSION]
+UNSUPPORTED_VERSIONS = [V1_CONFIG_VERSION]
+
 
 class ProjectConfig(object):
   """ Representation of the Optimizely project config. """
@@ -36,17 +39,19 @@ def __init__(self, datafile, logger, error_handler):
     """
 
     config = json.loads(datafile)
+    self.parsing_succeeded = False
     self.logger = logger
     self.error_handler = error_handler
     self.version = config.get('version')
+    if self.version in UNSUPPORTED_VERSIONS:
+      return
     self.account_id = config.get('accountId')
     self.project_id = config.get('projectId')
     self.revision = config.get('revision')
     self.groups = config.get('groups', [])
     self.experiments = config.get('experiments', [])
     self.events = config.get('events', [])
-    self.attributes = config.get('dimensions', []) \
-      if self.version == V1_CONFIG_VERSION else config.get('attributes', [])
+    self.attributes = config.get('attributes', [])
     self.audiences = config.get('audiences', [])
 
     # Utility maps for quick lookup
@@ -77,6 +82,8 @@ def __init__(self, datafile, logger, error_handler):
       for variation in self.variation_key_map.get(experiment.key).values():
         self.variation_id_map[experiment.key][variation.id] = variation
 
+    self.parsing_succeeded = True
+
   @staticmethod
   def _generate_key_map(list, key, entity_class):
     """ Helper method to generate map from key to entity object for given list of dicts.
@@ -116,6 +123,15 @@ def _deserialize_audience(audience_map):
 
     return audience_map
 
+  def was_parsing_successful(self):
+    """ Helper method to determine if parsing the datafile was successful.
+
+    Returns:
+      Boolean depending on whether parsing the datafile succeeded or not.
+    """
+
+    return self.parsing_succeeded
+
   def get_version(self):
     """ Get version of the datafile.
 

tests/helpers_tests/test_validator.py

@@ -112,7 +112,7 @@ def test_is_datafile_valid__returns_true(self):
   def test_is_datafile_valid__returns_false(self):
     """ Test that invalid datafile returns False. """
 
+    # When schema is not valid
     self.assertFalse(validator.is_datafile_valid(json.dumps({
       'invalid_key': 'invalid_value'
     })))
-

tests/test_optimizely.py

@@ -18,6 +18,7 @@
 from optimizely import exceptions
 from optimizely import logger
 from optimizely import optimizely
+from optimizely import project_config
 from optimizely import version
 from optimizely.helpers import enums
 from . import base
@@ -37,9 +38,10 @@ def test_init__invalid_datafile__logs_error(self):
     """ Test that invalid datafile logs error on init. """
 
     with mock.patch('optimizely.logger.SimpleLogger.log') as mock_logging:
-      optimizely.Optimizely('invalid_datafile')
+      opt_obj = optimizely.Optimizely('invalid_datafile')
 
     mock_logging.assert_called_once_with(enums.LogLevels.ERROR, 'Provided "datafile" is in an invalid format.')
+    self.assertFalse(opt_obj.is_valid)
 
   def test_init__invalid_event_dispatcher__logs_error(self):
     """ Test that invalid event_dispatcher logs error on init. """
@@ -48,31 +50,47 @@ class InvalidDispatcher(object):
       pass
 
     with mock.patch('optimizely.logger.SimpleLogger.log') as mock_logging:
-      optimizely.Optimizely(json.dumps(self.config_dict), event_dispatcher=InvalidDispatcher)
+      opt_obj = optimizely.Optimizely(json.dumps(self.config_dict), event_dispatcher=InvalidDispatcher)
 
     mock_logging.assert_called_once_with(enums.LogLevels.ERROR, 'Provided "event_dispatcher" is in an invalid format.')
+    self.assertFalse(opt_obj.is_valid)
 
-  def test_init__invalid_logger__raises(self):
+  def test_init__invalid_logger__logs_error(self):
     """ Test that invalid logger logs error on init. """
 
     class InvalidLogger(object):
       pass
 
     with mock.patch('optimizely.logger.SimpleLogger.log') as mock_logging:
-      optimizely.Optimizely(json.dumps(self.config_dict), logger=InvalidLogger)
+      opt_obj = optimizely.Optimizely(json.dumps(self.config_dict), logger=InvalidLogger)
 
     mock_logging.assert_called_once_with(enums.LogLevels.ERROR, 'Provided "logger" is in an invalid format.')
+    self.assertFalse(opt_obj.is_valid)
 
-  def test_init__invalid_error_handler__raises(self):
+  def test_init__invalid_error_handler__logs_error(self):
     """ Test that invalid error_handler logs error on init. """
 
     class InvalidErrorHandler(object):
       pass
 
     with mock.patch('optimizely.logger.SimpleLogger.log') as mock_logging:
-      optimizely.Optimizely(json.dumps(self.config_dict), error_handler=InvalidErrorHandler)
+      opt_obj = optimizely.Optimizely(json.dumps(self.config_dict), error_handler=InvalidErrorHandler)
 
     mock_logging.assert_called_once_with(enums.LogLevels.ERROR, 'Provided "error_handler" is in an invalid format.')
+    self.assertFalse(opt_obj.is_valid)
+
+  def test_init__v1_datafile__logs_error(self):
+    """ Test that v1 datafile logs error on init. """
+
+    self.config_dict['version'] = project_config.V1_CONFIG_VERSION
+    with mock.patch('optimizely.logger.SimpleLogger.log') as mock_logging:
+      opt_obj = optimizely.Optimizely(json.dumps(self.config_dict))
+
+    mock_logging.assert_called_once_with(
+      enums.LogLevels.ERROR,
+      'Provided datafile has unsupported version. Please use SDK version 1.1.0 or earlier for datafile version 1.'
+    )
+    self.assertFalse(opt_obj.is_valid)
 
   def test_skip_json_validation_true(self):
     """ Test that on setting skip_json_validation to true, JSON schema validation is not performed. """