test: Load the changed file on demand when checking that a different failure is reported

The reloader test wrote a file with a new failure while the automatic retries were running and
expected the next retry to report it. The write is ordinary, not atomic, so a retry can read the
file while it is empty or half written. An empty document is valid, so such a retry succeeds and
ends the retries, and the new failure is never read; a half-written file is reported as a failure
of its own. The test now loads the final content on demand and inspects the reports as a whole,
and a fixture helper collects the callbacks that arrive within a settle period.

Author: kinyoklion

ldclient/testing/integrations/test_filedata.py

@@ -3,7 +3,7 @@
 import threading
 import time
 from queue import Empty, Queue
-from typing import Any, Dict, List, Set
+from typing import Any, Dict, List, Set, Tuple
 from unittest import mock
 
 import pytest
@@ -319,6 +319,19 @@ def require_quiet(self, duration: float = QUIET_PERIOD) -> None:
                 pytest.fail("unexpected on_error call")
             time.sleep(0.01)
 
+    def drain(self, duration: float = QUIET_PERIOD) -> Tuple[List[MergeResult], List[Exception]]:
+        """Collects every apply and on_error call that arrives within the duration."""
+        applied: List[MergeResult] = []
+        errored: List[Exception] = []
+        deadline = time.time() + duration
+        while time.time() < deadline:
+            while not self.applied.empty():
+                applied.append(self.applied.get_nowait())
+            while not self.errored.empty():
+                errored.append(self.errored.get_nowait())
+            time.sleep(0.01)
+        return applied, errored
+
     def close(self) -> None:
         self.reloader.close()
 
@@ -437,9 +450,16 @@ def test_reloader_reports_identical_failure_only_once(make_fixture):
     # The automatic retries keep failing in the same way. They do not report again.
     f.require_quiet()
 
-    # A different failure is reported.
+    # A different failure is reported. The write is ordinary, not atomic, and a retry that runs
+    # while the file is being rewritten reads it empty or half written. An empty document is
+    # valid, so such a retry succeeds and ends the retries; a half-written file is a failure of
+    # its own. The final content is therefore loaded on demand, and everything that was reported
+    # is inspected as a whole: the new failure is among the reports, and once it is the current
+    # failure, the retries that repeat it stay silent.
     f.write('{"flags": {"flag1": "not an object"}}')
-    f.require_errored()
+    f.reloader.reload_now()
+    _, errored = f.drain()
+    assert any('must be an object' in str(e) for e in errored), errored
     f.require_quiet()