added traffic type validations and unit tests for it

Author: mredolatti

splitio/client/client.py

@@ -337,7 +337,14 @@ def track(self, key, traffic_type, event_type, value=None):
 
         key = input_validator.validate_track_key(key)
         event_type = input_validator.validate_event_type(event_type)
-        traffic_type = input_validator.validate_traffic_type(traffic_type)
+        should_validate_existance = self.ready and self._factory._apikey != 'localhost' #pylint: disable=protected-access
+        print(self.ready, self._factory._apikey, should_validate_existance)
+        traffic_type = input_validator.validate_traffic_type(
+            traffic_type,
+            should_validate_existance,
+            self._factory._get_storage('splits'), #pylint: disable=protected-access
+        )
+
         value = input_validator.validate_value(value)
 
         if key is None or event_type is None or traffic_type is None or value is False:

splitio/client/input_validator.py

@@ -288,12 +288,16 @@ def validate_track_key(key):
     return key_str
 
 
-def validate_traffic_type(traffic_type):
+def validate_traffic_type(traffic_type, should_validate_existance, split_storage):
     """
     Check if traffic_type is valid for track.
 
     :param traffic_type: traffic_type to be checked
     :type traffic_type: str
+    :param should_validate_existance: Whether to check for existante in the split storage.
+    :type should_validate_existance: bool
+    :param split_storage: Split storage.
+    :param split_storage: splitio.storages.SplitStorage
     :return: traffic_type
     :rtype: str|None
     """
@@ -305,6 +309,15 @@ def validate_traffic_type(traffic_type):
         _LOGGER.warning('track: %s should be all lowercase - converting string to lowercase.',
                         traffic_type)
         traffic_type = traffic_type.lower()
+
+    if should_validate_existance and not split_storage.is_valid_traffic_type(traffic_type):
+        _LOGGER.warning(
+            'track: Traffic Type %s does not have any corresponding Splits in this environment, '
+            'make sure you\'re tracking your events to a valid traffic type defined '
+            'in the Split console.',
+            traffic_type
+        )
+
     return traffic_type
 
 

tests/client/test_client.py

@@ -318,6 +318,7 @@ def _get_storage_mock(name):
         destroyed_mock = mocker.PropertyMock()
         destroyed_mock.return_value = False
         type(factory).destroyed = destroyed_mock
+        factory._apikey = 'test'
         mocker.patch('splitio.client.client.time.time', new=lambda: 1)
 
         client = Client(factory)

tests/client/test_input_validator.py

@@ -453,6 +453,7 @@ def test_track(self, mocker):
         factory_destroyed = mocker.PropertyMock()
         factory_destroyed.return_value = False
         type(factory_mock).destroyed = factory_destroyed
+        factory_mock._apikey = 'some-test'
 
         client = Client(factory_mock)
         client._events_storage = mocker.Mock(spec=EventStorage)
@@ -602,6 +603,50 @@ def test_track(self, mocker):
             mocker.call("track: value must be a number.")
         ]
 
+        # Test traffic type existance
+        ready_property = mocker.PropertyMock()
+        ready_property.return_value = True
+        type(factory_mock).ready = ready_property
+
+        split_storage_mock = mocker.Mock(spec=SplitStorage)
+        split_storage_mock.is_valid_traffic_type.return_value = True
+        factory_mock._get_storage.return_value = split_storage_mock
+
+        # Test that it doesn't warn if tt is cached, not in localhost mode and sdk is ready
+        client._logger.reset_mock()
+        assert client.track("some_key", "traffic_type", "event_type", None) is True
+        assert client._logger.error.mock_calls == []
+        assert client._logger.warning.mock_calls == []
+
+        # Test that it does warn if tt is cached, not in localhost mode and sdk is ready
+        split_storage_mock.is_valid_traffic_type.return_value = False
+        client._logger.reset_mock()
+        assert client.track("some_key", "traffic_type", "event_type", None) is True
+        assert client._logger.error.mock_calls == []
+        assert client._logger.warning.mock_calls == [mocker.call(
+            'track: Traffic Type %s does not have any corresponding Splits in this environment, '
+            'make sure you\'re tracking your events to a valid traffic type defined '
+            'in the Split console.',
+            'traffic_type'
+        )]
+
+        # Test that it does not warn when in localhost mode.
+        factory_mock._apikey = 'localhost'
+        client._logger.reset_mock()
+        assert client.track("some_key", "traffic_type", "event_type", None) is True
+        assert client._logger.error.mock_calls == []
+        assert client._logger.warning.mock_calls == []
+
+        # Test that it does not warn when not in localhost mode and not ready
+        factory_mock._apikey = 'not-localhost'
+        ready_property.return_value = False
+        type(factory_mock).ready = ready_property
+        client._logger.reset_mock()
+        assert client.track("some_key", "traffic_type", "event_type", None) is True
+        assert client._logger.error.mock_calls == []
+        assert client._logger.warning.mock_calls == []
+
+
     def test_get_treatments(self, mocker):
         """Test getTreatments() method."""
         split_mock = mocker.Mock(spec=Split)