Fixed tests

chillaq · chillaq · commit 6931e0649fef · 2023-01-19T13:47:31.000-08:00
diff --git a/tests/client/test_client.py b/tests/client/test_client.py
@@ -53,8 +53,8 @@ def test_get_treatment(self, mocker):
             mocker.Mock(),
             mocker.Mock(),
             telemetry_producer,
-            telemetry_consumer.get_telemetry_init_consumer(),
-            mocker.Mock()
+            telemetry_producer.get_telemetry_init_producer(),
+            mocker.Mock(),
         )
 
         client = Client(factory, recorder, True)
@@ -122,7 +122,7 @@ def test_get_treatment_with_config(self, mocker):
             mocker.Mock(),
             mocker.Mock(),
             telemetry_producer,
-            telemetry_consumer.get_telemetry_init_consumer(),
+            telemetry_producer.get_telemetry_init_producer(),
             mocker.Mock()
         )
 
@@ -199,7 +199,7 @@ def test_get_treatments(self, mocker):
             mocker.Mock(),
             mocker.Mock(),
             telemetry_producer,
-            telemetry_consumer.get_telemetry_init_consumer(),
+            telemetry_producer.get_telemetry_init_producer(),
             mocker.Mock()
         )
 
@@ -272,7 +272,7 @@ def test_get_treatments_with_config(self, mocker):
             mocker.Mock(),
             mocker.Mock(),
             telemetry_producer,
-            telemetry_consumer.get_telemetry_init_consumer(),
+            telemetry_producer.get_telemetry_init_producer(),
             mocker.Mock()
         )
 
@@ -349,7 +349,7 @@ def test_destroy(self, mocker):
             mocker.Mock(),
             mocker.Mock(),
             telemetry_producer,
-            telemetry_consumer.get_telemetry_init_consumer(),
+            telemetry_producer.get_telemetry_init_producer(),
             mocker.Mock()
         )
 
@@ -381,7 +381,7 @@ def test_track(self, mocker):
             mocker.Mock(),
             mocker.Mock(),
             telemetry_producer,
-            telemetry_consumer.get_telemetry_init_consumer(),
+            telemetry_producer.get_telemetry_init_producer(),
             mocker.Mock()
         )
 
@@ -418,7 +418,7 @@ def test_evaluations_before_running_post_fork(self, mocker):
             mocker.Mock(),
             mocker.Mock(),
             telemetry_producer,
-            telemetry_consumer.get_telemetry_init_consumer(),
+            telemetry_producer.get_telemetry_init_producer(),
             mocker.Mock(),
             True
         )
@@ -468,7 +468,7 @@ def test_telemetry_not_ready(self, mocker):
             mocker.Mock(),
             mocker.Mock(),
             telemetry_producer,
-            telemetry_consumer.get_telemetry_init_consumer(),
+            telemetry_producer.get_telemetry_init_producer(),
             mocker.Mock()
         )
         client = Client(factory, mocker.Mock())
@@ -506,7 +506,7 @@ def test_telemetry_record_treatment_exception(self, mocker):
             impmanager,
             mocker.Mock(),
             telemetry_producer,
-            telemetry_consumer.get_telemetry_init_consumer(),
+            telemetry_producer.get_telemetry_init_producer(),
             mocker.Mock()
         )
         client = Client(factory, recorder, True)
@@ -550,7 +550,7 @@ def test_telemetry_record_treatments_exception(self, mocker):
             impmanager,
             mocker.Mock(),
             telemetry_producer,
-            telemetry_consumer.get_telemetry_init_consumer(),
+            telemetry_producer.get_telemetry_init_producer(),
             mocker.Mock()
         )
         client = Client(factory, recorder, True)
@@ -593,7 +593,7 @@ def test_telemetry_method_latency(self, mocker):
             impmanager,
             mocker.Mock(),
             telemetry_producer,
