def setUp(self):
self._split_parser = SplitParser(object())
matcher = {
'matcherType': 'PART_OF_SET',
'whitelistMatcherData': {'whitelist': ['ABC', 'DEF', 'GHI']}
}
split = {'conditions': [{'matcher': matcher}]}
self._matcher = (self._split_parser._parse_matcher(split, matcher)
._matcher.delegate)
def setUp(self):
self._split_parser = SplitParser(object())
matcher = {
'matcherType': 'EQUAL_TO_BOOLEAN',
'booleanMatcherData': True
}
split = {'conditions': [{'matcher': matcher}]}
self._matcher = (self._split_parser._parse_matcher(split, matcher)
._matcher.delegate)
def setUp(self):
self._split_parser = SplitParser(object())
matcher = {
'matcherType': 'MATCHES_STRING',
'stringMatcherData': '[a-z]'
}
split = {'conditions': [{'matcher': matcher}]}
self._matcher = (self._split_parser._parse_matcher(split, matcher)
._matcher.delegate)
def setUp(self):
self._split_parser = SplitParser(object())
matcher = {
'matcherType': 'IN_SPLIT_TREATMENT',
'dependencyMatcherData': {
'split': 'someSplit',
'treatments': ['on']
}
}
split = {'conditions': [{'matcher': matcher}]}
self._matcher = (self._split_parser._parse_matcher(split, matcher)
._matcher.delegate)
self._mock = self.patch('splitio.clients.MatcherClient')
class SplitParserParseCombinerTests(TestCase):
def setUp(self):
self.some_segment_fetcher = mock.MagicMock()
self.parser = SplitParser(self.some_segment_fetcher)
def test_returns_and_combiner(self):
"""Tests that _parse_combiner returns an AndCombiner"""
self.assertIsInstance(self.parser._parse_combiner('AND'), AndCombiner)
def test_raises_exception_on_invalid_combiner(self):
"""Tests that _parse_combiner raises an exception on an invalid combiner"""
with self.assertRaises(ValueError):
self.parser._parse_combiner('foobar')
class BooleanMatcherTests(TestCase, MockUtilsMixin):
def setUp(self):
self._split_parser = SplitParser(object())
matcher = {
'matcherType': 'EQUAL_TO_BOOLEAN',
'booleanMatcherData': True
}
split = {'conditions': [{'matcher': matcher}]}
self._matcher = (self._split_parser._parse_matcher(split, matcher)
._matcher.delegate)
def test_matcher_construction(self):
'''
Tests that the correct matcher matcher is constructed.
'''
self.assertIsInstance(self._matcher, BooleanMatcher)
def test_different_keys(self):
'''
Test how different types get parsed
'''
self.assertTrue(self._matcher.match(True))
self.assertTrue(self._matcher.match('tRue'))
self.assertFalse(self._matcher.match(False))
self.assertFalse(self._matcher.match('False'))
self.assertFalse(self._matcher.match(''))
self.assertFalse(self._matcher.match({}))
class RegexMatcherTests(TestCase, MockUtilsMixin):
def setUp(self):
self._split_parser = SplitParser(object())
matcher = {
'matcherType': 'MATCHES_STRING',
'stringMatcherData': '[a-z]'
}
split = {'conditions': [{'matcher': matcher}]}
self._matcher = (self._split_parser._parse_matcher(split, matcher)
._matcher.delegate)
def test_matcher_construction(self):
'''
Tests that the correct matcher matcher is constructed.
'''
self.assertIsInstance(self._matcher, RegexMatcher)
def test_regexes(self):
'''
Test different regexes lodeded from regex.txt
'''
current_path = os.path.dirname(__file__)
with open(os.path.join(current_path, 'regex.txt')) as flo:
lines = [line for line in flo]
lines.pop() # Remove empy last line
for line in lines:
regex, text, res = line.split('#')
matcher = RegexMatcher(regex)
print(regex, text, res)
self.assertEquals(matcher.match(text), json.loads(res))
class DependencyMatcherTests(TestCase, MockUtilsMixin):
def setUp(self):
self._split_parser = SplitParser(object())
matcher = {
'matcherType': 'IN_SPLIT_TREATMENT',
'dependencyMatcherData': {
'split': 'someSplit',
'treatments': ['on']
}
}
split = {'conditions': [{'matcher': matcher}]}
self._matcher = (self._split_parser._parse_matcher(split, matcher)
._matcher.delegate)
self._mock = self.patch('splitio.clients.MatcherClient')
def test_matcher_construction(self):
'''
Tests that the correct matcher matcher is constructed.
'''
self.assertIsInstance(self._matcher, DependencyMatcher)
def test_matcher_client_is_created_and_get_treatment_called(self):
self._matcher.match('abc', None, self._mock)
self._mock.get_treatment.assert_called_once_with('abc', 'someSplit', None)
self.assertTrue(True)
def setUp(self):
self.some_partial_split = mock.MagicMock()
self.some_segment_fetcher = mock.MagicMock()
self.combining_matcher_mock = self.patch(
'splitio.splits.CombiningMatcher')
self.parser = SplitParser(self.some_segment_fetcher)
self.parse_matcher_mock = self.patch_object(self.parser,
'_parse_matcher')
self.parse_matcher_side_effect = [mock.MagicMock() for _ in range(2)]
self.parse_matcher_mock.side_effect = self.parse_matcher_side_effect
self.parse_combiner_mock = self.patch_object(self.parser,
'_parse_combiner')
self.some_matchers = [mock.MagicMock(), mock.MagicMock()]
self.some_matcher_group = {
'matchers': self.some_matchers,
'combiner': mock.MagicMock()
}
def setUp(self):
self.some_partial_split = mock.MagicMock()
self.some_segment_fetcher = mock.MagicMock()
self.some_matcher = mock.MagicMock()
self.parser = SplitParser(self.some_segment_fetcher)
self.get_matcher_data_data_type_mock = self.patch_object(
self.parser, '_get_matcher_data_data_type')
self.equal_to_matcher_mock = self.patch(
'splitio.splits.EqualToMatcher')
self.greater_than_or_equal_to_matcher_mock = self.patch(
'splitio.splits.GreaterThanOrEqualToMatcher')
self.less_than_or_equal_to_matcher_mock = self.patch(
'splitio.splits.LessThanOrEqualToMatcher')
self.between_matcher_mock = self.patch('splitio.splits.BetweenMatcher')
self.some_in_segment_matcher = {
'matcherType': 'IN_SEGMENT',
'userDefinedSegmentMatcherData': {
'segmentName': mock.MagicMock()
}
}
self.some_whitelist_matcher = {
'matcherType': 'WHITELIST',
'whitelistMatcherData': {
'whitelist': mock.MagicMock()
}
}
self.some_equal_to_matcher = self._get_unary_number_matcher('EQUAL_TO')
self.some_greater_than_or_equal_to_matcher = self._get_unary_number_matcher(
'GREATER_THAN_OR_EQUAL_TO')
self.some_less_than_or_equal_to_matcher = self._get_unary_number_matcher(
'LESS_THAN_OR_EQUAL_TO')
self.some_between_matcher = {
'matcherType': 'BETWEEN',
'betweenMatcherData': {
'start': mock.MagicMock(),
'end': mock.MagicMock(),
}
}
def setUp(self):
self.some_partial_split = mock.MagicMock()
self.some_segment_fetcher = mock.MagicMock()
self.some_matcher = mock.MagicMock()
self.parser = SplitParser(self.some_segment_fetcher)
self.parse_matcher_all_keys_mock = self.patch_object(
self.parser, '_parse_matcher_all_keys')
self.parse_matcher_in_segment_mock = self.patch_object(
self.parser, '_parse_matcher_in_segment')
self.parse_matcher_whitelist_mock = self.patch_object(
self.parser, '_parse_matcher_whitelist')
self.parse_matcher_equal_to_mock = self.patch_object(
self.parser, '_parse_matcher_equal_to')
self.parse_matcher_greater_than_or_equal_to_mock = self.patch_object(
self.parser, '_parse_matcher_greater_than_or_equal_to')
self.parse_matcher_less_than_or_equal_to_mock = self.patch_object(
self.parser, '_parse_matcher_less_than_or_equal_to')
self.parse_matcher_between_mock = self.patch_object(
self.parser, '_parse_matcher_between')
self.parser._parse_matcher_fake = mock.MagicMock()
def _build_split_fetcher(self):
"""
Build the json backed split fetcher
:return: The json backed split fetcher
:rtype: JSONFileSplitFetcher
"""
segment_fetcher = JSONFileSegmentFetcher(self._segment_changes_file_name)
split_parser = SplitParser(segment_fetcher)
split_fetcher = JSONFileSplitFetcher(
self._split_changes_file_name,
split_parser
)
return split_fetcher
class SplitParserParseTests(TestCase, MockUtilsMixin):
def setUp(self):
self.some_split = mock.MagicMock()
self.some_segment_fetcher = mock.MagicMock()
self.parser = SplitParser(self.some_segment_fetcher)
self.internal_parse_mock = self.patch_object(self.parser, '_parse')
def test_parse_calls_internal_parse(self):
"""Tests that parse calls _parse with block_until_ready as False"""
self.parser.parse(self.some_split)
self.internal_parse_mock.assert_called_once_with(
self.some_split, block_until_ready=False)
def test_parse_calls_internal_parse_with_block_until_ready(self):
"""Tests that parse calls _parse passing the value of block_until_ready"""
self.parser.parse(self.some_split, block_until_ready=True)
self.internal_parse_mock.assert_called_once_with(
self.some_split, block_until_ready=True)
def test_parse_returns_none_if_internal_parse_raises_an_exception(self):
"""Tests that parse returns None if _parse raises an exception"""
self.internal_parse_mock.side_effect = Exception()
self.assertIsNone(self.parser.parse(self.some_split))
class ContainsStringMatcherTests(TestCase, MockUtilsMixin):
def setUp(self):
self._split_parser = SplitParser(object())
matcher = {
'matcherType': 'CONTAINS_STRING',
'whitelistMatcherData': {'whitelist': ['ABC', 'DEF', 'GHI']}
}
split = {'conditions': [{'matcher': matcher}]}
self._matcher = (self._split_parser._parse_matcher(split, matcher)
._matcher.delegate)
def test_matcher_construction(self):
'''
Tests that the correct matcher matcher is constructed.
'''
self.assertIsInstance(self._matcher, ContainsStringMatcher)
def test_keys_with_string(self):
'''
Test that keys starting with one of the prefixes in the condition match
'''
self.assertTrue(self._matcher.match('testABC'))
self.assertTrue(self._matcher.match('testDEFabc'))
self.assertTrue(self._matcher.match('GHI3214'))
def test_keys_without_string_dont_match(self):
'''
Test that keys that dont start with one of the prefixes don't match.
'''
self.assertFalse(self._matcher.match('testJKL'))
self.assertFalse(self._matcher.match('test123'))
self.assertFalse(self._matcher.match('testdl_'))
def test_empty_string_doesnt_match(self):
'''
Tests that the empty string doesn't match.
'''
self.assertFalse(self._matcher.match(''))
def test_none_doesnt_match(self):
'''
Tests that None doesn't match.
'''
self.assertFalse(self._matcher.match(None))
class StartsWithMatcherTests(TestCase, MockUtilsMixin):
def setUp(self):
self._split_parser = SplitParser(object())
matcher = {
'matcherType': 'STARTS_WITH',
'whitelistMatcherData': {'whitelist': ['ABC', 'DEF', 'GHI']}
}
split = {'conditions': [{'matcher': matcher}]}
self._matcher = (self._split_parser._parse_matcher(split, matcher)
._matcher.delegate)
def test_matcher_construction(self):
'''
Tests that the correct matcher matcher is constructed.
'''
self.assertIsInstance(self._matcher, StartsWithMatcher)
def test_keys_with_prefix_match(self):
'''
Test that keys starting with one of the prefixes in the condition match
'''
self.assertTrue(self._matcher.match('ABCtest'))
self.assertTrue(self._matcher.match('DEFtest'))
self.assertTrue(self._matcher.match('GHItest'))
def test_keys_without_prefix_dont_match(self):
'''
Test that keys that dont start with one of the prefixes don't match.
'''
self.assertFalse(self._matcher.match('JKLtest'))
self.assertFalse(self._matcher.match('123test'))
self.assertFalse(self._matcher.match('dl_test'))
def test_empty_string_doesnt_match(self):
'''
Tests that the empty string doesn't match.
'''
self.assertFalse(self._matcher.match(''))
def test_none_doesnt_match(self):
'''
Tests that None doesn't match.
'''
self.assertFalse(self._matcher.match(None))
class PartOfSetMatcherTests(TestCase, MockUtilsMixin):
def setUp(self):
self._split_parser = SplitParser(object())
matcher = {
'matcherType': 'PART_OF_SET',
'whitelistMatcherData': {'whitelist': ['ABC', 'DEF', 'GHI']}
}
split = {'conditions': [{'matcher': matcher}]}
self._matcher = (self._split_parser._parse_matcher(split, matcher)
._matcher.delegate)
def test_matcher_construction(self):
'''
Tests that the correct matcher matcher is constructed.
'''
self.assertIsInstance(self._matcher, PartOfSetMatcher)
def test_subset_of_set_matches(self):
'''
Test that a subset of the set matches
'''
self.assertTrue(self._matcher.match(['ABC', 'DEF', 'GHI']))
self.assertTrue(self._matcher.match(['ABC']))
def test_not_subset_of_set_doesnt_match(self):
'''
Test that any set with elements that are not in the split's set doesn't
match
'''
self.assertFalse(self._matcher.match(['ABC', 'DEF', 'GHI', 'AWE']))
self.assertFalse(self._matcher.match(['RFV']))
def test_empty_set_doesnt_match(self):
'''
Tests that an empty set doesn't match
'''
self.assertFalse(self._matcher.match([]))
def test_none_doesnt_match(self):
'''
Tests that None doesn't match.
'''
self.assertFalse(self._matcher.match(None))
def _build_split_fetcher(self):
"""
Build the self refreshing split fetcher
:return: The self refreshing split fetcher
:rtype: SelfRefreshingSplitFetcher
"""
segment_change_fetcher = ApiSegmentChangeFetcher(self._sdk_api)
segment_fetcher = SelfRefreshingSegmentFetcher(
segment_change_fetcher,
interval=self._segment_fetcher_interval
)
split_change_fetcher = ApiSplitChangeFetcher(self._sdk_api)
split_parser = SplitParser(segment_fetcher)
split_fetcher = SelfRefreshingSplitFetcher(
split_change_fetcher,
split_parser,
interval=self._split_fetcher_interval
)
return split_fetcher
class ContainsAnyOfSetMatcherTests(TestCase, MockUtilsMixin):
def setUp(self):
self._split_parser = SplitParser(object())
matcher = {
'matcherType': 'CONTAINS_ANY_OF_SET',
'whitelistMatcherData': {'whitelist': ['ABC', 'DEF', 'GHI']}
}
split = {'conditions': [{'matcher': matcher}]}
self._matcher = (self._split_parser._parse_matcher(split, matcher)
._matcher.delegate)
def test_matcher_construction(self):
'''
Tests that the correct matcher matcher is constructed.
'''
self.assertIsInstance(self._matcher, ContainsAnyOfSetMatcher)
def test_set_with_at_least_one_key(self):
'''
Test that a set with at least one key matches
'''
self.assertTrue(self._matcher.match(['ABC', 'DEF', 'GHI']))
self.assertTrue(self._matcher.match(['ABC', 'DEF', 'GHI', 'AWE']))
self.assertTrue(self._matcher.match(['ABC', 'DEF']))
def test_set_without_any_key_doesnt_match(self):
'''
Test that a set without any the keys doesn't match
'''
self.assertFalse(self._matcher.match(['AWE']))
def test_empty_set_doesnt_match(self):
'''
Tests that an empty set doesn't match
'''
self.assertFalse(self._matcher.match([]))
def test_none_doesnt_match(self):
'''
Tests that None doesn't match.
'''
self.assertFalse(self._matcher.match(None))
class EqualToSetMatcherTests(TestCase, MockUtilsMixin):
def setUp(self):
self._split_parser = SplitParser(object())
matcher = {
'matcherType': 'EQUAL_TO_SET',
'whitelistMatcherData': {'whitelist': ['ABC', 'DEF', 'GHI']}
}
split = {'conditions': [{'matcher': matcher}]}
self._matcher = (self._split_parser._parse_matcher(split, matcher)
._matcher.delegate)
def test_matcher_construction(self):
'''
Tests that the correct matcher matcher is constructed.
'''
self.assertIsInstance(self._matcher, EqualToSetMatcher)
def test_equal_set_matches(self):
'''
Test that the exact same set matches
'''
self.assertTrue(self._matcher.match(['ABC', 'DEF', 'GHI']))
def test_different_set_doesnt_match(self):
'''
Test that a different set doesn't match
'''
self.assertFalse(self._matcher.match(['ABC', 'DEF', 'GHI', 'AWE']))
self.assertFalse(self._matcher.match(['ABC']))
def test_empty_set_doesnt_match(self):
'''
Tests that an empty set doesn't match
'''
self.assertFalse(self._matcher.match([]))
def test_none_doesnt_match(self):
'''
Tests that None doesn't match.
'''
self.assertFalse(self._matcher.match(None))
def setUp(self):
self.some_split = mock.MagicMock()
self.some_segment_fetcher = mock.MagicMock()
self.parser = SplitParser(self.some_segment_fetcher)
self.internal_parse_mock = self.patch_object(self.parser, '_parse')
class SplitParserParseMatcherTests(TestCase, MockUtilsMixin):
def setUp(self):
self.some_partial_split = mock.MagicMock()
self.some_segment_fetcher = mock.MagicMock()
self.some_matcher = mock.MagicMock()
self.parser = SplitParser(self.some_segment_fetcher)
self.parse_matcher_all_keys_mock = self.patch_object(
self.parser, '_parse_matcher_all_keys')
self.parse_matcher_in_segment_mock = self.patch_object(
self.parser, '_parse_matcher_in_segment')
self.parse_matcher_whitelist_mock = self.patch_object(
self.parser, '_parse_matcher_whitelist')
self.parse_matcher_equal_to_mock = self.patch_object(
self.parser, '_parse_matcher_equal_to')
self.parse_matcher_greater_than_or_equal_to_mock = self.patch_object(
self.parser, '_parse_matcher_greater_than_or_equal_to')
self.parse_matcher_less_than_or_equal_to_mock = self.patch_object(
self.parser, '_parse_matcher_less_than_or_equal_to')
self.parse_matcher_between_mock = self.patch_object(
self.parser, '_parse_matcher_between')
self.parser._parse_matcher_fake = mock.MagicMock()
def _get_matcher(self, matcher_type):
return {
'matcherType': matcher_type,
'negate': mock.MagicMock(),
'keySelector': {
'attribute': mock.MagicMock()
}
}
def test_calls_parse_matcher_all_keys(self):
"""Test that _parse_matcher calls _parse_matcher_all_keys on ALL_KEYS matcher"""
matcher = self._get_matcher('ALL_KEYS')
self.parser._parse_matcher(self.some_partial_split, matcher)
self.parse_matcher_all_keys_mock.assert_called_once_with(
self.some_partial_split, matcher, block_until_ready=False)
def test_calls_parse_matcher_in_segment(self):
"""Test that _parse_matcher calls _parse_matcher_in_segment on IN_SEGMENT matcher"""
matcher = self._get_matcher('IN_SEGMENT')
self.parser._parse_matcher(self.some_partial_split, matcher)
self.parse_matcher_in_segment_mock.assert_called_once_with(
self.some_partial_split, matcher, block_until_ready=False)
def test_calls_parse_matcher_whitelist(self):
"""Test that _parse_matcher calls _parse_matcher_in_segment on WHITELIST matcher"""
matcher = self._get_matcher('WHITELIST')
self.parser._parse_matcher(self.some_partial_split, matcher)
self.parse_matcher_whitelist_mock.assert_called_once_with(
self.some_partial_split, matcher, block_until_ready=False)
def test_calls_parse_matcher_equal_to(self):
"""Test that _parse_matcher calls _parse_matcher_equal_to on EQUAL_TO matcher"""
matcher = self._get_matcher('EQUAL_TO')
self.parser._parse_matcher(self.some_partial_split, matcher)
self.parse_matcher_equal_to_mock.assert_called_once_with(
self.some_partial_split, matcher, block_until_ready=False)
def test_calls_parse_matcher_greater_than_or_equal_to(self):
"""
Test that _parse_matcher calls _parse_matcher_greater_than_or_equal_to on
GREATER_THAN_OR_EQUAL_TO matcher
"""
matcher = self._get_matcher('GREATER_THAN_OR_EQUAL_TO')
self.parser._parse_matcher(self.some_partial_split, matcher)
self.parse_matcher_greater_than_or_equal_to_mock.assert_called_once_with(
self.some_partial_split, matcher, block_until_ready=False)
def test_calls_parse_matcher_less_than_or_equal_to(self):
"""
Test that _parse_matcher calls _parse_matcher_less_than_or_equal_to on
LESS_THAN_OR_EQUAL_TO matcher
"""
matcher = self._get_matcher('LESS_THAN_OR_EQUAL_TO')
self.parser._parse_matcher(self.some_partial_split, matcher)
self.parse_matcher_less_than_or_equal_to_mock.assert_called_once_with(
self.some_partial_split, matcher, block_until_ready=False)
def test_calls_parse_matcher_between(self):
"""Test that _parse_matcher calls _parse_between on BETWEEN matcher"""
matcher = self._get_matcher('BETWEEN')
self.parser._parse_matcher(self.some_partial_split, matcher)
self.parse_matcher_between_mock.assert_called_once_with(
self.some_partial_split, matcher, block_until_ready=False)
def test_raises_exception_if_parse_method_returns_none(self):
"""
Tests that _parse_matcher raises an exception if the specific parse method returns None
"""
self.parser._parse_matcher_fake.return_value = None
with self.assertRaises(ValueError):
self.parser._parse_matcher(self.some_partial_split,
self._get_matcher('FAKE'))
def test_returns_attribute_matcher(self):
"""Tests that _parse_matcher returns an AttributeMatcher"""
self.assertIsInstance(
self.parser._parse_matcher(self.some_partial_split,
self._get_matcher('FAKE')),
AttributeMatcher)
class SplitParserInternalParseTests(TestCase, MockUtilsMixin):
def setUp(self):
self.some_split = mock.MagicMock()
self.some_segment_fetcher = mock.MagicMock()
self.some_block_until_ready = mock.MagicMock()
self.partition_mock = self.patch('splitio.splits.Partition')
self.partition_mock_side_effect = [mock.MagicMock() for _ in range(3)]
self.partition_mock.side_effect = self.partition_mock_side_effect
self.condition_mock = self.patch('splitio.splits.Condition')
self.condition_mock_side_effect = [mock.MagicMock() for _ in range(2)]
self.condition_mock.side_effect = self.condition_mock_side_effect
self.parser = SplitParser(self.some_segment_fetcher)
self.parse_split_mock = self.patch_object(self.parser, '_parse_split')
self.parse_matcher_group_mock = self.patch_object(
self.parser, '_parse_matcher_group')
self.parse_matcher_group_mock_side_effect = [
mock.MagicMock() for _ in range(2)
]
self.parse_matcher_group_mock.side_effect = self.parse_matcher_group_mock_side_effect
self.partition_0 = {
'treatment': mock.MagicMock(),
'size': mock.MagicMock()
}
self.partition_1 = {
'treatment': mock.MagicMock(),
'size': mock.MagicMock()
}
self.partition_2 = {
'treatment': mock.MagicMock(),
'size': mock.MagicMock()
}
self.matcher_group_0 = mock.MagicMock()
self.matcher_group_1 = mock.MagicMock()
self.label_0 = mock.MagicMock()
self.label_1 = mock.MagicMock()
self.some_split = {
'status':
'ACTIVE',
'name':
mock.MagicMock(),
'seed':
mock.MagicMock(),
'killed':
mock.MagicMock(),
'defaultTreatment':
mock.MagicMock(),
'conditions': [{
'matcherGroup': self.matcher_group_0,
'partitions': [self.partition_0],
'label': self.label_0
}, {
'matcherGroup': self.matcher_group_1,
'partitions': [self.partition_1, self.partition_2],
'label': self.label_1
}]
}
def test_returns_none_if_status_is_not_active(self):
"""Tests that _parse returns None if split is not ACTIVE"""
self.assertIsNone(self.parser._parse({'status': 'ARCHIVED'}))
def test_creates_partition_on_each_condition_partition(self):
"""Test that _parse calls Partition constructor on each partition"""
self.parser._parse(self.some_split)
self.assertListEqual([
mock.call(self.partition_0['treatment'], self.partition_0['size']),
mock.call(self.partition_1['treatment'], self.partition_1['size']),
mock.call(self.partition_2['treatment'], self.partition_2['size'])
], self.partition_mock.call_args_list)
def test_calls_parse_matcher_group_on_each_matcher_group(self):
"""Tests that _parse calls _parse_matcher_group on each matcher group with the default
value for block_until_ready"""
self.parser._parse(self.some_split)
self.assertListEqual([
mock.call(self.parse_split_mock.return_value,
self.matcher_group_0,
block_until_ready=False),
mock.call(self.parse_split_mock.return_value,
self.matcher_group_1,
block_until_ready=False)
], self.parse_matcher_group_mock.call_args_list)
def test_calls_parse_matcher_group_on_each_matcher_group_with_block_until_ready(
self):
"""Tests that _parse calls _parse_matcher_group on each matcher group with the passed
value for block_until_ready"""
some_block_until_ready = mock.MagicMock()
self.parser._parse(self.some_split,
block_until_ready=some_block_until_ready)
self.assertListEqual([
mock.call(self.parse_split_mock.return_value,
self.matcher_group_0,
block_until_ready=some_block_until_ready),
mock.call(self.parse_split_mock.return_value,
self.matcher_group_1,
block_until_ready=some_block_until_ready)
], self.parse_matcher_group_mock.call_args_list)
def test_creates_condition_on_each_condition(self):
"""Tests that _parse calls Condition constructor on each condition"""
self.parser._parse(self.some_split)
self.assertListEqual([
mock.call(self.parse_matcher_group_mock_side_effect[0],
[self.partition_mock_side_effect[0]], self.label_0,
ConditionType.WHITELIST),
mock.call(self.parse_matcher_group_mock_side_effect[1], [
self.partition_mock_side_effect[1],
self.partition_mock_side_effect[2]
], self.label_1, ConditionType.WHITELIST)
], self.condition_mock.call_args_list)
def test_calls_parse_split(self):
"""Tests that _parse calls _parse_split"""
self.parser._parse(self.some_split,
block_until_ready=self.some_block_until_ready)
self.parse_split_mock.assert_called_once_with(
self.some_split, block_until_ready=self.some_block_until_ready)
class SplitParserMatcherParseMethodsTests(TestCase, MockUtilsMixin):
def setUp(self):
self.some_partial_split = mock.MagicMock()
self.some_segment_fetcher = mock.MagicMock()
self.some_matcher = mock.MagicMock()
self.parser = SplitParser(self.some_segment_fetcher)
self.get_matcher_data_data_type_mock = self.patch_object(
self.parser, '_get_matcher_data_data_type')
self.equal_to_matcher_mock = self.patch(
'splitio.splits.EqualToMatcher')
self.greater_than_or_equal_to_matcher_mock = self.patch(
'splitio.splits.GreaterThanOrEqualToMatcher')
self.less_than_or_equal_to_matcher_mock = self.patch(
'splitio.splits.LessThanOrEqualToMatcher')
self.between_matcher_mock = self.patch('splitio.splits.BetweenMatcher')
self.some_in_segment_matcher = {
'matcherType': 'IN_SEGMENT',
'userDefinedSegmentMatcherData': {
'segmentName': mock.MagicMock()
}
}
self.some_whitelist_matcher = {
'matcherType': 'WHITELIST',
'whitelistMatcherData': {
'whitelist': mock.MagicMock()
}
}
self.some_equal_to_matcher = self._get_unary_number_matcher('EQUAL_TO')
self.some_greater_than_or_equal_to_matcher = self._get_unary_number_matcher(
'GREATER_THAN_OR_EQUAL_TO')
self.some_less_than_or_equal_to_matcher = self._get_unary_number_matcher(
'LESS_THAN_OR_EQUAL_TO')
self.some_between_matcher = {
'matcherType': 'BETWEEN',
'betweenMatcherData': {
'start': mock.MagicMock(),
'end': mock.MagicMock(),
}
}
def _get_unary_number_matcher(self, matcher_type):
return {
'matcherType': matcher_type,
'unaryNumericMatcherData': {
'dataType': mock.MagicMock(),
'value': mock.MagicMock()
}
}
def test_parse_matcher_all_keys_returns_all_keys_matcher(self):
"""Tests that _parser_matcher_all_keys returns an AllKeysMatcher"""
self.assertIsInstance(
self.parser._parse_matcher_all_keys(self.some_partial_split,
self.some_matcher),
AllKeysMatcher)
def test_parse_matcher_in_segment_calls_segment_fetcher_fetch(self):
"""Tests that _parse_matcher_in_segment calls segment_fetcher fetch method with default
value for block_until_ready"""
self.parser._parse_matcher_in_segment(self.some_partial_split,
self.some_in_segment_matcher)
self.some_segment_fetcher.fetch.assert_called_once_with(
self.some_in_segment_matcher['userDefinedSegmentMatcherData']
['segmentName'],
block_until_ready=False)
def test_parse_matcher_in_segment_calls_segment_fetcher_fetch_block(self):
"""Tests that _parse_matcher_in_segment calls segment_fetcher fetch method with supploed
value for block_until_ready"""
some_block_until_ready = mock.MagicMock()
self.parser._parse_matcher_in_segment(
self.some_partial_split,
self.some_in_segment_matcher,
block_until_ready=some_block_until_ready)
self.some_segment_fetcher.fetch.assert_called_once_with(
self.some_in_segment_matcher['userDefinedSegmentMatcherData']
['segmentName'],
block_until_ready=some_block_until_ready)
def test_parse_matcher_in_segment_returns_user_defined_segment_matcher(
self):
"""Tests that _parse_matcher_in_segment calls segment_fetcher fetch method"""
self.assertIsInstance(
self.parser._parse_matcher_in_segment(
self.some_partial_split, self.some_in_segment_matcher),
UserDefinedSegmentMatcher)
def test_parse_matcher_whitelist_returns_whitelist_matcher(self):
"""Tests that _parse_matcher_whitelist returns a WhitelistMatcher"""
self.assertIsInstance(
self.parser._parse_matcher_whitelist(self.some_partial_split,
self.some_whitelist_matcher),
WhitelistMatcher)
def test_parse_matcher_equal_to_calls_equal_to_matcher_for_data_type(self):
"""Tests that _parse_matcher_equal_to calls EqualToMatcher.for_data_type"""
self.parser._parse_matcher_equal_to(self.some_partial_split,
self.some_equal_to_matcher)
self.equal_to_matcher_mock.for_data_type.assert_called_once_with(
self.get_matcher_data_data_type_mock.return_value,
self.some_equal_to_matcher['unaryNumericMatcherData']['value'])
def test_parse_matcher_equal_to_returns_equal_to_matcher(self):
"""
Tests that _parse_matcher_equal_to returns the result of calling
EqualToMatcher.for_data_type
"""
self.assertEqual(
self.equal_to_matcher_mock.for_data_type.return_value,
self.parser._parse_matcher_equal_to(self.some_partial_split,
self.some_equal_to_matcher))
def test_parse_matcher_greater_than_or_equal_to_calls_equal_to_matcher_for_data_type(
self):
"""
Tests that _parse_matcher_greater_than_or_equal_to calls
GreaterThanOrEqualToMatcher.for_data_type
"""
self.parser._parse_matcher_greater_than_or_equal_to(
self.some_partial_split,
self.some_greater_than_or_equal_to_matcher)
self.greater_than_or_equal_to_matcher_mock.for_data_type.assert_called_once_with(
self.get_matcher_data_data_type_mock.return_value,
self.some_greater_than_or_equal_to_matcher[
'unaryNumericMatcherData']['value'])
def test_parse_matcher_greater_than_or_equal_to_returns_equal_to_matcher(
self):
"""
Tests that _parse_matcher_greater_than_or_equal_to returns the result of calling
GreaterThanOrEqualToMatcher.for_data_type
"""
self.assertEqual(
self.greater_than_or_equal_to_matcher_mock.for_data_type.
return_value,
self.parser._parse_matcher_greater_than_or_equal_to(
self.some_partial_split,
self.some_greater_than_or_equal_to_matcher))
def test_parse_matcher_less_than_or_equal_to_calls_equal_to_matcher_for_data_type(
self):
"""
Tests that _parse_matcher_less_than_or_equal_to calls
LessThanOrEqualToMatcher.for_data_type
"""
self.parser._parse_matcher_less_than_or_equal_to(
self.some_partial_split, self.some_less_than_or_equal_to_matcher)
self.less_than_or_equal_to_matcher_mock.for_data_type.assert_called_once_with(
self.get_matcher_data_data_type_mock.return_value,
self.some_less_than_or_equal_to_matcher['unaryNumericMatcherData']
['value'])
def test_parse_matcher_less_than_or_equal_to_returns_equal_to_matcher(
self):
"""
Tests that _parse_matcher_less_than_or_equal_to returns the result of calling
LessThanOrEqualToMatcher.for_data_type
"""
self.assertEqual(
self.less_than_or_equal_to_matcher_mock.for_data_type.return_value,
self.parser._parse_matcher_less_than_or_equal_to(
self.some_partial_split,
self.some_less_than_or_equal_to_matcher))
def test_parse_matcher_between_calls_between_matcher_for_data_type(self):
"""Tests that _parse_matcher_between calls BetweenMatcher.for_data_type"""
self.parser._parse_matcher_between(self.some_partial_split,
self.some_between_matcher)
self.between_matcher_mock.for_data_type.assert_called_once_with(
self.get_matcher_data_data_type_mock.return_value,
self.some_between_matcher['betweenMatcherData']['start'],
self.some_between_matcher['betweenMatcherData']['end'])
def test_parse_matcher_between_returns_between_matcher(self):
"""
Tests that _parse_matcher_between returns the result of calling
BetweenMatcher.for_data_type
"""
self.assertEqual(
self.between_matcher_mock.for_data_type.return_value,
self.parser._parse_matcher_between(self.some_partial_split,
self.some_between_matcher))
def setUp(self):
self.some_segment_fetcher = mock.MagicMock()
self.parser = SplitParser(self.some_segment_fetcher)
def setUp(self):
self.some_split = mock.MagicMock()
self.some_segment_fetcher = mock.MagicMock()
self.some_block_until_ready = mock.MagicMock()
self.partition_mock = self.patch('splitio.splits.Partition')
self.partition_mock_side_effect = [mock.MagicMock() for _ in range(3)]
self.partition_mock.side_effect = self.partition_mock_side_effect
self.condition_mock = self.patch('splitio.splits.Condition')
self.condition_mock_side_effect = [mock.MagicMock() for _ in range(2)]
self.condition_mock.side_effect = self.condition_mock_side_effect
self.parser = SplitParser(self.some_segment_fetcher)
self.parse_split_mock = self.patch_object(self.parser, '_parse_split')
self.parse_matcher_group_mock = self.patch_object(
self.parser, '_parse_matcher_group')
self.parse_matcher_group_mock_side_effect = [
mock.MagicMock() for _ in range(2)
]
self.parse_matcher_group_mock.side_effect = self.parse_matcher_group_mock_side_effect
self.partition_0 = {
'treatment': mock.MagicMock(),
'size': mock.MagicMock()
}
self.partition_1 = {
'treatment': mock.MagicMock(),
'size': mock.MagicMock()
}
self.partition_2 = {
'treatment': mock.MagicMock(),
'size': mock.MagicMock()
}
self.matcher_group_0 = mock.MagicMock()
self.matcher_group_1 = mock.MagicMock()
self.label_0 = mock.MagicMock()
self.label_1 = mock.MagicMock()
self.some_split = {
'status':
'ACTIVE',
'name':
mock.MagicMock(),
'seed':
mock.MagicMock(),
'killed':
mock.MagicMock(),
'defaultTreatment':
mock.MagicMock(),
'conditions': [{
'matcherGroup': self.matcher_group_0,
'partitions': [self.partition_0],
'label': self.label_0
}, {
'matcherGroup': self.matcher_group_1,
'partitions': [self.partition_1, self.partition_2],
'label': self.label_1
}]
}
class SplitParserParseMatcherGroupTests(TestCase, MockUtilsMixin):
def setUp(self):
self.some_partial_split = mock.MagicMock()
self.some_segment_fetcher = mock.MagicMock()
self.combining_matcher_mock = self.patch(
'splitio.splits.CombiningMatcher')
self.parser = SplitParser(self.some_segment_fetcher)
self.parse_matcher_mock = self.patch_object(self.parser,
'_parse_matcher')
self.parse_matcher_side_effect = [mock.MagicMock() for _ in range(2)]
self.parse_matcher_mock.side_effect = self.parse_matcher_side_effect
self.parse_combiner_mock = self.patch_object(self.parser,
'_parse_combiner')
self.some_matchers = [mock.MagicMock(), mock.MagicMock()]
self.some_matcher_group = {
'matchers': self.some_matchers,
'combiner': mock.MagicMock()
}
def test_calls_parse_matcher_on_each_matcher(self):
"""Tests that _parse_matcher_group calls _parse_matcher on each matcher with the default
value for block_until_ready"""
self.parser._parse_matcher_group(self.some_partial_split,
self.some_matcher_group)
self.assertListEqual([
mock.call(self.some_partial_split,
self.some_matchers[0],
block_until_ready=False),
mock.call(self.some_partial_split,
self.some_matchers[1],
block_until_ready=False)
], self.parse_matcher_mock.call_args_list)
def test_calls_parse_matcher_with_block_until_ready_parameter(self):
"""Tests that _parse_matcher_group calls _parse_matcher on each matcher"""
some_block_until_ready = mock.MagicMock
self.parser._parse_matcher_group(
self.some_partial_split,
self.some_matcher_group,
block_until_ready=some_block_until_ready)
self.assertListEqual([
mock.call(self.some_partial_split,
self.some_matchers[0],
block_until_ready=some_block_until_ready),
mock.call(self.some_partial_split,
self.some_matchers[1],
block_until_ready=some_block_until_ready)
], self.parse_matcher_mock.call_args_list)
def test_calls_parse_combiner_on_combiner(self):
"""Tests that _parse_matcher_group calls _parse_combiner on combiner"""
self.parser._parse_matcher_group(self.some_partial_split,
self.some_matcher_group)
self.parse_combiner_mock.assert_called_once_with(
self.some_matcher_group['combiner'])
def test_creates_combining_matcher(self):
"""Tests that _parse_matcher_group calls CombiningMatcher constructor"""
self.parser._parse_matcher_group(self.some_partial_split,
self.some_matcher_group)
self.combining_matcher_mock.assert_called_once_with(
self.parse_combiner_mock.return_value,
self.parse_matcher_side_effect)
def test_returns_combining_matcher(self):
"""Tests that _parse_matcher_group returns a CombiningMatcher"""
self.assertEqual(
self.combining_matcher_mock.return_value,
self.parser._parse_matcher_group(self.some_partial_split,
self.some_matcher_group))
