more tests

Author: dkhokhlov

logdna/logdna.py

@@ -177,7 +177,7 @@ def try_request(self):
             self.close_flusher()
             self.exception_flag = True
 
-    def send_request(self, data):
+    def send_request(self, data): # noqa: max-complexity: 13
         """
             Send log data to LogDNA server
         Returns:
@@ -206,9 +206,11 @@ def send_request(self, data):
                     1XX                       unexpected status
                     200                       expected status, OK
                     2XX                       unexpected status
-                    301 302 303               unexpected status, per "allow_redirects=True"
+                    301 302 303               unexpected status,
+                                              per "allow_redirects=True"
                     3XX                       unexpected status
-                    401, 403                  expected client error, invalid ingestion key
+                    401, 403                  expected client error,
+                                              invalid ingestion key
                     4XX                       unexpected client error
                     500 502 503 507           expected server error, transient
                     5XX                       unexpected server error
@@ -221,7 +223,7 @@ def send_request(self, data):
                     unexpected server error   log + discard flush buffer
             '''
             if status_code == 200:
-                return True # discard
+                return True  # discard
 
             if isinstance(response.reason, bytes):
                 # We attempt to decode utf-8 first because some servers
@@ -239,19 +241,19 @@ def send_request(self, data):
                 self.internalLogger.debug('Unexpected response: %s. ' +
                                           'Discarding flush buffer',
                                           reason)
-                return True # discard
+                return True  # discard
 
             if status_code in [401, 403]:
                 self.internalLogger.debug(
                     'Please provide a valid ingestion key. ' +
                     'Discarding flush buffer')
-                return True # discard
+                return True  # discard
 
             if 400 <= status_code <= 499:
                 self.internalLogger.debug('Client Error: %s. ' +
                                           'Discarding flush buffer',
                                           reason)
-                return True # discard
+                return True  # discard
 
             if status_code in [500, 502, 503, 507]:
                 self.internalLogger.debug('Server Error: %s. Retrying...',
@@ -271,7 +273,7 @@ def send_request(self, data):
             self.internalLogger.debug(
                 'Error sending logs %s. Discarding flush buffer', exception)
 
-        return True # discard
+        return True  # discard
 
     def emit(self, record):
         msg = self.format(record)

tests/test_logger.py

@@ -8,7 +8,7 @@
 from concurrent.futures import ThreadPoolExecutor
 from logdna.configs import defaults
 from unittest import mock
-from tests.test_utils import ordered
+from unittest.mock import patch
 
 now = int(time.time())
 expectedLines = []
@@ -45,7 +45,8 @@
     'mac': 'C0:FF:EE:C0:FF:EE',
     'tags': 'sample,test',
     'index_meta': True,
-    'now': int(time.time() * 1000)
+    'now': int(time.time() * 1000),
+    'retry_interval_secs': 0.5
 }
 
 
@@ -71,7 +72,6 @@ def shutdown(self, wait=True):
 
 class LogDNAHandlerTest(unittest.TestCase):
 
-    @ordered
     def test_handler(self):
         handler = LogDNAHandler(LOGDNA_API_KEY, sample_options)
         self.assertIsInstance(handler, logging.Handler)
@@ -99,7 +99,7 @@ def test_handler(self):
         self.assertEqual(handler.max_concurrent_requests,
                          defaults['MAX_CONCURRENT_REQUESTS'])
         self.assertEqual(handler.retry_interval_secs,
-                         defaults['RETRY_INTERVAL_SECS'])
+                         sample_options['retry_interval_secs'])
 
         # Set the Flush-related Variables
         self.assertEqual(handler.buf, [])
@@ -119,7 +119,6 @@ def test_handler(self):
         self.assertIsInstance(handler.request_thread_pool, ThreadPoolExecutor)
         self.assertEqual(handler.level, logging.DEBUG)
 
-    @ordered
     def test_flusher(self):
         handler = LogDNAHandler(LOGDNA_API_KEY, sample_options)
         self.assertIsNone(handler.flusher)
@@ -128,59 +127,73 @@ def test_flusher(self):
         handler.close_flusher()
         self.assertIsNone(handler.flusher)
 
-    @ordered
     def test_emit(self):
         handler = LogDNAHandler(LOGDNA_API_KEY, sample_options)
         handler.buffer_log = unittest.mock.Mock()
         handler.emit(sample_record)
         sample_message['timestamp'] = unittest.mock.ANY
         handler.buffer_log.assert_called_once_with(sample_message)
 
-    @ordered
     @mock.patch('time.time', unittest.mock.MagicMock(return_value=now))
     def test_try_request(self):
-        r = requests.Response()
-        r.status_code = 200
-        r.reason = 'OK'
-        requests.post = unittest.mock.Mock(return_value=r)
-        handler = LogDNAHandler(LOGDNA_API_KEY, sample_options)
-        sample_message['timestamp'] = unittest.mock.ANY
-        handler.buf = [sample_message]
-        handler.try_request()
-        self.assertFalse(handler.exception_flag)
-        requests.post.assert_called_with(
-            url=handler.url,
-            json={
-                'e': 'ls',
-                'ls': handler.buf
-            },
-            auth=('user', handler.key),
-            params={
-                'hostname': handler.hostname,
-                'ip': handler.ip,
-                'mac': handler.mac,
-                'tags': handler.tags,
-                'now': int(now * 1000)
-            },
-            stream=True,
-            allow_redirects=True,
-            timeout=handler.request_timeout,
-            headers={'user-agent': handler.user_agent})
-
-    @ordered
+        with patch('requests.post') as post_mock:
+            r = requests.Response()
+            r.status_code = 200
+            r.reason = 'OK'
+            post_mock.return_value = r
+            handler = LogDNAHandler(LOGDNA_API_KEY, sample_options)
+            sample_message['timestamp'] = unittest.mock.ANY
+            handler.buf = [sample_message]
+            handler.try_request()
+            post_mock.assert_called_with(
+                url=handler.url,
+                json={
+                    'e': 'ls',
+                    'ls': handler.buf
+                },
+                auth=('user', handler.key),
+                params={
+                    'hostname': handler.hostname,
+                    'ip': handler.ip,
+                    'mac': handler.mac,
+                    'tags': handler.tags,
+                    'now': int(now * 1000)
+                },
+                stream=True,
+                allow_redirects=True,
+                timeout=handler.request_timeout,
+                headers={'user-agent': handler.user_agent})
+            self.assertFalse(handler.exception_flag)
+            self.assertTrue(post_mock.call_count, 1)
+
     @mock.patch('time.time', unittest.mock.MagicMock(return_value=now))
     def test_try_request_500(self):
-        r = requests.Response()
-        r.status_code = 500
-        r.reason = 'OK'
-        requests.post = unittest.mock.Mock(return_value=r)
-        handler = LogDNAHandler(LOGDNA_API_KEY, sample_options)
-        sample_message['timestamp'] = unittest.mock.ANY
-        handler.buf = [sample_message]
-        handler.try_request()
-        self.assertTrue(handler.exception_flag)
+        with patch('requests.post') as post_mock:
+            r = requests.Response()
+            r.status_code = 500
+            r.reason = 'OK'
+            post_mock.return_value = r
+            handler = LogDNAHandler(LOGDNA_API_KEY, sample_options)
+            sample_message['timestamp'] = unittest.mock.ANY
+            handler.buf = [sample_message]
+            handler.try_request()
+            self.assertTrue(handler.exception_flag)
+            self.assertTrue(post_mock.call_count, 3)
+
+    @mock.patch('time.time', unittest.mock.MagicMock(return_value=now))
+    def test_try_request_403(self):
+        with patch('requests.post') as post_mock:
+            r = requests.Response()
+            r.status_code = 403
+            r.reason = 'OK'
+            post_mock.return_value = r
+            handler = LogDNAHandler(LOGDNA_API_KEY, sample_options)
+            sample_message['timestamp'] = unittest.mock.ANY
+            handler.buf = [sample_message]
+            handler.try_request()
+            self.assertFalse(handler.exception_flag)
+            self.assertTrue(post_mock.call_count, 1)
 
-    @ordered
     def test_close(self):
         handler = LogDNAHandler(LOGDNA_API_KEY, sample_options)
         handler.close_flusher = unittest.mock.Mock()
@@ -191,7 +204,6 @@ def test_close(self):
         self.assertIsNone(handler.worker_thread_pool)
         self.assertIsNone(handler.request_thread_pool)
 
-    @ordered
     def test_flush(self):
         handler = LogDNAHandler(LOGDNA_API_KEY, sample_options)
         handler.worker_thread_pool = MockThreadPoolExecutor()
@@ -201,7 +213,6 @@ def test_flush(self):
         handler.flush()
         handler.try_request.assert_called_once_with()
 
-    @ordered
     def test_flush_secondary(self):
         handler = LogDNAHandler(LOGDNA_API_KEY, sample_options)
         clean = handler.clean_after_success
@@ -221,7 +232,6 @@ def test_flush_secondary(self):
         self.assertEqual(handler.secondary, [])
         self.assertEqual(handler.buf, [])
 
-    @ordered
     def test_buffer_log(self):
         handler = LogDNAHandler(LOGDNA_API_KEY, sample_options)
         handler.worker_thread_pool = MockThreadPoolExecutor()

tests/test_utils.py

@@ -59,20 +59,3 @@ def test_normalize_simple(self):
         self.assertEqual(value1, ['a', 'b'])
         self.assertEqual(value1, value2)
         self.assertEqual(value3, [])
-
-
-def _make_orderer():
-    order = {}
-
-    def ordered(f):
-        order[f.__name__] = len(order)
-        return f
-
-    def compare(a, b):
-        return [1, -1][order[a] > order[b]]
-
-    return ordered, compare
-
-
-ordered, _compare = _make_orderer()
-unittest.loader.TestLoader.sortTestMethodsUsing = lambda _, x, y: _compare(y, x)