-            telemetry_consumer.get_telemetry_init_consumer(),
+            telemetry_producer.get_telemetry_init_producer(),
             mocker.Mock()
         )
         client = Client(factory, recorder, True)
@@ -635,7 +635,7 @@ def test_telemetry_track_exception(self, mocker):
             impmanager,
             mocker.Mock(),
             telemetry_producer,
-            telemetry_consumer.get_telemetry_init_consumer(),
+            telemetry_producer.get_telemetry_init_producer(),
             mocker.Mock()
         )
         client = Client(factory, recorder, True)
diff --git a/tests/client/test_input_validator.py b/tests/client/test_input_validator.py
@@ -553,7 +553,7 @@ def test_track(self, mocker):
             impmanager,
             mocker.Mock(),
             telemetry_producer,
-            telemetry_consumer.get_telemetry_init_consumer(),
+            telemetry_producer.get_telemetry_init_producer(),
             mocker.Mock()
         )
         factory._apikey = 'some-test'
@@ -828,7 +828,7 @@ def test_get_treatments(self, mocker):
             impmanager,
             mocker.Mock(),
             telemetry_producer,
-            telemetry_consumer.get_telemetry_init_consumer(),
+            telemetry_producer.get_telemetry_init_producer(),
             mocker.Mock()
         )
         ready_mock = mocker.PropertyMock()
@@ -969,7 +969,7 @@ def test_get_treatments_with_config(self, mocker):
             impmanager,
             mocker.Mock(),
             telemetry_producer,
-            telemetry_consumer.get_telemetry_init_consumer(),
+            telemetry_producer.get_telemetry_init_producer(),
             mocker.Mock()
         )
 
@@ -1105,7 +1105,7 @@ def test_split_(self, mocker):
             impmanager,
             mocker.Mock(),
             telemetry_producer,
-            telemetry_consumer.get_telemetry_init_consumer(),
+            telemetry_producer.get_telemetry_init_producer(),
             mocker.Mock()
         )
 
diff --git a/tests/client/test_manager.py b/tests/client/test_manager.py
@@ -31,7 +31,7 @@ def test_evaluations_before_running_post_fork(self, mocker):
             impmanager,
             mocker.Mock(),
             telemetry_producer,
-            telemetry_consumer.get_telemetry_init_consumer(),
+            telemetry_producer.get_telemetry_init_producer(),
             mocker.Mock(),
             True
         )
diff --git a/tests/integration/test_client_e2e.py b/tests/integration/test_client_e2e.py
@@ -72,7 +72,7 @@ def setup_method(self):
                                     recorder,
                                     None,
                                     telemetry_producer=telemetry_producer,
-                                    telemetry_init_consumer=telemetry_consumer.get_telemetry_init_consumer(),
+                                    telemetry_init_producer=telemetry_producer.get_telemetry_init_producer(),
                                     )  # pylint:disable=attribute-defined-outside-init
         except:
             pass
@@ -348,7 +348,7 @@ def setup_method(self):
                                     recorder,
                                     None,
                                     telemetry_producer=telemetry_producer,
-                                    telemetry_init_consumer=telemetry_consumer.get_telemetry_init_consumer(),
+                                    telemetry_init_producer=telemetry_producer.get_telemetry_init_producer(),
                                     )  # pylint:disable=attribute-defined-outside-init
 
     def _validate_last_impressions(self, client, *to_validate):
@@ -578,7 +578,7 @@ def setup_method(self):
                                     True,
                                     recorder,
                                     telemetry_producer=telemetry_producer,
-                                    telemetry_init_consumer=telemetry_consumer.get_telemetry_init_consumer(),
+                                    telemetry_init_producer=telemetry_producer.get_telemetry_init_producer(),
                                     )  # pylint:disable=attribute-defined-outside-init
 
     def _validate_last_impressions(self, client, *to_validate):
@@ -870,7 +870,7 @@ def setup_method(self):
                                     True,
                                     recorder,
                                     telemetry_producer=telemetry_producer,
