polish and integration tests

Author: chillaq

splitio/api/client.py

@@ -133,7 +133,7 @@ def set_telemetry_data(self, metric_name, telemetry_runtime_producer):
         self._metric_name = metric_name
 
     def is_sdk_endpoint_overridden(self):
-        return self._urls['sdk'] == SDK_URL
+        return self._urls['sdk'] != SDK_URL
 
     def _get_headers(self, extra_headers, sdk_key):
         headers = _build_basic_headers(sdk_key)

splitio/engine/evaluator.py

@@ -125,13 +125,19 @@ def context_for(self, key, feature_names):
             pending = set()
             for feature in features.values():
                 cf, cs, crbs = get_dependencies(feature)
+                for rbs in crbs:
+                    rbs_cf, rbs_cs, rbs_crbs = get_dependencies(self._rbs_segment_storage.get(rbs))                
+                    cf.extend(rbs_cf)
+                    cs.extend(rbs_cs)
+                    crbs.extend(rbs_crbs)
+
                 pending.update(filter(lambda f: f not in splits, cf))
                 pending_memberships.update(cs)
                 pending_rbs_memberships.update(crbs)
 
         rbs_segment_memberships = {}
         rbs_segment_conditions = {}
-        excluded_rbs_segments = {}
+        excluded_rbs_segments = set()
         key_membership = False
         segment_memberhsip = False
         for rbs_segment in pending_rbs_memberships:
@@ -147,7 +153,7 @@ def context_for(self, key, feature_names):
                 if excluded_segment.type == SegmentType.RULE_BASED:
                     rbs_segment = self._rbs_segment_storage.get(excluded_segment.name)
                     if rbs_segment is not None:
-                        excluded_rbs_segments.update()
+                        excluded_rbs_segments.add(rbs_segment)
 
             rbs_segment_memberships.update({rbs_segment: segment_memberhsip or key_membership})
             if not (segment_memberhsip or key_membership):
@@ -189,7 +195,7 @@ async def context_for(self, key, feature_names):
             splits.update(features)
             pending = set()
             for feature in features.values():
-                cf, cs, crbs = get_dependencies(feature)
+                cf, cs, crbs = get_dependencies(feature)                    
                 pending.update(filter(lambda f: f not in splits, cf))
                 pending_memberships.update(cs)
                 pending_rbs_memberships.update(crbs)

splitio/models/grammar/matchers/rule_based_segment.py

@@ -34,7 +34,7 @@ def _match(self, key, attributes=None, context=None):
             return False
 
         for rbs_segment in context['ec'].excluded_rbs_segments:
-            if self._match_conditions(rbs_segment, key, attributes, context):
+            if self._match_conditions(rbs_segment.conditions, key, attributes, context):
                 return True
 
         if self._match_conditions(context['ec'].segment_rbs_conditions.get(self._rbs_segment_name), key, attributes, context):
@@ -50,7 +50,7 @@ def _add_matcher_specific_properties_to_json(self):
             }
         }
 
-    def _match_conditions(self, rbs_segment, key, attributes, context):
-        for parsed_condition in rbs_segment:
+    def _match_conditions(self, rbs_segment_conditions, key, attributes, context):
+        for parsed_condition in rbs_segment_conditions:
             if parsed_condition.matches(key, attributes, context):
                 return True

splitio/models/rule_based_segments.py

@@ -111,6 +111,16 @@ def from_raw(raw_rule_based_segment):
         _LOGGER.error(str(e))
         _LOGGER.debug("Using default conditions template for feature flag: %s", raw_rule_based_segment['name'])
         conditions = [condition.from_raw(_DEFAULT_CONDITIONS_TEMPLATE)]
