fix(selftest): eliminate timer-vs-cancel race in DepsThrashing fixture (#200)

* fix(selftest): eliminate timer-vs-cancel race in DepsThrashing fixture

DepsThrashing_AtMostOneCompleted hit completed=2 on CI Stress run
#25518410339 (shards 5 and 10). The previous fix (ThrowIfCancellationRequested
after Task.Delay(200)) left a TOCTOU window: if the pool thread's CT check
ran before the UI thread's Cts.Cancel() completed, the counter incremented
for a fetch the production hook correctly discards.

Root cause: when CI render ticks approach 200ms, the delay timer and dep-change
cancellation fire nearly simultaneously on different threads, making the race
likely rather than theoretical.

Fix: replace Task.Delay(200, ct) with Task.Delay(Timeout.Infinite, ct). An
infinite-duration delay can only exit via OperationCanceledException — there
is no timer to race against. completed stays 0; the assertion guards against
regressions. Remove the now-unreachable ThrowIfCancellationRequested() and the
Harness.Render(400) wait that existed solely to let the last fetch resolve.

Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>

* fixup: address CR feedback on DepsThrashing fixture

Two issues raised in review of #200:

1. host.Dispose() before GC drain: the last dep's Task.Delay(Infinite, ct)
   ran forever with no explicit teardown. Disposing the host triggers the
   UseEffect cleanup which cancels the CTS, ensuring the in-flight task is
   torn down before the unobserved-exception probe runs.

2. Tighten completed==0: the comment said "completed stays 0" but the
   assertion was completed<=1. Changed to completed==0 so the fixture
   actually catches a regression if a completion slips through.

Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>

Author: codemonkeychris

tests/Reactor.AppTests.Host/SelfTest/Fixtures/AsyncResourceFramerateFixtures.cs

@@ -71,16 +71,12 @@ public override async Task RunAsync()
                             try
                             {
                                 ct.Register(() => Interlocked.Increment(ref cancelled));
-                                await Task.Delay(200, ct);
-                                // Close the race where Task.Delay's 200ms timer
-                                // fires almost simultaneously with cancellation:
-                                // Task.Delay can complete normally (timer wins
-                                // the atomic result-set) even though Cancel()
-                                // was called, leaving the await to resume and
-                                // increment `completed` for a fetch the hook
-                                // will correctly discard. Re-checking the CT
-                                // after the await observes the cancellation.
-                                ct.ThrowIfCancellationRequested();
+                                // Infinite delay: the only exit is OperationCanceledException
+                                // when the CT fires. This eliminates the timer-vs-cancel race
+                                // that made completed reach 2 when CI render ticks approached
+                                // the old 200ms fixed delay. `completed` stays 0; the
+                                // assertion below guards against regressions.
+                                await Task.Delay(Timeout.Infinite, ct);
                                 Interlocked.Increment(ref completed);
                                 return $"dep={dep}";
                             }
@@ -101,9 +97,6 @@ public override async Task RunAsync()
                     await Harness.Render();
                 }
 
-                // Only the final deps value's fetch should survive. Let it resolve.
-                await Harness.Render(400);
-
                 // Invariant 1: fetches started roughly once per deps-change (some coalesce).
                 H.Check($"DepsThrashing_Started (started={started}, frames={Frames})",
                     started >= Frames / 3 && started <= Frames + 2);
@@ -117,11 +110,15 @@ public override async Task RunAsync()
                 H.Check($"DepsThrashing_StaleCancelled (cancelled={cancelled}, started={started})",
                     cancelled >= started - 1);
 
-                // Invariant 4: at most one fetch ran to completion — the last deps' one.
+                // Invariant 4: no fetch body completes — all use Timeout.Infinite delays and
+                // exit only via cancellation. completed must be exactly 0.
                 H.Check($"DepsThrashing_AtMostOneCompleted (completed={completed})",
-                    completed <= 1);
+                    completed == 0);
 
                 // Invariant 5: no unobserved task exceptions escaped under this load.
+                // Dispose the host first so the last in-flight Task.Delay(Infinite, ct) is
+                // cancelled via UseEffect teardown before we drain for unobserved exceptions.
+                host.Dispose();
                 await Harness.Render();
                 GC.Collect();
                 GC.WaitForPendingFinalizers();