Deprecate AsynchronousTransport

Author: Peter Dolak

README.rst

@@ -174,11 +174,15 @@ Transport types
 
 By default the client uses a simple non-buffered synchronous transport. The three available transport types are:
 * `NullTransport` - No requests, useful for disabling tracking in the Infinario constructor.
-* `SynchronousTransport` - Most operations are blocking for the time of a request to the Infinario API
+* `SynchronousTransport` - (default) Most operations are blocking for the time of a request to the Infinario API
 * `AsynchronousTransport` - Most operations are non-blocking (see the code for more information),
     buffered and using a single worker thread. Infinario client must be closed when no more data is to be tracked.
+    **We recommend against using the AsynchronousTransport, as it cannot be guaranteed the data will be sent.**
+    Data loss can for example happen in various events of system failure or even due to misuse.
+    If you would like to track data from your code asynchronously, consider creating your own asynchronous workers
+    using a library such as celery and use the SynchronousTransport to send the data from there.
 
-Example of choosing a transport:
+Example of choosing `AsynchronousTransport`:
 
 .. code-block:: python
 

infinario.py

@@ -143,6 +143,7 @@ def __init__(self, **kwargs):
         self.__dict__.update(**kwargs)
 
 
+# DEPRECATED - we recommend against using this transport mode, we cannot guarantee all data will be sent
 class AsynchronousTransport(object):
     """
     AsynchronousTransport is a buffered asynchronous transport using one lazy-initialized thread and requests.Session.

test_infinario_sdk.py

@@ -6,21 +6,13 @@
     import unittest
 import re
 import requests
-import time
-from infinario import Infinario, SynchronousTransport, AsynchronousTransport
+from infinario import Infinario, SynchronousTransport
 try:
     from mock import MagicMock, patch
 except ImportError:
     from unittest.mock import MagicMock, patch
 
 
-def _fake_post_response(*args, **kwargs):
-    mock = MagicMock()
-    mock.status_code = 200
-    mock.json = lambda: {'success': True, 'results': [{'status': 'ok'}]*20 + [{'status': 'retry'}]*50}
-    return mock
-
-
 class TestInfinarioSDK(unittest.TestCase):
 
     # helper for assertions about API requests
@@ -34,19 +26,6 @@ def _pop_post_calls(self, mock):
         mock.reset_mock()
         return calls
 
-    # helper for assertions about API bulk requests
-    def _assert_bulk_events(self, mock, expected_leftovers, type):
-        calls = self._pop_post_calls(mock)
-        self.assertEquals(len(expected_leftovers), len(calls))
-        for call, expected in zip(calls, expected_leftovers):
-            self.assertEquals('bulk', call[0])
-            events = 0
-            for command in call[1]['commands']:
-                self.assertEquals('crm/events', command['name'])
-                self.assertEquals(type, command['data']['type'])
-                events += 1
-            self.assertEquals(expected, events)
-
     # testing unidentified track, identify, identified track, update and identify at init with simple sync transport
     @patch.object(requests, 'Session')
     def test_synchronous_transport(self, session_mock):
@@ -76,38 +55,7 @@ def test_synchronous_transport(self, session_mock):
         ]
         self.assertEquals(expected, self._pop_post_calls(session_mock))
 
-    # testing async transport - flush, buffer fill, timeout and close
-    @unittest.skip("This test uses sleep() which means that it fails randomly. Skip it until it is fixed.")
-    @patch.object(requests, 'Session')
-    def test_asynchronous_transport(self, session_mock):
-        session_mock().post.side_effect = _fake_post_response
-
-        # flush
-        infinario = Infinario('t', target='nope/', transport=AsynchronousTransport)
-        try:
-            infinario.track('e1')
-            infinario.flush()
-
-            time.sleep(0.2)
-            self._assert_bulk_events(session_mock, [1], 'e1')
-
-            # full buffer, will 2x push 20 through, attempts max 50
-            for _ in range(80):
-                infinario.track('e2')
-
-            time.sleep(0.2)
-            self._assert_bulk_events(session_mock, [50, 50], 'e2')
-
-            # timeout, again 2x 20
-            time.sleep(1.1)
-            self._assert_bulk_events(session_mock, [40, 20], 'e2')
-        finally:
-            # close
-            infinario.track('e3')
-            infinario.close()
-
-            time.sleep(0.2)
-            self._assert_bulk_events(session_mock, [1], 'e3')
+    # asynchronous transport test removed as it is deprecated
 
 
 class TestConvertTimestampArgument(unittest.TestCase):