From fb82bd7bca8774d0241c8dd6488f5baf3be519fd Mon Sep 17 00:00:00 2001
From: Timmy <timmy@storkit>
Date: Fri, 15 May 2026 11:13:31 +0100
Subject: [PATCH] test(tick_loop): de-flake
 reconcile_never_floods_broadcast_channel

The test asserted msg_count == 0 on a process-global broadcast channel
(TRANSITION_TX is a single OnceLock<Sender> shared across the test
binary), so any concurrent test calling apply_transition could land
events in our receiver between the drain and the post-reconcile check.
Observed failure: 3 stray transitions from parallel tests.

Drop the strict count check.  The real "never floods" invariant is
captured by the Lagged check alone: 1000 seeded items must not overflow
the 256-slot channel, which can only hold if the reconcile path
bypasses the broadcast (AC4).  The sibling test
`reconcile_pass_scales_to_1000_items_without_lagged_divergence` already
uses this Lagged-only pattern.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 server/src/startup/tick_loop.rs | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/server/src/startup/tick_loop.rs b/server/src/startup/tick_loop.rs
index 8a52ead8..3fcd48f5 100644
--- a/server/src/startup/tick_loop.rs
+++ b/server/src/startup/tick_loop.rs
@@ -674,8 +674,14 @@ mod tests {
             );
         }
 
-        // Subscribe after seeding and drain any pre-existing channel noise from
-        // concurrent tests before checking that the reconcile pass adds nothing.
+        // Subscribe and drain pre-existing channel noise.  Note: `TRANSITION_TX`
+        // is a single process-global broadcast channel shared by every test in
+        // this binary, so other tests running on parallel threads may write to
+        // it during our window.  We can't assert `msg_count == 0` — that's
+        // racy by construction.  The real "never floods" invariant is captured
+        // by the Lagged check: 1000 seeded items must not overflow the
+        // 256-slot channel, which is only possible if the reconcile path
+        // bypasses the broadcast (which is what AC4 requires).
         let mut rx = crate::pipeline_state::subscribe_transitions();
         while let Ok(_) | Err(tokio::sync::broadcast::error::TryRecvError::Lagged(_)) =
             rx.try_recv()
@@ -683,12 +689,10 @@ mod tests {
 
         run_reconcile_pass(&root, &pool, std::time::Duration::ZERO).await;
 
-        // The channel must have received exactly zero messages from run_reconcile_pass.
-        let mut msg_count = 0u64;
         let mut lagged = false;
         loop {
             match rx.try_recv() {
-                Ok(_) => msg_count += 1,
+                Ok(_) => {}
                 Err(tokio::sync::broadcast::error::TryRecvError::Lagged(_)) => {
                     lagged = true;
                     break;
@@ -701,9 +705,5 @@ mod tests {
             !lagged,
             "run_reconcile_pass must never cause Lagged on the broadcast channel"
         );
-        assert_eq!(
-            msg_count, 0,
-            "run_reconcile_pass must not send any TransitionFired events"
-        );
     }
 }