+    
+    if raw_rule_based_segment.get('excluded') == None:
+        raw_rule_based_segment['excluded'] = {'keys': [], 'segments': []}
+        
+    if raw_rule_based_segment['excluded'].get('keys') == None:
+        raw_rule_based_segment['excluded']['keys'] = []
+
+    if raw_rule_based_segment['excluded'].get('segments') == None:
+        raw_rule_based_segment['excluded']['segments'] = []
+        
     return RuleBasedSegment(
         raw_rule_based_segment['name'],
         raw_rule_based_segment['trafficTypeName'],        

splits.json

@@ -0,0 +1,61 @@
+{"ff": {"d": [], "t": -1, "s": -1},
+"rbs": {"t": -1, "s": -1, "d":
+  [{
+  "changeNumber": 5,
+  "name": "dependent_rbs",
+  "status": "ACTIVE",
+  "trafficTypeName": "user",
+  "excluded":{"keys":["[email protected]","[email protected]"],"segments":[]},
+  "conditions": [
+    {
+      "matcherGroup": {
+        "combiner": "AND",
+        "matchers": [
+          {
+            "keySelector": {
+              "trafficType": "user",
+              "attribute": "email"
+            },
+            "matcherType": "ENDS_WITH",
+            "negate": false,
+            "whitelistMatcherData": {
+              "whitelist": [
+                "@split.io"
+              ]
+            }
+          }
+        ]
+      }
+    }
+  ]},
+  {
+    "changeNumber": 5,
+    "name": "sample_rule_based_segment",
+    "status": "ACTIVE",
+    "trafficTypeName": "user",
+    "excluded": {
+      "keys": [],
+      "segments": []
+    },
+    "conditions": [
+      {
+        "conditionType": "ROLLOUT",
+        "matcherGroup": {
+          "combiner": "AND",
+          "matchers": [
+            {
+              "keySelector": {
+                "trafficType": "user"
+              },
+              "matcherType": "IN_RULE_BASED_SEGMENT",
+              "negate": false,
+              "userDefinedSegmentMatcherData": {
+                "segmentName": "dependent_rbs"
+              }
+            }
+          ]
+        }
+      }
+    ]
+  }]
+}}

tests/engine/files/rule_base_segments.json

@@ -0,0 +1,63 @@
+{"ff": {"d": [], "t": -1, "s": -1},
+"rbs": {"t": -1, "s": -1, "d": [
+  {
+    "changeNumber": 5,
+    "name": "sample_rule_based_segment",
+    "status": "ACTIVE",
+    "trafficTypeName": "user",
+    "excluded":{
+      "keys":["[email protected]","[email protected]"],
+      "segments":[{"type":"rule-based", "name":"no_excludes"}]
+    },
+    "conditions": [
+      {
+        "matcherGroup": {
+          "combiner": "AND",
+          "matchers": [
+            {
+              "keySelector": {
+                "trafficType": "user",
+                "attribute": "email"
+              },
+              "matcherType": "ENDS_WITH",
+              "negate": false,
+              "whitelistMatcherData": {
+                "whitelist": [
+                  "@split.io"
+                ]
+              }
+            }
+          ]
+        }
+      }
+    ]
+  },
+  {
+    "changeNumber": 5,
+    "name": "no_excludes",
+    "status": "ACTIVE",
+    "trafficTypeName": "user",
+    "conditions": [
+      {
+        "matcherGroup": {
+          "combiner": "AND",
+          "matchers": [
+            {
+              "keySelector": {
+                "trafficType": "user",
+                "attribute": "email"
+              },
+              "matcherType": "ENDS_WITH",
+              "negate": false,
+              "whitelistMatcherData": {
+                "whitelist": [
+                  "@split.io"
+                ]
+              }
+            }
+          ]
+        }
+      }
+    ]
+  }
+]}}

tests/engine/files/rule_base_segments2.json

@@ -0,0 +1,35 @@
+{"ff": {"d": [], "t": -1, "s": -1},
+"rbs": {"t": -1, "s": -1, "d": [
+  {
+    "changeNumber": 5,
+    "name": "sample_rule_based_segment",
+    "status": "ACTIVE",
+    "trafficTypeName": "user",
+    "excluded":{
+      "keys":["[email protected]","[email protected]"],
+      "segments":[{"type":"standard", "name":"segment1"}]
+    },
+    "conditions": [
+      {
+        "matcherGroup": {
+          "combiner": "AND",
+          "matchers": [
+            {
+              "keySelector": {
+                "trafficType": "user",
+                "attribute": "email"
+              },
+              "matcherType": "ENDS_WITH",
+              "negate": false,
+              "whitelistMatcherData": {
+                "whitelist": [
+                  "@split.io"
+                ]
+              }
+            }
+          ]
+        }
+      }
+    ]
+  }
+]}}

tests/engine/files/rule_base_segments3.json

@@ -1,9 +1,12 @@
 """Evaluator tests module."""
+import json
 import logging
+import os
 import pytest
 import copy
 
 from splitio.models.splits import Split, Status
+from splitio.models import segments
 from splitio.models.grammar.condition import Condition, ConditionType
 from splitio.models.impressions import Label
 from splitio.models.grammar import condition
@@ -245,6 +248,74 @@ def test_evaluate_treatment_with_rule_based_segment(self, mocker):
         result = e.eval_with_context('[email protected]', '[email protected]', 'some', {'email': '[email protected]'}, ctx)
         assert result['treatment'] == 'off'
 
+    def test_evaluate_treatment_with_rbs_in_condition(self):
+        e = evaluator.Evaluator(splitters.Splitter())
+        splits_storage = InMemorySplitStorage()
+        rbs_storage = InMemoryRuleBasedSegmentStorage()
+        segment_storage = InMemorySegmentStorage()
+        evaluation_facctory = EvaluationDataFactory(splits_storage, segment_storage, rbs_storage)
+        
+        rbs_segments = os.path.join(os.path.dirname(__file__), 'files', 'rule_base_segments.json')
+        with open(rbs_segments, 'r') as flo:
+            data = json.loads(flo.read())
+            
+        mocked_split = Split('some', 12345, False, 'off', 'user', Status.ACTIVE, 12, split_conditions, 1.2, 100, 1234, {}, None, False)
+        rbs = rule_based_segments.from_raw(data["rbs"]["d"][0])
+        rbs2 = rule_based_segments.from_raw(data["rbs"]["d"][1])
+        rbs_storage.update([rbs, rbs2], [], 12)
+        splits_storage.update([mocked_split], [], 12)
+        
+        ctx = evaluation_facctory.context_for('[email protected]', ['some'])
+        assert e.eval_with_context('[email protected]', '[email protected]', 'some', {'email': '[email protected]'}, ctx)['treatment'] == "on"
+        ctx = evaluation_facctory.context_for('[email protected]', ['some'])
+        assert e.eval_with_context('[email protected]', '[email protected]', 'some', {'email': '[email protected]'}, ctx)['treatment'] == "off"
+        
+
+    def test_using_segment_in_excluded(self):
+        rbs_segments = os.path.join(os.path.dirname(__file__), 'files', 'rule_base_segments3.json')
+        with open(rbs_segments, 'r') as flo:
+            data = json.loads(flo.read())
+        e = evaluator.Evaluator(splitters.Splitter())
+        splits_storage = InMemorySplitStorage()
+        rbs_storage = InMemoryRuleBasedSegmentStorage()
+        segment_storage = InMemorySegmentStorage()
+        evaluation_facctory = EvaluationDataFactory(splits_storage, segment_storage, rbs_storage)
+                    
+        mocked_split = Split('some', 12345, False, 'off', 'user', Status.ACTIVE, 12, split_conditions, 1.2, 100, 1234, {}, None, False)
+        rbs = rule_based_segments.from_raw(data["rbs"]["d"][0])
+        rbs_storage.update([rbs], [], 12)
+        splits_storage.update([mocked_split], [], 12)
+        segment = segments.from_raw({'name': 'segment1', 'added': ['[email protected]'], 'removed': [], 'till': 123})
+        segment_storage.put(segment)
+        
+        ctx = evaluation_facctory.context_for('[email protected]', ['some'])
+        assert e.eval_with_context('[email protected]', '[email protected]', 'some', {'email': '[email protected]'}, ctx)['treatment'] == "on"
+        ctx = evaluation_facctory.context_for('[email protected]', ['some'])
+        assert e.eval_with_context('[email protected]', '[email protected]', 'some', {'email': '[email protected]'}, ctx)['treatment'] == "off"
+        ctx = evaluation_facctory.context_for('[email protected]', ['some'])
+        assert e.eval_with_context('[email protected]', '[email protected]', 'some', {'email': '[email protected]'}, ctx)['treatment'] == "off"
+        
+    def test_using_rbs_in_excluded(self):
+        rbs_segments = os.path.join(os.path.dirname(__file__), 'files', 'rule_base_segments2.json')
+        with open(rbs_segments, 'r') as flo:
+            data = json.loads(flo.read())
+        e = evaluator.Evaluator(splitters.Splitter())
+        splits_storage = InMemorySplitStorage()
+        rbs_storage = InMemoryRuleBasedSegmentStorage()
+        segment_storage = InMemorySegmentStorage()
+        evaluation_facctory = EvaluationDataFactory(splits_storage, segment_storage, rbs_storage)
+                    
+        mocked_split = Split('some', 12345, False, 'off', 'user', Status.ACTIVE, 12, split_conditions, 1.2, 100, 1234, {}, None, False)
+        rbs = rule_based_segments.from_raw(data["rbs"]["d"][0])
+        rbs2 = rule_based_segments.from_raw(data["rbs"]["d"][1])
+        rbs_storage.update([rbs, rbs2], [], 12)
+        splits_storage.update([mocked_split], [], 12)
+        
+        ctx = evaluation_facctory.context_for('[email protected]', ['some'])
+        assert e.eval_with_context('[email protected]', '[email protected]', 'some', {'email': '[email protected]'}, ctx)['treatment'] == "on"
+        ctx = evaluation_facctory.context_for('[email protected]', ['some'])
+        assert e.eval_with_context('[email protected]', '[email protected]', 'some', {'email': '[email protected]'}, ctx)['treatment'] == "on"
+        
 class EvaluationDataFactoryTests(object):
     """Test evaluation factory class."""