chore: cleanup flake in tests

Author: karel-rehor

tests/test_api_client.py

@@ -1,8 +1,6 @@
 import json
-import time
 import unittest
 import uuid
-from concurrent.futures import thread
 from unittest import mock
 
 import pytest
@@ -41,9 +39,11 @@ def data(self):
 
     return MockResponse(None, 200)
 
+
 class ApiClientTests(unittest.TestCase):
 
     received_timeout_total = None
+
     def mock_urllib3_timeout_request(method,
                                      url,
                                      body,
@@ -166,7 +166,7 @@ def test_request_config_timeout(self, mock_request):
         service = WriteService(local_client)
         with pytest.raises(ConnectTimeoutError):
             service.post_write("TEST_ORG", "TEST_BUCKET", "data,foo=bar val=3.14",
-                              _preload_content=False)
+                               _preload_content=False)
         self.assertEqual(0.3, self.received_timeout_total)
         self.received_timeout_total = None
 

tests/test_influxdb_client_3.py

@@ -85,17 +85,16 @@ def test_write_options(self):
                                            flush_interval=500,))
         )
 
-        assert isinstance(client._write_client_options["write_options"], WriteOptions)
-        assert client._write_client_options["success_callback"]("an_arg") == True
-        assert client._write_client_options["error_callback"]("an_arg") == False
-        assert client._write_client_options["extra_arg"] == "ignored"
-        assert client._write_client_options["write_options"].timeout == 30_000
-        assert client._write_client_options["write_options"].max_retries == 0
-        assert client._write_client_options["write_options"].max_retry_time == 0
-        assert client._write_client_options["write_options"].max_retry_delay == 0
-        assert client._write_client_options["write_options"].write_type == WriteType.synchronous
-        assert client._write_client_options["write_options"].flush_interval == 500
-
+        self.assertIsInstance(client._write_client_options["write_options"], WriteOptions)
+        self.assertTrue(client._write_client_options["success_callback"]("an_arg"))
+        self.assertFalse(client._write_client_options["error_callback"]("an_arg"))
+        self.assertEqual("ignored", client._write_client_options["extra_arg"])
+        self.assertEqual(30_000, client._write_client_options["write_options"].timeout)
+        self.assertEqual(0, client._write_client_options["write_options"].max_retries)
+        self.assertEqual(0, client._write_client_options["write_options"].max_retry_time)
+        self.assertEqual(0, client._write_client_options["write_options"].max_retry_delay)
+        self.assertEqual(WriteType.synchronous, client._write_client_options["write_options"].write_type)
+        self.assertEqual(500, client._write_client_options["write_options"].flush_interval)
 
     def test_default_write_options(self):
         client = InfluxDBClient3(
@@ -105,10 +104,12 @@ def test_default_write_options(self):
             database="my_db",
         )
 
-        assert client._write_client_options["write_options"].write_type == DefaultWriteOptions.write_type.value
-        assert client._write_client_options["write_options"].no_sync == DefaultWriteOptions.no_sync.value
-        assert client._write_client_options["write_options"].write_precision == DefaultWriteOptions.write_precision.value
-        assert client._write_client_options["write_options"].timeout == DefaultWriteOptions.timeout.value
+        self.assertEqual(DefaultWriteOptions.write_type.value,
+                         client._write_client_options["write_options"].write_type)
+        self.assertEqual(DefaultWriteOptions.no_sync.value, client._write_client_options["write_options"].no_sync)
+        self.assertEqual(DefaultWriteOptions.write_precision.value,
+                         client._write_client_options["write_options"].write_precision)
+        self.assertEqual(DefaultWriteOptions.timeout.value, client._write_client_options["write_options"].timeout)
 
     @asyncio_run
     async def test_query_async(self):

tests/test_influxdb_client_3_integration.py

@@ -7,9 +7,9 @@
 import time
 import unittest
 
-from urllib3.exceptions import MaxRetryError, ConnectTimeoutError, TimeoutError as Url3TimeoutError
+from urllib3.exceptions import MaxRetryError, TimeoutError as Url3TimeoutError
 
-from influxdb_client_3 import InfluxDBClient3, write_client_options, WriteOptions, SYNCHRONOUS, flight_client_options, \
+from influxdb_client_3 import InfluxDBClient3, write_client_options, WriteOptions, \
     WriteType, InfluxDB3ClientQueryError
 from influxdb_client_3.exceptions import InfluxDBError
 from tests.util import asyncio_run, lp_to_py_object
@@ -278,9 +278,8 @@ async def test_write_timeout_async(self):
                 database=self.database,
                 token=self.token,
                 write_client_options=write_client_options(
-                    # error_callback=set_error_record,
                     write_options=WriteOptions(
-                        max_retry_time=0, # disable retries
+                        max_retry_time=0,  # disable retries
                         timeout=20,
                         write_type=WriteType.asynchronous
                     )
@@ -305,7 +304,7 @@ def set_error_result(rt, rd, rx):
             write_client_options=write_client_options(
                 error_callback=set_error_result,
                 write_options=WriteOptions(
-                    max_retry_time=0, # disable retries
+                    max_retry_time=0,  # disable retries
                     timeout=20,
                     write_type=WriteType.batching,
                     max_retries=0,
@@ -330,11 +329,13 @@ def set_error_result(rt, rd, rx):
     def test_write_timeout_retry(self):
 
         ErrorResult = {"rt": None, "rd": None, "rx": None}
+
         def set_error_result(rt, rd, rx):
             nonlocal ErrorResult
             ErrorResult = {"rt": rt, "rd": rd, "rx": rx}
 
         retry_ct = 0
+
         def retry_cb(args, data, excp):
             nonlocal retry_ct
             retry_ct += 1
@@ -359,7 +360,7 @@ def retry_cb(args, data, excp):
 
         lp = "test_write_timeout,location=harfa fVal=3.14,iVal=42i"
         localClient.write(lp)
-        time.sleep(1) # await all retries
+        time.sleep(1)  # await all retries
 
         self.assertEqual(3, retry_ct)
         self.assertEqual((self.database, 'default', 'ns'), ErrorResult["rt"])
@@ -391,4 +392,3 @@ def test_query_timeout_per_call_override(self):
 
         with self.assertRaisesRegex(InfluxDB3ClientQueryError, ".*Deadline Exceeded.*"):
             localClient.query("SELECT * FROM data", timeout=0.001)
-

tests/test_query.py

@@ -13,7 +13,7 @@
 )
 
 from influxdb_client_3 import InfluxDBClient3
-from influxdb_client_3.query.query_api import QueryApiOptionsBuilder, QueryApi, QueryApiOptions
+from influxdb_client_3.query.query_api import QueryApiOptionsBuilder, QueryApi
 from influxdb_client_3.version import USER_AGENT
 from tests.util import asyncio_run
 
@@ -431,7 +431,7 @@ async def fibo(iters):
 
             # fibo ended before query_async
             assert events['query_result'] > events['fibo_end'], (f"query_result: {events['query_result']} should occur "
-                                                                     f"after fibo_end: {events['fibo_end']}")
+                                                                 f"after fibo_end: {events['fibo_end']}")
 
     @asyncio_run
     async def test_query_async_timeout(self):

tests/test_write_local_server.py

@@ -23,7 +23,7 @@ def assert_request_made(httpserver, matcher):
         httpserver.check_assertions()
 
     @staticmethod
-    def delay_response(httpserver, delay = 1.0):
+    def delay_response(httpserver, delay=1.0):
         httpserver.expect_request(re.compile(".*")).respond_with_handler(lambda request: time.sleep(delay))
 
     def test_write_default_params(self, httpserver: HTTPServer):