add more unit tests for user context

optimizely/optimizely.py

@@ -982,14 +982,10 @@ def decide(self, user_context, key, decide_options=None):
             reasons.append(DecisionMessage.SDK_NOT_READY)
             return Decision(flag_key=key, user_context=user_context, reasons=reasons)
 
-        feature_flag = None
-        for flag in config.feature_flags:
-            if flag['key'] == key:
-                feature_flag = flag
-                break
+        feature_flag = config.get_feature_from_key(key)
         if feature_flag is None:
             self.logger.error("No feature flag was found for key '#{key}'.")
-            reasons.push(DecisionMessage.FLAG_KEY_INVALID.format(key))
+            reasons.append(DecisionMessage.FLAG_KEY_INVALID.format(key))
             return Decision(flag_key=key, user_context=user_context, reasons=reasons)
 
         # merge decide_options and default_decide_options
@@ -1003,6 +999,7 @@ def decide(self, user_context, key, decide_options=None):
         user_id = user_context.user_id
         attributes = user_context.user_attributes
         variation_key = None
+        variation = None
         feature_enabled = False
         rule_key = None
         flag_key = key
@@ -1035,10 +1032,11 @@ def decide(self, user_context, key, decide_options=None):
 
         # Generate all variables map if decide options doesn't include excludeVariables
         if DecideOption.EXCLUDE_VARIABLES not in decide_options:
-            for v in feature_flag['variables']:
-                project_config = self.config_manager.get_config()
-                all_variables[v['key']] = self._get_feature_variable_for_type(project_config, feature_flag['key'],
-                                                                              v['key'], v['type'], user_id, attributes)
+            project_config = self.config_manager.get_config()
+            for key in feature_flag.variables:
+                v = feature_flag.variables[key]
+                all_variables[v.key] = self._get_feature_variable_for_type(project_config, feature_flag.key,
+                                                                           v.key, v.type, user_id, attributes)
 
         # Send notification
         self.notification_center.send_notifications(
@@ -1094,7 +1092,7 @@ def decide_all(self, user_context, decide_options=None):
 
         return self.decide_for_keys(user_context, keys, decide_options)
 
-    def decide_for_keys(self, user_context, keys, decide_options=[]):
+    def decide_for_keys(self, user_context, keys, decide_options=None):
         """
 
         Args:
@@ -1114,7 +1112,10 @@ def decide_for_keys(self, user_context, keys, decide_options=[]):
             self.logger.error(enums.Errors.INVALID_PROJECT_CONFIG.format('decide_for_keys'))
             return {}
 
-        enabled_flags_only = DecideOption.ENABLED_FLAGS_ONLY in decide_options
+        enabled_flags_only = False
+        if decide_options is not None:
+            enabled_flags_only = DecideOption.ENABLED_FLAGS_ONLY in decide_options
+
         decisions = {}
         for key in keys:
             decision = self.decide(user_context, key, decide_options)

tests/test_user_context.py

@@ -57,15 +57,48 @@ def test_decide_rollout(self):
     Also confirm that no impression event is processed. """
 
         opt_obj = optimizely.Optimizely(json.dumps(self.config_dict_with_features))
-        project_config = opt_obj.config_manager.get_config()
 
-        mock_rollout = project_config.get_experiment_from_key('test_experiment')
-        mock_variation = project_config.get_variation_from_id('test_experiment', '111129')
-        with mock.patch(
-            'optimizely.decision_service.DecisionService.get_variation_for_feature',
-            return_value=decision_service.Decision(mock_rollout, mock_variation, enums.DecisionSources.ROLLOUT),
-        ):
-            user_context = opt_obj.create_user_context('test_user')
-            decision = opt_obj.decide(user_context, 'test_feature_in_experiment')
-            self.assertTrue(decision.enabled)
-            self.assertEqual(decision.flag_key, 'test_feature_in_experiment')
+        user_context = opt_obj.create_user_context('test_user')
+        decision = opt_obj.decide(user_context, 'test_feature_in_rollout')
+        self.assertFalse(decision.enabled)
+        self.assertEqual(decision.flag_key, 'test_feature_in_rollout')
+
+    def test_decide_for_keys(self):
+        """ Test that the feature is enabled for the user if bucketed into variation of a rollout.
+    Also confirm that no impression event is processed. """
+
+        opt_obj = optimizely.Optimizely(json.dumps(self.config_dict_with_features))
+
+        user_context = opt_obj.create_user_context('test_user')
+        decisions = opt_obj.decide_for_keys(user_context, ['test_feature_in_rollout', 'test_feature_in_experiment'])
+        self.assertTrue(len(decisions) == 2)
+
+        self.assertFalse(decisions['test_feature_in_rollout'].enabled)
+        self.assertEqual(decisions['test_feature_in_rollout'].flag_key, 'test_feature_in_rollout')
+
+        self.assertFalse(decisions['test_feature_in_experiment'].enabled)
+        self.assertEqual(decisions['test_feature_in_experiment'].flag_key, 'test_feature_in_experiment')
+
+    def test_decide_all(self):
+        """ Test that the feature is enabled for the user if bucketed into variation of a rollout.
+    Also confirm that no impression event is processed. """
+
+        opt_obj = optimizely.Optimizely(json.dumps(self.config_dict_with_features))
+
+        user_context = opt_obj.create_user_context('test_user')
+        decisions = opt_obj.decide_all(user_context)
+        self.assertTrue(len(decisions) == 4)
+
+        self.assertFalse(decisions['test_feature_in_rollout'].enabled)
+        self.assertEqual(decisions['test_feature_in_rollout'].flag_key, 'test_feature_in_rollout')
+
+        self.assertFalse(decisions['test_feature_in_experiment'].enabled)
+        self.assertEqual(decisions['test_feature_in_experiment'].flag_key, 'test_feature_in_experiment')
+
+        self.assertFalse(decisions['test_feature_in_group'].enabled)
+        self.assertEqual(decisions['test_feature_in_group'].flag_key, 'test_feature_in_group')
+
+        self.assertFalse(decisions['test_feature_in_experiment_and_rollout'].enabled)
+        self.assertEqual(decisions['test_feature_in_experiment_and_rollout'].flag_key,
+                         'test_feature_in_experiment_and_rollout')
+