test: fix flaky test_route_with_one_healthy_and_one_unhealthy_seed

Replace fixed sleep durations with retry loops that actively poll for expected routing state. This eliminates timing-related flakiness in CI environments where task scheduling is less predictable.

Changes:
- Add wait_for_routing_to_domains helper that polls until expected domains are available
- Update test to use retry loops with timeouts instead of fixed sleeps
- Remove timing assumptions that failed in CI due to scheduler variance

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

Author: lwshang

ic-agent/src/agent/route_provider/dynamic_routing/dynamic_route_provider.rs

@@ -389,7 +389,8 @@ mod tests {
                 },
                 node::Node,
                 test_utils::{
-                    assert_routed_domains, route_n_times, NodeHealthCheckerMock, NodesFetcherMock,
+                    assert_routed_domains, route_n_times, wait_for_routing_to_domains,
+                    NodeHealthCheckerMock, NodesFetcherMock,
                 },
             },
             RouteProvider, RoutesStats,
@@ -726,18 +727,24 @@ mod tests {
         .with_check_period(check_interval)
         .build();
         route_provider.start().await;
-        tokio::time::sleep(std::time::Duration::from_millis(100)).await;
         let route_provider = Arc::new(route_provider);
 
-        // Test 1: calls to route() return only a healthy seed ic0.app.
-        let routed_domains = route_n_times(3, Arc::clone(&route_provider));
-        assert_routed_domains(routed_domains, vec![node_1.domain()]);
+        // Test 1: Wait for routing to stabilize and verify only the healthy seed ic0.app is returned.
+        wait_for_routing_to_domains(
+            Arc::clone(&route_provider),
+            vec![node_1.domain()],
+            Duration::from_secs(3),
+        )
+        .await;
 
-        // Test 2: calls to route() return two healthy seeds, as the unhealthy seed becomes healthy.
+        // Test 2: Make the unhealthy seed healthy and wait for routing to reflect both healthy seeds.
         checker.overwrite_healthy_nodes(vec![node_1.clone(), node_2.clone()]);
-        tokio::time::sleep(2 * check_interval).await;
-        let routed_domains = route_n_times(6, Arc::clone(&route_provider));
-        assert_routed_domains(routed_domains, vec![node_1.domain(), node_2.domain()]);
+        wait_for_routing_to_domains(
+            Arc::clone(&route_provider),
+            vec![node_1.domain(), node_2.domain()],
+            Duration::from_secs(5),
+        )
+        .await;
     }
 
     #[tokio::test]

ic-agent/src/agent/route_provider/dynamic_routing/test_utils.rs

@@ -58,6 +58,42 @@ where
     }
 }
 
+/// Polls the route provider until the expected domains are available or timeout is reached.
+/// This is more reliable than fixed sleeps for async state updates in tests.
+pub(super) async fn wait_for_routing_to_domains(
+    route_provider: Arc<impl RouteProvider + ?Sized>,
+    expected_domains: Vec<&str>,
+    timeout: Duration,
+) {
+    let start = std::time::Instant::now();
+    let poll_interval = Duration::from_millis(50);
+    let sample_size = expected_domains.len() * 2; // Sample multiple times to account for probabilistic routing
+
+    loop {
+        if start.elapsed() >= timeout {
+            panic!(
+                "Timeout waiting for routing to expected domains: {:?}. Elapsed: {:?}",
+                expected_domains,
+                start.elapsed()
+            );
+        }
+
+        let routed_domains = route_n_times(sample_size, Arc::clone(&route_provider));
+        let unique_domains: HashSet<String> = routed_domains.into_iter().collect();
+
+        // Check if all expected domains are present
+        let expected_set: HashSet<&str> = expected_domains.iter().copied().collect();
+        let actual_set: HashSet<&str> = unique_domains.iter().map(|s| s.as_str()).collect();
+
+        if expected_set == actual_set {
+            // Success - all expected domains are now being routed to
+            return;
+        }
+
+        crate::util::sleep(poll_interval).await;
+    }
+}
+
 #[derive(Debug)]
 pub(super) struct NodesFetcherMock {
     // A set of nodes, existing in the topology.