integration e2e tests

Author: chillaq

tests/integration/test_client_e2e.py

@@ -15,6 +15,8 @@
     InMemorySegmentStorage, InMemorySplitStorage, InMemoryTelemetryStorage
 from splitio.storage.redis import RedisEventsStorage, RedisImpressionsStorage, \
     RedisSplitStorage, RedisSegmentStorage, RedisTelemetryStorage
+from splitio.storage.pluggable import PluggableEventsStorage, PluggableImpressionsStorage, PluggableSegmentStorage, \
+    PluggableTelemetryStorage, PluggableSplitStorage
 from splitio.storage.adapters.redis import build, RedisAdapter
 from splitio.models import splits, segments
 from splitio.engine.impressions.impressions import Manager as ImpressionsManager, ImpressionsMode
@@ -25,8 +27,13 @@
 from splitio.recorder.recorder import StandardRecorder, PipelinedRecorder
 from splitio.client.config import DEFAULT_CONFIG
 from splitio.sync.synchronizer import SplitTasks, SplitSynchronizers, Synchronizer
-from splitio.sync.manager import Manager
+from splitio.sync.manager import Manager, RedisManager
+from splitio.sync.synchronizer import PluggableSynchronizer
+
 from tests.integration import splits_json
+from tests.storage.test_pluggable import StorageMockAdapter
+
+
 class InMemoryIntegrationTests(object):
     """Inmemory storage-based integration tests."""
 
@@ -1124,3 +1131,324 @@ def test_localhost_e2e(self):
         event = threading.Event()
         factory.destroy(event)
         event.wait()
