Beispiel #1
0
 def test_get_changenumber(self, mocker):
     """Test fetching changenumber."""
     adapter = mocker.Mock(spec=RedisAdapter)
     storage = RedisSplitStorage(adapter)
     adapter.get.return_value = '-1'
     assert storage.get_change_number() == -1
     assert adapter.get.mock_calls == [mocker.call('SPLITIO.splits.till')]
    def test_put_fetch(self):
        """Test storing and retrieving splits in redis."""
        adapter = _build_default_client({})
        try:
            storage = RedisSplitStorage(adapter)
            with open(
                    os.path.join(os.path.dirname(__file__), 'files',
                                 'split_changes.json'), 'r') as flo:
                split_changes = json.load(flo)

            split_objects = [
                splits.from_raw(raw) for raw in split_changes['splits']
            ]
            for split_object in split_objects:
                raw = split_object.to_json()
                adapter.set(
                    RedisSplitStorage._SPLIT_KEY.format(
                        split_name=split_object.name), json.dumps(raw))

            original_splits = {split.name: split for split in split_objects}
            fetched_splits = {
                name: storage.get(name)
                for name in original_splits.keys()
            }

            assert set(original_splits.keys()) == set(fetched_splits.keys())

            for original_split in original_splits.values():
                fetched_split = fetched_splits[original_split.name]
                assert original_split.traffic_type_name == fetched_split.traffic_type_name
                assert original_split.seed == fetched_split.seed
                assert original_split.algo == fetched_split.algo
                assert original_split.status == fetched_split.status
                assert original_split.change_number == fetched_split.change_number
                assert original_split.killed == fetched_split.killed
                assert original_split.default_treatment == fetched_split.default_treatment
                for index, original_condition in enumerate(
                        original_split.conditions):
                    fetched_condition = fetched_split.conditions[index]
                    assert original_condition.label == fetched_condition.label
                    assert original_condition.condition_type == fetched_condition.condition_type
                    assert len(original_condition.matchers) == len(
                        fetched_condition.matchers)
                    assert len(original_condition.partitions) == len(
                        fetched_condition.partitions)

            adapter.set(RedisSplitStorage._SPLIT_TILL_KEY,
                        split_changes['till'])
            assert storage.get_change_number() == split_changes['till']
        finally:
            to_delete = [
                "SPLITIO.split.sample_feature", "SPLITIO.splits.till",
                "SPLITIO.split.all_feature", "SPLITIO.split.killed_feature",
                "SPLITIO.split.Risk_Max_Deductible",
                "SPLITIO.split.whitelist_feature", "SPLITIO.split.regex_test",
                "SPLITIO.split.boolean_test", "SPLITIO.split.dependency_test"
            ]
            for item in to_delete:
                adapter.delete(item)