-                                    telemetry_init_consumer=telemetry_consumer.get_telemetry_init_consumer(),
+                                    telemetry_init_producer=telemetry_producer.get_telemetry_init_producer(),
                                     )  # pylint:disable=attribute-defined-outside-init
 
 class LocalhostIntegrationTests(object):  # pylint: disable=too-few-public-methods
diff --git a/tests/recorder/test_recorder.py b/tests/recorder/test_recorder.py
@@ -2,15 +2,14 @@
 
 import pytest
 
-from splitio.client.util import get_method_constant
 from splitio.recorder.recorder import StandardRecorder, PipelinedRecorder
 from splitio.engine.impressions.impressions import Manager as ImpressionsManager
 from splitio.engine.telemetry import TelemetryStorageProducer
 from splitio.storage.inmemmory import EventStorage, ImpressionStorage, InMemoryTelemetryStorage
 from splitio.storage.redis import ImpressionPipelinedStorage, EventStorage, RedisEventsStorage, RedisImpressionsStorage, RedisTelemetryStorage
 from splitio.storage.adapters.redis import RedisAdapter
 from splitio.models.impressions import Impression
-
+from splitio.models.telemetry import MethodExceptionsAndLatencies
 
 
 class StandardRecorderTests(object):
@@ -34,10 +33,10 @@ def record_latency(*args, **kwargs):
         telemetry_storage.record_latency.side_effect = record_latency
 
         recorder = StandardRecorder(impmanager, event, impression, telemetry_producer.get_telemetry_evaluation_producer())
-        recorder.record_treatment_stats(impressions, 1, 'some', 'get_treatment')
+        recorder.record_treatment_stats(impressions, 1, MethodExceptionsAndLatencies.TREATMENT, 'get_treatment')
 
         assert recorder._impression_storage.put.mock_calls[0][1][0] == impressions
-        assert(self.passed_args[0] == get_method_constant('treatment'))
+        assert(self.passed_args[0] == MethodExceptionsAndLatencies.TREATMENT)
         assert(self.passed_args[1] == 1)
 
     def test_pipelined_recorder(self, mocker):
@@ -51,13 +50,12 @@ def test_pipelined_recorder(self, mocker):
         event = mocker.Mock(spec=RedisEventsStorage)
         impression = mocker.Mock(spec=RedisImpressionsStorage)
         recorder = PipelinedRecorder(redis, impmanager, event, impression, mocker.Mock())
-        recorder.record_treatment_stats(impressions, 1, 'some', 'get_treatment')
+        recorder.record_treatment_stats(impressions, 1, MethodExceptionsAndLatencies.TREATMENT, 'get_treatment')
 #        pytest.set_trace()
         assert recorder._impression_storage.add_impressions_to_pipe.mock_calls[0][1][0] == impressions
-        assert recorder._telemetry_redis_storage.add_latency_to_pipe.mock_calls[0][1][0] == 'treatment'
+        assert recorder._telemetry_redis_storage.add_latency_to_pipe.mock_calls[0][1][0] == MethodExceptionsAndLatencies.TREATMENT
         assert recorder._telemetry_redis_storage.add_latency_to_pipe.mock_calls[0][1][1] == 1
 