+
+
+class PluggableIntegrationTests(object):
+    """Pluggable storage-based integration tests."""
+
+    def setup_method(self):
+        """Prepare storages with test data."""
+        metadata = SdkMetadata('python-1.2.3', 'some_ip', 'some_name')
+        self.pluggable_storage_adapter = StorageMockAdapter()
+        split_storage = PluggableSplitStorage(self.pluggable_storage_adapter, 'myprefix')
+        segment_storage = PluggableSegmentStorage(self.pluggable_storage_adapter, 'myprefix')
+
+        telemetry_pluggable_storage = PluggableTelemetryStorage(self.pluggable_storage_adapter, metadata, 'myprefix')
+        telemetry_producer = TelemetryStorageProducer(telemetry_pluggable_storage)
+        telemetry_consumer = TelemetryStorageConsumer(telemetry_pluggable_storage)
+        telemetry_runtime_producer = telemetry_producer.get_telemetry_runtime_producer()
+
+        storages = {
+            'splits': split_storage,
+            'segments': segment_storage,
+            'impressions': PluggableImpressionsStorage(self.pluggable_storage_adapter, metadata),
+            'events': PluggableEventsStorage(self.pluggable_storage_adapter, metadata),
+            'telemetry': telemetry_pluggable_storage
+        }
+
+        impmanager = ImpressionsManager(StrategyDebugMode(), telemetry_runtime_producer) # no listener
+        recorder = StandardRecorder(impmanager, storages['events'],
+                                    storages['impressions'], storages['telemetry'])
+
+        self.factory = SplitFactory('some_api_key',
+                                    storages,
+                                    True,
+                                    recorder,
+                                    RedisManager(PluggableSynchronizer()),
+                                    sdk_ready_flag=None,
+                                    telemetry_producer=telemetry_producer,
+                                    telemetry_init_producer=telemetry_producer.get_telemetry_init_producer(),
+                                    )  # pylint:disable=attribute-defined-outside-init
+
+        # Adding data to storage
+        split_fn = os.path.join(os.path.dirname(__file__), 'files', 'splitChanges.json')
+        with open(split_fn, 'r') as flo:
+            data = json.loads(flo.read())
+        for split in data['splits']:
+            self.pluggable_storage_adapter.set(split_storage._prefix.format(split_name=split['name']), split)
+        self.pluggable_storage_adapter.set(split_storage._split_till_prefix, data['till'])
+
+        segment_fn = os.path.join(os.path.dirname(__file__), 'files', 'segmentEmployeesChanges.json')
+        with open(segment_fn, 'r') as flo:
+            data = json.loads(flo.read())
+        self.pluggable_storage_adapter.set(segment_storage._prefix.format(segment_name=data['name']), set(data['added']))
+        self.pluggable_storage_adapter.set(segment_storage._segment_till_prefix.format(segment_name=data['name']), data['till'])
+
+        segment_fn = os.path.join(os.path.dirname(__file__), 'files', 'segmentHumanBeignsChanges.json')
+        with open(segment_fn, 'r') as flo:
+            data = json.loads(flo.read())
+        self.pluggable_storage_adapter.set(segment_storage._prefix.format(segment_name=data['name']), set(data['added']))
+        self.pluggable_storage_adapter.set(segment_storage._segment_till_prefix.format(segment_name=data['name']), data['till'])
+
+
+    def _validate_last_events(self, client, *to_validate):
+        """Validate the last N impressions are present disregarding the order."""
+        event_storage = client._factory._get_storage('events')
+        events_raw = []
+        if self.pluggable_storage_adapter.get(event_storage._events_queue_key) is not None:
+            events_raw = [json.loads(im) for im in self.pluggable_storage_adapter.get(event_storage._events_queue_key)]
+
+        as_tup_set = set(
+            (i['e']['key'], i['e']['trafficTypeName'], i['e']['eventTypeId'], i['e']['value'], str(i['e']['properties']))
+            for i in events_raw
+        )
+        assert as_tup_set == set(to_validate)
+
+    def _validate_last_impressions(self, client, *to_validate):
+        """Validate the last N impressions are present disregarding the order."""
+        imp_storage = client._factory._get_storage('impressions')
+        impressions_raw = []
+        if self.pluggable_storage_adapter.get(imp_storage._impressions_queue_key) is not None:
+            impressions_raw = [json.loads(im) for im in self.pluggable_storage_adapter.get(imp_storage._impressions_queue_key)]
+        as_tup_set = set(
+            (i['i']['f'], i['i']['k'], i['i']['t'])
+            for i in impressions_raw
+        )
+
+        assert as_tup_set == set(to_validate)
+        self.pluggable_storage_adapter.delete(imp_storage._impressions_queue_key)
+
+    def test_get_treatment(self):
+        """Test client.get_treatment()."""
+        client = self.factory.client()
+
+        assert client.get_treatment('user1', 'sample_feature') == 'on'
+        self._validate_last_impressions(client, ('sample_feature', 'user1', 'on'))
+
+        assert client.get_treatment('invalidKey', 'sample_feature') == 'off'
+        self._validate_last_impressions(client, ('sample_feature', 'invalidKey', 'off'))
+
+        assert client.get_treatment('invalidKey', 'invalid_feature') == 'control'
+        self._validate_last_impressions(client)
+
+        # testing a killed feature. No matter what the key, must return default treatment
+        assert client.get_treatment('invalidKey', 'killed_feature') == 'defTreatment'
+        self._validate_last_impressions(client, ('killed_feature', 'invalidKey', 'defTreatment'))
+
+        # testing ALL matcher
+        assert client.get_treatment('invalidKey', 'all_feature') == 'on'
+        self._validate_last_impressions(client, ('all_feature', 'invalidKey', 'on'))
+
+        # testing WHITELIST matcher
+        assert client.get_treatment('whitelisted_user', 'whitelist_feature') == 'on'
+        self._validate_last_impressions(client, ('whitelist_feature', 'whitelisted_user', 'on'))
+        assert client.get_treatment('unwhitelisted_user', 'whitelist_feature') == 'off'
+        self._validate_last_impressions(client, ('whitelist_feature', 'unwhitelisted_user', 'off'))
+
+        #  testing INVALID matcher
+        assert client.get_treatment('some_user_key', 'invalid_matcher_feature') == 'control'
+        self._validate_last_impressions(client)
+
+        #  testing Dependency matcher
+        assert client.get_treatment('somekey', 'dependency_test') == 'off'
+        self._validate_last_impressions(client, ('dependency_test', 'somekey', 'off'))
+
+        #  testing boolean matcher
+        assert client.get_treatment('True', 'boolean_test') == 'on'
+        self._validate_last_impressions(client, ('boolean_test', 'True', 'on'))
+
+        #  testing regex matcher
+        assert client.get_treatment('abc4', 'regex_test') == 'on'
+        self._validate_last_impressions(client, ('regex_test', 'abc4', 'on'))
+
+    def test_get_treatment_with_config(self):
+        """Test client.get_treatment_with_config()."""
+        client = self.factory.client()
+
+        result = client.get_treatment_with_config('user1', 'sample_feature')
+        assert result == ('on', '{"size":15,"test":20}')
+        self._validate_last_impressions(client, ('sample_feature', 'user1', 'on'))
+
+        result = client.get_treatment_with_config('invalidKey', 'sample_feature')
+        assert result == ('off', None)
+        self._validate_last_impressions(client, ('sample_feature', 'invalidKey', 'off'))
+
+        result = client.get_treatment_with_config('invalidKey', 'invalid_feature')
+        assert result == ('control', None)
+        self._validate_last_impressions(client)
+
+        # testing a killed feature. No matter what the key, must return default treatment
+        result = client.get_treatment_with_config('invalidKey', 'killed_feature')
+        assert ('defTreatment', '{"size":15,"defTreatment":true}') == result
+        self._validate_last_impressions(client, ('killed_feature', 'invalidKey', 'defTreatment'))
+
+        # testing ALL matcher
+        result = client.get_treatment_with_config('invalidKey', 'all_feature')
+        assert result == ('on', None)
+        self._validate_last_impressions(client, ('all_feature', 'invalidKey', 'on'))
+
+    def test_get_treatments(self):
+        """Test client.get_treatments()."""
+        client = self.factory.client()
+
+        result = client.get_treatments('user1', ['sample_feature'])
+        assert len(result) == 1
+        assert result['sample_feature'] == 'on'
+        self._validate_last_impressions(client, ('sample_feature', 'user1', 'on'))
+
+        result = client.get_treatments('invalidKey', ['sample_feature'])
+        assert len(result) == 1
+        assert result['sample_feature'] == 'off'
+        self._validate_last_impressions(client, ('sample_feature', 'invalidKey', 'off'))
+
+        result = client.get_treatments('invalidKey', ['invalid_feature'])
+        assert len(result) == 1
+        assert result['invalid_feature'] == 'control'
+        self._validate_last_impressions(client)
+
+        # testing a killed feature. No matter what the key, must return default treatment
+        result = client.get_treatments('invalidKey', ['killed_feature'])
+        assert len(result) == 1
+        assert result['killed_feature'] == 'defTreatment'
+        self._validate_last_impressions(client, ('killed_feature', 'invalidKey', 'defTreatment'))
+
+        # testing ALL matcher
+        result = client.get_treatments('invalidKey', ['all_feature'])
+        assert len(result) == 1
+        assert result['all_feature'] == 'on'
+        self._validate_last_impressions(client, ('all_feature', 'invalidKey', 'on'))
+
+        # testing multiple splitNames
+        result = client.get_treatments('invalidKey', [
+            'all_feature',
+            'killed_feature',
+            'invalid_feature',
+            'sample_feature'
+        ])
+        assert len(result) == 4
+        assert result['all_feature'] == 'on'
+        assert result['killed_feature'] == 'defTreatment'
+        assert result['invalid_feature'] == 'control'
+        assert result['sample_feature'] == 'off'
+        self._validate_last_impressions(
+            client,
+            ('all_feature', 'invalidKey', 'on'),
+            ('killed_feature', 'invalidKey', 'defTreatment'),
+            ('sample_feature', 'invalidKey', 'off')
+        )
+
+    def test_get_treatments_with_config(self):
+        """Test client.get_treatments_with_config()."""
+        client = self.factory.client()
+
+        result = client.get_treatments_with_config('user1', ['sample_feature'])
+        assert len(result) == 1
+        assert result['sample_feature'] == ('on', '{"size":15,"test":20}')
+        self._validate_last_impressions(client, ('sample_feature', 'user1', 'on'))
+
+        result = client.get_treatments_with_config('invalidKey', ['sample_feature'])
+        assert len(result) == 1
+        assert result['sample_feature'] == ('off', None)
+        self._validate_last_impressions(client, ('sample_feature', 'invalidKey', 'off'))
+
+        result = client.get_treatments_with_config('invalidKey', ['invalid_feature'])
+        assert len(result) == 1
+        assert result['invalid_feature'] == ('control', None)
+        self._validate_last_impressions(client)
+
+        # testing a killed feature. No matter what the key, must return default treatment
+        result = client.get_treatments_with_config('invalidKey', ['killed_feature'])
+        assert len(result) == 1
+        assert result['killed_feature'] == ('defTreatment', '{"size":15,"defTreatment":true}')
+        self._validate_last_impressions(client, ('killed_feature', 'invalidKey', 'defTreatment'))
+
+        # testing ALL matcher
+        result = client.get_treatments_with_config('invalidKey', ['all_feature'])
+        assert len(result) == 1
+        assert result['all_feature'] == ('on', None)
+        self._validate_last_impressions(client, ('all_feature', 'invalidKey', 'on'))
+
+        # testing multiple splitNames
+        result = client.get_treatments_with_config('invalidKey', [
+            'all_feature',
+            'killed_feature',
+            'invalid_feature',
+            'sample_feature'
+        ])
+        assert len(result) == 4
+        assert result['all_feature'] == ('on', None)
+        assert result['killed_feature'] == ('defTreatment', '{"size":15,"defTreatment":true}')
+        assert result['invalid_feature'] == ('control', None)
+        assert result['sample_feature'] == ('off', None)
+        self._validate_last_impressions(
+            client,
+            ('all_feature', 'invalidKey', 'on'),
+            ('killed_feature', 'invalidKey', 'defTreatment'),
+            ('sample_feature', 'invalidKey', 'off'),
+        )
+
+    def test_track(self):
+        """Test client.track()."""
+        client = self.factory.client()
+        assert(client.track('user1', 'user', 'conversion', 1, {"prop1": "value1"}))
+        assert(not client.track(None, 'user', 'conversion'))
+        assert(not client.track('user1', None, 'conversion'))
+        assert(not client.track('user1', 'user', None))
+        self._validate_last_events(
+            client,
+            ('user1', 'user', 'conversion', 1, "{'prop1': 'value1'}")
+        )
+
+    def test_manager_methods(self):
+        """Test manager.split/splits."""
+        try:
+            manager = self.factory.manager()
+        except:
+            pass
+        result = manager.split('all_feature')
+        assert result.name == 'all_feature'
+        assert result.traffic_type is None
+        assert result.killed is False
+        assert len(result.treatments) == 2
+        assert result.change_number == 123
+        assert result.configs == {}
+
+        result = manager.split('killed_feature')
+        assert result.name == 'killed_feature'
+        assert result.traffic_type is None
+        assert result.killed is True
+        assert len(result.treatments) == 2
+        assert result.change_number == 123
+        assert result.configs['defTreatment'] == '{"size":15,"defTreatment":true}'
+        assert result.configs['off'] == '{"size":15,"test":20}'
+
+        result = manager.split('sample_feature')
+        assert result.name == 'sample_feature'
+        assert result.traffic_type is None
+        assert result.killed is False
+        assert len(result.treatments) == 2
+        assert result.change_number == 123
+        assert result.configs['on'] == '{"size":15,"test":20}'
+
+        assert len(manager.split_names()) == 7
+        assert len(manager.splits()) == 7
+
+    def teardown_method(self):
+        """Clear redis cache."""
+        keys_to_delete = [
+            "SPLITIO.segment.human_beigns",
+            "SPLITIO.segment.employees.till",
+            "SPLITIO.split.sample_feature",
+            "SPLITIO.splits.till",
+            "SPLITIO.split.killed_feature",
+            "SPLITIO.split.all_feature",
+            "SPLITIO.split.whitelist_feature",
+            "SPLITIO.segment.employees",
+            "SPLITIO.split.regex_test",
+            "SPLITIO.segment.human_beigns.till",
+            "SPLITIO.split.boolean_test",
+            "SPLITIO.split.dependency_test"
+        ]
+
+        for key in keys_to_delete:
+            self.pluggable_storage_adapter.delete(key)