From 13d2a040525add23f108032c403f0961ef633694 Mon Sep 17 00:00:00 2001 From: Polish Hammer Date: Mon, 24 Aug 2026 14:10:06 +0200 Subject: [PATCH] tests: fix the flaky heartbeat coverage assertion test_search_fills_progress_with_live_positions_and_total asserted 100% coverage after searching for a DOI that EXISTS. Once every queried DOI is found the consumer signals TERM and the producers stop mid-file, so the recorded offsets reach an arbitrary point - the assertion was racing the scan and failed roughly one full-suite run in two. Split into the two things that are actually deterministic: coverage is now measured with an ABSENT DOI (nothing can stop the scan early, so 100% is guaranteed), and the found-target case asserts what holds regardless of where the producers stopped - the total is known, progress is bounded and sane, and the hit is reported. Verified: 5 consecutive runs of the file and 3 consecutive full integration runs, all green. Co-Authored-By: Claude Opus 4.8 --- tests/integration/test_librarian_heartbeat.py | 40 +++++++++++++++---- 1 file changed, 32 insertions(+), 8 deletions(-) diff --git a/tests/integration/test_librarian_heartbeat.py b/tests/integration/test_librarian_heartbeat.py index 6935772..d6e2f8c 100644 --- a/tests/integration/test_librarian_heartbeat.py +++ b/tests/integration/test_librarian_heartbeat.py @@ -60,25 +60,49 @@ def test_current_search_registration_round_trip(): assert not lib._current_search -def test_search_fills_progress_with_live_positions_and_total(tmp_path, monkeypatch): - # End to end against the real scan: total_bytes matches the chunk files on - # disk, and once finished the recorded offsets cover them. - monkeypatch.setattr(search_bot, "DATABASE_PATH", str(tmp_path) + "/") +def _write_two_chunks(tmp_path): (tmp_path / "0_chunk.txt").write_text("10.1/a\n10.1/b\n", encoding="utf-8") (tmp_path / "1_chunk.txt").write_text("10.1/c\n", encoding="utf-8") - expected_total = sum( + return sum( (tmp_path / name).stat().st_size for name in ("0_chunk.txt", "1_chunk.txt") ) + +def test_search_fills_progress_and_reaches_full_coverage(tmp_path, monkeypatch): + # Coverage must be measured on a search that CANNOT stop early. Once every + # queried DOI is found the consumer signals TERM and the producers stop + # mid-file, so a search for a DOI that exists reaches an arbitrary offset - + # asserting 100% there is a race (it failed roughly one run in two). + # An absent DOI forces the whole database to be read. + monkeypatch.setattr(search_bot, "DATABASE_PATH", str(tmp_path) + "/") + expected_total = _write_two_chunks(tmp_path) + + progress = {} + search_bot.search_for_doi([("10.9/absent", "DATA")], [], _LOG, progress=progress) + + assert progress["total_bytes"] == expected_total + assert progress["chunk_files"] == 2 + done, total, percent = lib._progress_summary(progress) + assert total == expected_total + assert done == expected_total # nothing stopped it: whole DB scanned + assert percent == pytest.approx(100.0) + + +def test_progress_is_populated_for_a_search_that_finds_its_target(tmp_path, monkeypatch): + # The early-termination case: the target is found, so coverage is whatever + # the producers reached. Assert what IS deterministic - the total is known, + # progress is bounded and sane, and the hit is reported. + monkeypatch.setattr(search_bot, "DATABASE_PATH", str(tmp_path) + "/") + expected_total = _write_two_chunks(tmp_path) + progress = {} result, _positions, _interrupted = search_bot.search_for_doi( [("10.1/c", "DATA")], [], _LOG, progress=progress ) assert progress["total_bytes"] == expected_total - assert progress["chunk_files"] == 2 done, total, percent = lib._progress_summary(progress) assert total == expected_total - assert done == expected_total # whole DB scanned - assert percent == pytest.approx(100.0) + assert 0 <= done <= total # bounded, never nonsense + assert 0.0 <= percent <= 100.0 assert [r for r in result if r["DOI"] == "10.1/c" and r["exists"]]