Merge pull request #409 from splitio/async-model-matchers

updated dependency and segment matchers

Author: chillaq

splitio/models/grammar/matchers/keys.py

@@ -65,14 +65,10 @@ def _match(self, key, attributes=None, context=None):
         :returns: Wheter the match is successful.
         :rtype: bool
         """
-        segment_storage = context.get('segment_storage')
-        if not segment_storage:
-            raise Exception('Segment storage not present in matcher context.')
-
         matching_data = self._get_matcher_input(key, attributes)
         if matching_data is None:
             return False
-        return segment_storage.segment_contains(self._segment_name, matching_data)
+        return context['segment_matchers'][self._segment_name]
 
     def _add_matcher_specific_properties_to_json(self):
         """Return UserDefinedSegment specific properties."""

splitio/models/grammar/matchers/misc.py

@@ -35,8 +35,14 @@ def _match(self, key, attributes=None, context=None):
         assert evaluator is not None
 
         bucketing_key = context.get('bucketing_key')
-
-        result = evaluator.evaluate_feature(self._split_name, key, bucketing_key, attributes)
+        dependent_split = None
+        condition_matchers = {}
+        for split in context.get("dependent_splits"):
+            if split[0].name == self._split_name:
+                dependent_split = split[0]
+                condition_matchers = split[1]
+                break
+        result = evaluator.evaluate_feature(dependent_split, key, bucketing_key, condition_matchers, attributes)
         return result['treatment'] in self._treatments
 
     def _add_matcher_specific_properties_to_json(self):

tests/models/grammar/test_matchers.py

@@ -6,13 +6,16 @@
 import json
 import os.path
 import re
+import pytest
 
 from datetime import datetime
 
 from splitio.models.grammar import matchers
+from splitio.models import splits
+from splitio.models.grammar import condition
 from splitio.storage import SegmentStorage
 from splitio.engine.evaluator import Evaluator
-
+from tests.integration import splits_json
 
 class MatcherTestsBase(object):
     """Abstract class to make sure we test all relevant methods."""
@@ -398,26 +401,12 @@ def test_from_raw(self, mocker):
     def test_matcher_behaviour(self, mocker):
         """Test if the matcher works properly."""
         matcher = matchers.UserDefinedSegmentMatcher(self.raw)
-        segment_storage = mocker.Mock(spec=SegmentStorage)
 
         # Test that if the key if the storage wrapper finds the key in the segment, it matches.
-        segment_storage.segment_contains.return_value = True
-        assert matcher.evaluate('some_key', {}, {'segment_storage': segment_storage}) is True
+        assert matcher.evaluate('some_key', {}, {'segment_matchers':{'some_segment': True} }) is True
 
         # Test that if the key if the storage wrapper doesn't find the key in the segment, it fails.
-        segment_storage.segment_contains.return_value = False
-        assert matcher.evaluate('some_key', {}, {'segment_storage': segment_storage}) is False
-
-        assert segment_storage.segment_contains.mock_calls == [
-            mocker.call('some_segment', 'some_key'),
-            mocker.call('some_segment', 'some_key')
-        ]
-
-        assert matcher.evaluate([], {}, {'segment_storage': segment_storage}) is False
-        assert matcher.evaluate({}, {}, {'segment_storage': segment_storage}) is False
-        assert matcher.evaluate(123, {}, {'segment_storage': segment_storage}) is False
-        assert matcher.evaluate(True, {}, {'segment_storage': segment_storage}) is False
-        assert matcher.evaluate(False, {}, {'segment_storage': segment_storage}) is False
+        assert matcher.evaluate('some_key', {}, {'segment_matchers':{'some_segment': False}}) is False
 
     def test_to_json(self):
         """Test that the object serializes to JSON properly."""
@@ -784,30 +773,36 @@ def test_from_raw(self, mocker):
 
     def test_matcher_behaviour(self, mocker):
         """Test if the matcher works properly."""
-        parsed = matchers.DependencyMatcher(self.raw)
+        cond_raw = self.raw.copy()
+        cond_raw['dependencyMatcherData']['split'] = 'SPLIT_2'
+        parsed = matchers.DependencyMatcher(cond_raw)
         evaluator = mocker.Mock(spec=Evaluator)
 
+        cond = condition.from_raw(splits_json["splitChange1_1"]["splits"][0]['conditions'][0])
+        split = splits.from_raw(splits_json["splitChange1_1"]["splits"][0])
+
         evaluator.evaluate_feature.return_value = {'treatment': 'on'}
-        assert parsed.evaluate('test1', {}, {'bucketing_key': 'buck', 'evaluator': evaluator}) is True
+        assert parsed.evaluate('SPLIT_2', {}, {'bucketing_key': 'buck', 'evaluator': evaluator, 'dependent_splits': [(split, [cond])]}) is True
 
         evaluator.evaluate_feature.return_value = {'treatment': 'off'}
-        assert parsed.evaluate('test1', {}, {'bucketing_key': 'buck', 'evaluator': evaluator}) is False
+#        pytest.set_trace()
+        assert parsed.evaluate('SPLIT_2', {}, {'bucketing_key': 'buck', 'evaluator': evaluator, 'dependent_splits': [(split, [cond])]}) is False
 
         assert evaluator.evaluate_feature.mock_calls == [
-            mocker.call('some_split', 'test1', 'buck', {}),
-            mocker.call('some_split', 'test1', 'buck', {})
+            mocker.call(split, 'SPLIT_2', 'buck', [cond], {}),
+            mocker.call(split, 'SPLIT_2', 'buck', [cond], {})
         ]
 
-        assert parsed.evaluate([], {}, {'bucketing_key': 'buck', 'evaluator': evaluator}) is False
-        assert parsed.evaluate({}, {}, {'bucketing_key': 'buck', 'evaluator': evaluator}) is False
-        assert parsed.evaluate(123, {}, {'bucketing_key': 'buck', 'evaluator': evaluator}) is False
-        assert parsed.evaluate(object(), {}, {'bucketing_key': 'buck', 'evaluator': evaluator}) is False
+        assert parsed.evaluate([], {}, {'bucketing_key': 'buck', 'evaluator': evaluator, 'dependent_splits': [(split, [cond])]}) is False
+        assert parsed.evaluate({}, {}, {'bucketing_key': 'buck', 'evaluator': evaluator, 'dependent_splits': [(split, [cond])]}) is False
+        assert parsed.evaluate(123, {}, {'bucketing_key': 'buck', 'evaluator': evaluator, 'dependent_splits': [(split, [cond])]}) is False
+        assert parsed.evaluate(object(), {}, {'bucketing_key': 'buck', 'evaluator': evaluator, 'dependent_splits': [(split, [cond])]}) is False
 
     def test_to_json(self):
         """Test that the object serializes to JSON properly."""
         as_json = matchers.DependencyMatcher(self.raw).to_json()
         assert as_json['matcherType'] == 'IN_SPLIT_TREATMENT'
-        assert as_json['dependencyMatcherData']['split'] == 'some_split'
+        assert as_json['dependencyMatcherData']['split'] == 'SPLIT_2'
         assert as_json['dependencyMatcherData']['treatments'] == ['on', 'almost_on']