cleanup

Author: cameronwaterman

tests/tag/test_tagmanager.py

@@ -1,7 +1,6 @@
 import asyncio
 import time
 import uuid
-from typing import Optional
 from collections import OrderedDict
 from datetime import datetime, timedelta, timezone
 from unittest import mock
@@ -12,15 +11,14 @@
 from .http.httpclienttestbase import HttpClientTestBase, MockResponse
 from ..anyorderlist import AnyOrderList
 
-def _wait_for_call_count(mock_obj, expected: int, *, timeout: float = 3.0, min_elapsed: Optional[float] = None):
 
+def _wait_for_call_count(mock_obj, expected: int, *, timeout: float = 3.0):
     """Wait until mock_obj.call_count >= expected or timeout.
 
     Args:
         mock_obj: Mock with call_count attribute.
         expected: Target call count (>=).
         timeout: Max seconds to wait.
-        min_elapsed: If provided, fail if the condition is met before this many seconds (guards against premature flushes).
 
     Returns:
         Elapsed seconds when condition satisfied.
@@ -30,17 +28,11 @@ def _wait_for_call_count(mock_obj, expected: int, *, timeout: float = 3.0, min_e
     """
     start = time.monotonic()
     while True:
-        current = mock_obj.call_count
-        if current >= expected:
-            elapsed = time.monotonic() - start
-            if min_elapsed is not None and elapsed < min_elapsed:
-                raise AssertionError(
-                    f"Condition reached too early: call_count={current} elapsed={elapsed:.4f}s < min_elapsed={min_elapsed:.4f}s"
-                )
-            return elapsed
+        if mock_obj.call_count >= expected:
+            return time.monotonic() - start
         if time.monotonic() - start >= timeout:
             raise AssertionError(
-                f"Timed out waiting for call_count >= {expected}. Final={current} timeout={timeout}s"
+                f"Timed out waiting for call_count >= {expected}. Final={mock_obj.call_count} timeout={timeout}s"
             )
         time.sleep(0.01)
 
@@ -2413,22 +2405,20 @@ def test__create_writer_with_buffer_time__sends_when_timer_elapsed(self):
         path = "tag"
         value = 1
         buffer_ms = 50
-        writer = self._uut.create_writer(max_buffer_time=timedelta(milliseconds=buffer_ms))
+        writer = self._uut.create_writer(
+            max_buffer_time=timedelta(milliseconds=buffer_ms)
+        )
         timestamp = datetime.now()
-        self._client.all_requests.configure_mock(side_effect=self._get_mock_request([None]))
+        self._client.all_requests.configure_mock(
+            side_effect=self._get_mock_request([None])
+        )
 
         writer.write(path, tbase.DataType.INT32, value, timestamp=timestamp)
         self._client.all_requests.assert_not_called()
 
-        warm = buffer_ms / 1000 * 2.5  # generous warm period for slow CI start
-        time.sleep(warm)
+        time.sleep(buffer_ms / 1000 * 2.5)
         if self._client.all_requests.call_count == 0:
-            _wait_for_call_count(
-                self._client.all_requests,
-                1,
-                timeout=5.0,
-                min_elapsed=buffer_ms / 1000 * 0.4,  # at least 40% of interval to avoid racey early flush
-            )
+            _wait_for_call_count(self._client.all_requests, 1, timeout=5.0)
 
         utctime = (
             datetime.fromtimestamp(timestamp.timestamp(), timezone.utc)
@@ -2498,16 +2488,12 @@ def test__create_writer_with_buffer_size_and_timer__obeys_both_settings(self):
         )
 
         writer2.write(path, tbase.DataType.INT32, value3, timestamp=timestamp)
-        assert 1 == self._client.all_requests.call_count
-        # Use longer warm period in CI to allow thread scheduling
+        assert 1 == self._client.all_requests.call_count  # same as before
+
         time.sleep(buffer_ms / 1000 * 2.5)
         if self._client.all_requests.call_count == 1:
-            _wait_for_call_count(
-                self._client.all_requests,
-                2,
-                timeout=5.0,
-                min_elapsed=buffer_ms / 1000 * 0.4,
-            )
+            _wait_for_call_count(self._client.all_requests, 2, timeout=5.0)
+
         assert 2 == self._client.all_requests.call_count
         assert self._client.all_requests.call_args_list[1] == mock.call(
             "POST",