-
     def test_sampled_recorder(self, mocker):
         impressions = [
             Impression('k1', 'f1', 'on', 'l1', 123, None, None),
diff --git a/tests/storage/test_redis.py b/tests/storage/test_redis.py
@@ -6,14 +6,14 @@
 import unittest.mock as mock
 import pytest
 
-from splitio.client.util import get_metadata, SdkMetadata, get_method_constant
+from splitio.client.util import get_metadata, SdkMetadata
 from splitio.storage.redis import RedisEventsStorage, RedisImpressionsStorage, \
     RedisSegmentStorage, RedisSplitStorage, RedisTelemetryStorage
 from splitio.storage.adapters.redis import RedisAdapter, RedisAdapterException, build
 from splitio.models.segments import Segment
 from splitio.models.impressions import Impression
 from splitio.models.events import Event, EventWrapper
-from splitio.models.telemetry import MethodExceptions, MethodLatencies, TelemetryConfig
+from splitio.models.telemetry import MethodExceptions, MethodLatencies, TelemetryConfig, MethodExceptionsAndLatencies
 
 
 class RedisSplitStorageTests(object):
@@ -394,8 +394,6 @@ def test_init(self, mocker):
         assert(isinstance(redis_telemetry._method_latencies, MethodLatencies))
         assert(isinstance(redis_telemetry._method_exceptions, MethodExceptions))
         assert(isinstance(redis_telemetry._tel_config, TelemetryConfig))
-        assert(redis_telemetry.host_ip is not None)
-        assert(redis_telemetry.host_name is not None)
         assert(redis_telemetry._make_pipe is not None)
 
     @mock.patch('splitio.models.telemetry.TelemetryConfig.record_config')
@@ -419,7 +417,8 @@ def test_format_config_stats(self, mocker):
             'aF': stats['aF'],
             'rF': stats['rF'],
             'sT': stats['sT'],
-            'oM': stats['oM']
+            'oM': stats['oM'],
+            't': redis_telemetry.pop_config_tags()
         }))
 
     def test_record_active_and_redundant_factories(self, mocker):
@@ -441,12 +440,12 @@ def _mocked_hincrby(*args, **kwargs):
         redis_telemetry = RedisTelemetryStorage(adapter, metadata)
         pipe = adapter._decorated.pipeline()
         with mock.patch('redis.client.Pipeline.hincrby', _mocked_hincrby):
-            redis_telemetry.add_latency_to_pipe('treatment', 20, pipe)
+            redis_telemetry.add_latency_to_pipe(MethodExceptionsAndLatencies.TREATMENT, 20, pipe)
 
     def test_record_exception(self, mocker):
         def _mocked_hincrby(*args, **kwargs):
             assert(args[1] == RedisTelemetryStorage._TELEMETRY_EXCEPTIONS_KEY)
-            assert(args[2][-9:] == 'treatment')
+            assert(args[2] == 'python-1.1.1/hostname/ip/treatment')
             assert(args[3] == 1)
 
         adapter = build({})
@@ -455,7 +454,7 @@ def _mocked_hincrby(*args, **kwargs):
         with mock.patch('redis.client.Pipeline.hincrby', _mocked_hincrby):
             with mock.patch('redis.client.Pipeline.execute') as mock_method:
                 mock_method.return_value = [1]
-                redis_telemetry.record_exception(get_method_constant('treatment'))
+                redis_telemetry.record_exception(MethodExceptionsAndLatencies.TREATMENT)
 
     def test_expire_latency_keys(self, mocker):
         redis_telemetry = RedisTelemetryStorage(mocker.Mock(), mocker.Mock())
diff --git a/tests/sync/test_telemetry.py b/tests/sync/test_telemetry.py
@@ -1,40 +1,41 @@
 """Telemetry Worker tests."""
 import unittest.mock as mock
 import json
-from splitio.sync.telemetry import TelemetrySynchronizer, TelemetrySubmitter
+from splitio.sync.telemetry import TelemetrySynchronizer, InMemoryTelemetrySubmitter
 from splitio.engine.telemetry import TelemetryEvaluationConsumer, TelemetryInitConsumer, TelemetryRuntimeConsumer, TelemetryStorageConsumer
 from splitio.storage.inmemmory import InMemoryTelemetryStorage, InMemorySegmentStorage, InMemorySplitStorage
 from splitio.models.splits import Split, Status
 from splitio.models.segments import Segment
 from splitio.models.telemetry import StreamingEvents
+from splitio.api.telemetry import TelemetryAPI
 
 class TelemetrySynchronizerTests(object):
     """Telemetry synchronizer test cases."""
 
