[AI-FSSDK] (DO NOT REVIEW) [FSSDK-12262] Exclude CMAB from UserProfileService

optimizely/decision_service.py

@@ -457,7 +457,10 @@ def get_variation(
             }
 
         # Check to see if user has a decision available for the given experiment
-        if user_profile_tracker is not None and not ignore_user_profile:
+        # CMAB experiments are excluded from UPS (sticky bucketing) since CMAB
+        # decisions are managed by the CMAB service with its own caching.
+        is_cmab_experiment = bool(experiment.cmab)
+        if user_profile_tracker is not None and not ignore_user_profile and not is_cmab_experiment:
             variation = self.get_stored_variation(project_config, experiment, user_profile_tracker.get_user_profile())
             if variation:
                 message = f'Returning previously activated variation ID "{variation}" of experiment ' \
@@ -472,6 +475,10 @@ def get_variation(
                 }
             else:
                 self.logger.warning('User profile has invalid format.')
+        elif is_cmab_experiment and user_profile_tracker is not None and not ignore_user_profile:
+            message = f'Skipping user profile service for CMAB experiment "{experiment.key}".'
+            self.logger.debug(message)
+            decide_reasons.append(message)
 
         # Check audience conditions
         audience_conditions = experiment.get_audience_conditions_or_ids()
