[AI-FSSDK] [FSSDK-12337] Simplify feature rollout config parsing

- Inline _get_everyone_else_variation logic, remove unnecessary static method
- Use get_rollout_from_id() to match TDD pseudocode
- Remove isinstance check (rollout experiments are always dicts)
- Remove 3 unit tests for deleted helper method (edge cases already
  covered by integration-level tests)

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: FarhanAnjum-opti

optimizely/project_config.py

@@ -234,23 +234,19 @@ def __init__(self, datafile: str | bytes, logger: Logger, error_handler: Any):
 
             # Feature Rollout support: inject the "everyone else" variation
             # into any experiment with type == "feature_rollout"
-            rollout_for_flag = (
-                None if len(feature.rolloutId) == 0
-                else self.rollout_id_map.get(feature.rolloutId)
-            )
-            if rollout_for_flag:
-                everyone_else_variation = self._get_everyone_else_variation(rollout_for_flag)
-                if everyone_else_variation is not None:
+            rollout_for_flag = self.get_rollout_from_id(feature.rolloutId) if feature.rolloutId else None
+            if rollout_for_flag and rollout_for_flag.experiments:
+                everyone_else_rule = rollout_for_flag.experiments[-1]
+                everyone_else_variations = everyone_else_rule.get('variations', [])
+                if everyone_else_variations:
+                    everyone_else_variation = everyone_else_variations[0]
                     for experiment in rules:
                         if getattr(experiment, 'type', None) == 'feature_rollout':
-                            # Append the everyone else variation to the experiment
                             experiment.variations.append(everyone_else_variation)
-                            # Add traffic allocation entry with endOfRange=10000
                             experiment.trafficAllocation.append({
                                 'entityId': everyone_else_variation['id'],
                                 'endOfRange': 10000,
                             })
-                            # Update variation maps for this experiment
                             var_entity = entities.Variation(
                                 id=everyone_else_variation['id'],
                                 key=everyone_else_variation['key'],
@@ -340,32 +336,6 @@ def _generate_key_map(
 
         return key_map
 
-    @staticmethod
-    def _get_everyone_else_variation(rollout: entities.Layer) -> Optional[types.VariationDict]:
-        """ Get the "everyone else" variation from a rollout.
-
-        The "everyone else" rule is the last experiment in the rollout,
-        and its first variation is the "everyone else" variation.
-
-        Args:
-            rollout: The rollout (Layer) entity to get the variation from.
-
-        Returns:
-            The "everyone else" variation dict, or None if not available.
-        """
-        if not rollout.experiments:
-            return None
-
-        everyone_else_rule = rollout.experiments[-1]
-        variations = everyone_else_rule.get('variations', []) if isinstance(
-            everyone_else_rule, dict
-        ) else getattr(everyone_else_rule, 'variations', [])
-
-        if not variations:
-            return None
-
-        return variations[0]
-
     @staticmethod
     def _deserialize_audience(audience_map: dict[str, entities.Audience]) -> dict[str, entities.Audience]:
         """ Helper method to de-serialize and populate audience map with the condition list and structure.

tests/test_config.py

@@ -2363,66 +2363,3 @@ def test_existing_datafile_not_broken(self):
         self.assertEqual(len(experiment.trafficAllocation), 2)
         self.assertIsNone(experiment.type)
 
-    def test_get_everyone_else_variation_helper(self):
-        """Test the _get_everyone_else_variation static method directly."""
-        layer = entities.Layer(
-            id='rollout_1',
-            experiments=[
-                {
-                    'id': 'rule_1',
-                    'key': 'rule_1',
-                    'status': 'Running',
-                    'forcedVariations': {},
-                    'layerId': 'rollout_1',
-                    'audienceIds': [],
-                    'trafficAllocation': [],
-                    'variations': [
-                        {'key': 'var_1', 'id': 'var_1', 'featureEnabled': True}
-                    ],
-                },
-                {
-                    'id': 'everyone_else',
-                    'key': 'everyone_else',
-                    'status': 'Running',
-                    'forcedVariations': {},
-                    'layerId': 'rollout_1',
-                    'audienceIds': [],
-                    'trafficAllocation': [],
-                    'variations': [
-                        {'key': 'ee_var', 'id': 'ee_var', 'featureEnabled': False}
-                    ],
-                },
-            ],
-        )
-
-        result = ProjectConfig._get_everyone_else_variation(layer)
-        self.assertIsNotNone(result)
-        self.assertEqual(result['id'], 'ee_var')
-        self.assertEqual(result['key'], 'ee_var')
-
-    def test_get_everyone_else_variation_empty_rollout(self):
-        """Test _get_everyone_else_variation returns None for empty rollout."""
-        layer = entities.Layer(id='empty_rollout', experiments=[])
-        result = ProjectConfig._get_everyone_else_variation(layer)
-        self.assertIsNone(result)
-
-    def test_get_everyone_else_variation_no_variations(self):
-        """Test _get_everyone_else_variation returns None when last rule has no variations."""
-        layer = entities.Layer(
-            id='rollout_1',
-            experiments=[
-                {
-                    'id': 'rule_1',
-                    'key': 'rule_1',
-                    'status': 'Running',
-                    'forcedVariations': {},
-                    'layerId': 'rollout_1',
-                    'audienceIds': [],
-                    'trafficAllocation': [],
-                    'variations': [],
-                },
-            ],
-        )
-
-        result = ProjectConfig._get_everyone_else_variation(layer)
-        self.assertIsNone(result)