-    @mock.patch('splitio.sync.telemetry.TelemetrySubmitter.synchronize_config')
+    @mock.patch('splitio.sync.telemetry.InMemoryTelemetrySubmitter.synchronize_config')
     def test_synchronize_config(self, mocker):
-        telemetry_synchronizer = TelemetrySynchronizer(mocker.Mock(), mocker.Mock(), mocker.Mock(), mocker.Mock())
+        telemetry_synchronizer = TelemetrySynchronizer(InMemoryTelemetrySubmitter(mocker.Mock(), mocker.Mock(), mocker.Mock(), mocker.Mock()))
         telemetry_synchronizer.synchronize_config()
         assert(mocker.called)
 
-    @mock.patch('splitio.sync.telemetry.TelemetrySubmitter.synchronize_stats')
+    @mock.patch('splitio.sync.telemetry.InMemoryTelemetrySubmitter.synchronize_stats')
     def test_synchronize_stats(self, mocker):
-        telemetry_synchronizer = TelemetrySynchronizer(mocker.Mock(), mocker.Mock(), mocker.Mock(), mocker.Mock())
+        telemetry_synchronizer = TelemetrySynchronizer(InMemoryTelemetrySubmitter(mocker.Mock(), mocker.Mock(), mocker.Mock(), mocker.Mock()))
         telemetry_synchronizer.synchronize_stats()
         assert(mocker.called)
 
 class TelemetrySubmitterTests(object):
     """Telemetry submitter test cases."""
 
     def test_synchronize_telemetry(self, mocker):
-        api = mocker.Mock()
+        api = mocker.Mock(spec=TelemetryAPI)
         telemetry_storage = InMemoryTelemetryStorage()
         telemetry_consumer = TelemetryStorageConsumer(telemetry_storage)
         split_storage = InMemorySplitStorage()
         split_storage.put(Split('split1', 1234, 1, False, 'user', Status.ACTIVE, 123))
         segment_storage = InMemorySegmentStorage()
         segment_storage.put(Segment('segment1', [], 123))
-        telemetry_submitter = TelemetrySubmitter(telemetry_consumer, split_storage, segment_storage, api)
+        telemetry_submitter = InMemoryTelemetrySubmitter(telemetry_consumer, split_storage, segment_storage, api)
 
         telemetry_storage._counters._impressions_queued = 100
         telemetry_storage._counters._impressions_deduped = 30
@@ -100,12 +101,13 @@ def test_synchronize_telemetry(self, mocker):
                                         'timeUntilReady': 1
                                        }, {}
         )
+        self.formatted_config = ""
         def record_init(*args, **kwargs):
             self.formatted_config = args[0]
 
         api.record_init.side_effect = record_init
         telemetry_submitter.synchronize_config()
-        assert(self.formatted_config == telemetry_submitter._telemetry_init_consumer.get_config_stats_to_json())
+        assert(self.formatted_config == telemetry_submitter._telemetry_init_consumer.get_config_stats())
 
         def record_stats(*args, **kwargs):
             self.formatted_stats = args[0]
@@ -130,5 +132,6 @@ def record_stats(*args, **kwargs):
             "mL": {"t": [1] + [0] * 22, "ts": [0] * 23, "tc": [0] * 23, "tcs": [0] * 23, "tr": [0] * 23},
             "spC": 1,
             "seC": 1,
-            "skC": 0
+            "skC": 0,
+            "t": ['tag1']
         })

Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@ def test_evaluations_before_running_post_fork(self, mocker):`
`31`	`31`	`impmanager,`
`32`	`32`	`mocker.Mock(),`
`33`	`33`	`telemetry_producer,`
`34`		`- telemetry_consumer.get_telemetry_init_consumer(),`
	`34`	`+ telemetry_producer.get_telemetry_init_producer(),`
`35`	`35`	`mocker.Mock(),`
`36`	`36`	`True`
`37`	`37`	`)`