@@ -529,7 +536,8 @@ def get_variation(
             self.logger.info(message)
             decide_reasons.append(message)
             # Store this new decision and return the variation for the user
-            if user_profile_tracker is not None and not ignore_user_profile:
+            # CMAB experiments are excluded from UPS since CMAB manages its own decisions.
+            if user_profile_tracker is not None and not ignore_user_profile and not is_cmab_experiment:
                 try:
                     user_profile_tracker.update_user_profile(experiment, variation)
                 except:

tests/test_decision_service.py

@@ -1890,3 +1890,184 @@ def test_get_variation_for_feature_returns_rollout_in_experiment_bucket_range_25
         mock_config_logging.debug.assert_called_with(
             'Assigned bucket 4000 to user with bucketing ID "test_user".')
         mock_generate_bucket_value.assert_called_with("test_user211147")
+
+    def test_get_variation_cmab_experiment_skips_ups_lookup(self):
+        """Test that get_variation skips UPS lookup for CMAB experiments even when UPS tracker is available."""
+
+        user = optimizely_user_context.OptimizelyUserContext(
+            optimizely_client=None,
+            logger=None,
+            user_id="test_user",
+            user_attributes={}
+        )
+
+        # Create a CMAB experiment
+        cmab_experiment = entities.Experiment(
+            '111150',
+            'cmab_experiment',
+            'Running',
+            '111150',
+            [],
+            {},
+            [
+                entities.Variation('111151', 'variation_1'),
+                entities.Variation('111152', 'variation_2')
+            ],
+            [
+                {'entityId': '111151', 'endOfRange': 5000},
+                {'entityId': '111152', 'endOfRange': 10000}
+            ],
+            cmab={'trafficAllocation': 5000}
+        )
+
+        user_profile_service = user_profile.UserProfileService()
+        user_profile_tracker = user_profile.UserProfileTracker(user.user_id, user_profile_service)
+
+        with mock.patch('optimizely.helpers.experiment.is_experiment_running', return_value=True), \
+            mock.patch('optimizely.helpers.audience.does_user_meet_audience_conditions', return_value=[True, []]), \
+            mock.patch.object(self.decision_service.bucketer, 'bucket_to_entity_id',
+                              return_value=['$', []]), \
+            mock.patch.object(self.decision_service, 'cmab_service') as mock_cmab_service, \
+            mock.patch.object(self.project_config, 'get_variation_from_id',
+                              return_value=entities.Variation('111151', 'variation_1')), \
+            mock.patch.object(self.decision_service, 'get_stored_variation') as mock_get_stored, \
+            mock.patch.object(self.decision_service,
+                              'logger') as mock_logger:
+
+            mock_cmab_service.get_decision.return_value = (
+                {
+                    'variation_id': '111151',
+                    'cmab_uuid': 'test-cmab-uuid-123'
+                },
+                []
+            )
+
+            variation_result = self.decision_service.get_variation(
+                self.project_config,
+                cmab_experiment,
+                user,
+                user_profile_tracker
+            )
+
+            # Verify UPS lookup was NOT called for CMAB experiment
+            mock_get_stored.assert_not_called()
+
+            # Verify variation was still returned correctly
+            self.assertEqual(entities.Variation('111151', 'variation_1'), variation_result['variation'])
+            self.assertEqual('test-cmab-uuid-123', variation_result['cmab_uuid'])
+            self.assertStrictFalse(variation_result['error'])
+
+            # Verify the skip reason was logged
+            self.assertIn(
+                'Skipping user profile service for CMAB experiment "cmab_experiment".',
+                variation_result['reasons']
+            )
+            mock_logger.debug.assert_any_call(
+                'Skipping user profile service for CMAB experiment "cmab_experiment".'
+            )
+
+    def test_get_variation_cmab_experiment_skips_ups_save(self):
+        """Test that get_variation does not save to UPS for CMAB experiments."""
+
+        user = optimizely_user_context.OptimizelyUserContext(
+            optimizely_client=None,
+            logger=None,
+            user_id="test_user",
+            user_attributes={}
+        )
+
+        # Create a CMAB experiment
+        cmab_experiment = entities.Experiment(
+            '111150',
+            'cmab_experiment',
+            'Running',
+            '111150',
+            [],
+            {},
+            [
+                entities.Variation('111151', 'variation_1'),
+                entities.Variation('111152', 'variation_2')
+            ],
+            [
+                {'entityId': '111151', 'endOfRange': 5000},
+                {'entityId': '111152', 'endOfRange': 10000}
+            ],
+            cmab={'trafficAllocation': 5000}
+        )
+
+        user_profile_service = user_profile.UserProfileService()
+        user_profile_tracker = user_profile.UserProfileTracker(user.user_id, user_profile_service)
+
+        with mock.patch('optimizely.helpers.experiment.is_experiment_running', return_value=True), \
+            mock.patch('optimizely.helpers.audience.does_user_meet_audience_conditions', return_value=[True, []]), \
+            mock.patch.object(self.decision_service.bucketer, 'bucket_to_entity_id',
+                              return_value=['$', []]), \
+            mock.patch.object(self.decision_service, 'cmab_service') as mock_cmab_service, \
+            mock.patch.object(self.project_config, 'get_variation_from_id',
+                              return_value=entities.Variation('111151', 'variation_1')), \
+            mock.patch.object(user_profile_tracker, 'update_user_profile') as mock_update_profile, \
+            mock.patch.object(self.decision_service, 'logger'):
+
+            mock_cmab_service.get_decision.return_value = (
+                {
+                    'variation_id': '111151',
+                    'cmab_uuid': 'test-cmab-uuid-123'
+                },
+                []
+            )
+
+            variation_result = self.decision_service.get_variation(
+                self.project_config,
+                cmab_experiment,
+                user,
+                user_profile_tracker
+            )
+
+            # Verify variation was returned correctly
+            self.assertEqual(entities.Variation('111151', 'variation_1'), variation_result['variation'])
+            self.assertEqual('test-cmab-uuid-123', variation_result['cmab_uuid'])
+
+            # Verify UPS was NOT updated for CMAB experiment
+            mock_update_profile.assert_not_called()
+
+    def test_get_variation_non_cmab_experiment_uses_ups(self):
+        """Test that get_variation still uses UPS for non-CMAB experiments (regression test)."""
+
+        user = optimizely_user_context.OptimizelyUserContext(
+            optimizely_client=None,
+            logger=None,
+            user_id="test_user",
+            user_attributes={}
+        )
+
+        experiment = self.project_config.get_experiment_from_key("test_experiment")
+        user_profile_service = user_profile.UserProfileService()
+        user_profile_tracker = user_profile.UserProfileTracker(user.user_id, user_profile_service)
+
+        with mock.patch(
+            "optimizely.decision_service.DecisionService.get_whitelisted_variation",
+            return_value=[None, []],
+        ), mock.patch(
+            "optimizely.decision_service.DecisionService.get_stored_variation",
+            return_value=entities.Variation("111128", "control"),
+        ) as mock_get_stored_variation, mock.patch(
+            "optimizely.helpers.audience.does_user_meet_audience_conditions"
+        ) as mock_audience_check, mock.patch(
+            "optimizely.bucketer.Bucketer.bucket"
+        ) as mock_bucket:
+            variation_result = self.decision_service.get_variation(
+                self.project_config, experiment, user, user_profile_tracker
+            )
+
+            # Verify stored variation IS returned for non-CMAB experiment
+            self.assertEqual(
+                entities.Variation("111128", "control"),
+                variation_result['variation'],
+            )
+
+            # Verify UPS lookup WAS called
+            mock_get_stored_variation.assert_called_once()
+
+            # Verify bucketing was NOT called (since stored variation was found)
+            mock_audience_check.assert_not_called()
+            mock_bucket.assert_not_called()