0.32.8_fix_tests

src/balance/tests.rs

@@ -646,121 +646,122 @@ mod tests {
             "b"
         );
     }
-}
 
-#[test]
-fn passive_ejection_remembers_first_real_error_and_trigger() {
-    let state = BackendState::new(HealthMode::Off);
-    let active = settings(HealthMode::Off);
-    let passive = PassiveHealth {
-        enabled: true,
-        fall: Some(2),
-        ..Default::default()
-    };
-    let elapsed = Duration::from_millis(3);
-    assert!(state
-        .observe_passive_with_detail(
-            &active,
-            &passive,
-            "connect_error",
-            "dns",
-            "first lookup failed",
-            elapsed
-        )
-        .is_none());
-    let (first, failures) = state
-        .observe_passive_with_detail(
-            &active,
-            &passive,
-            "connect_error",
-            "connect",
-            "second TCP failed",
-            elapsed,
-        )
-        .expect("the threshold crossing must return the first failure");
-    assert_eq!(failures, 2);
-    assert_eq!(first.class, "dns");
-    assert_eq!(first.detail, "first lookup failed");
-    assert!(!state.healthy());
-    assert!(
-        state
+    #[test]
+    fn passive_ejection_remembers_first_real_error_and_trigger() {
+        let state = BackendState::new(HealthMode::Off);
+        let active = settings(HealthMode::Off);
+        let passive = PassiveHealth {
+            enabled: true,
+            fall: Some(2),
+            ..Default::default()
+        };
+        let elapsed = Duration::from_millis(3);
+        assert!(state
+            .observe_passive_with_detail(
+                &active,
+                &passive,
+                "connect_error",
+                "dns",
+                "first lookup failed",
+                elapsed
+            )
+            .is_none());
+        let (first, failures) = state
             .observe_passive_with_detail(
                 &active,
                 &passive,
                 "connect_error",
                 "connect",
-                "third TCP failed",
-                elapsed
+                "second TCP failed",
+                elapsed,
             )
-            .is_none(),
-        "the ejection must be logged only once"
-    );
-}
-
-#[test]
-fn passive_io_burst_is_one_observation_not_many_failed_connections() {
-    let state = BackendState::new(HealthMode::Off);
-    let active = settings(HealthMode::Off);
-    let passive = PassiveHealth {
-        enabled: true,
-        fall: Some(3),
-        ..Default::default()
-    };
-    for _ in 0..20 {
-        state.observe_passive_with_detail(
-            &active,
-            &passive,
-            "io_error",
-            "io_error",
-            "connection closed",
-            Duration::from_millis(1),
+            .expect("the threshold crossing must return the first failure");
+        assert_eq!(failures, 2);
+        assert_eq!(first.class, "dns");
+        assert_eq!(first.detail, "first lookup failed");
+        assert!(!state.healthy());
+        assert!(
+            state
+                .observe_passive_with_detail(
+                    &active,
+                    &passive,
+                    "connect_error",
+                    "connect",
+                    "third TCP failed",
+                    elapsed
+                )
+                .is_none(),
+            "the ejection must be logged only once"
         );
     }
-    assert!(state.healthy());
-    assert_eq!(state.io_errors_total.load(Ordering::Relaxed), 20);
-    assert_eq!(
-        state.passive_health_failures_total.load(Ordering::Relaxed),
-        1
-    );
-}
 
-#[test]
-fn passive_only_quarantine_expires_without_vhost_reload() {
-    let state = BackendState::new(HealthMode::Off);
-    let active = settings(HealthMode::Off);
-    let passive = PassiveHealth {
-        enabled: true,
-        fall: Some(1),
-        ..Default::default()
-    };
-    state.observe_passive(&active, &passive, "connect_error", Duration::ZERO);
-    assert!(!state.healthy());
-    lock(&state.health).passive_ejected_at = Some(Instant::now() - Duration::from_secs(10));
-    assert!(
-        state.healthy(),
-        "a half-open traffic attempt must become possible"
-    );
-}
+    #[test]
+    fn passive_io_burst_is_one_observation_not_many_failed_connections() {
+        let state = BackendState::new(HealthMode::Off);
+        let active = settings(HealthMode::Off);
+        let passive = PassiveHealth {
+            enabled: true,
+            fall: Some(3),
+            ..Default::default()
+        };
+        for _ in 0..20 {
+            state.observe_passive_with_detail(
+                &active,
+                &passive,
+                "io_error",
+                "io_error",
+                "connection closed",
+                Duration::from_millis(1),
+            );
+        }
+        assert!(state.healthy());
+        assert_eq!(state.io_errors_total.load(Ordering::Relaxed), 20);
+        assert_eq!(
+            state.passive_health_failures_total.load(Ordering::Relaxed),
+            1
+        );
+    }
 
-#[test]
-fn active_probe_successes_recover_a_passively_ejected_backend() {
-    let state = BackendState::new(HealthMode::Http);
-    let active = HealthCheck {
-        fall: 1,
-        rise: 1,
-        ..settings(HealthMode::Http)
-    };
-    let passive = PassiveHealth {
-        enabled: true,
-        fall: Some(1),
-        ..Default::default()
-    };
-    state.observe_active(&active, "ok", Duration::ZERO);
-    assert!(state.healthy());
-    state.observe_passive(&active, &passive, "connect_error", Duration::ZERO);
-    assert!(!state.healthy());
-    state.observe_active(&active, "ok", Duration::ZERO);
-    assert!(!state.healthy());
-    state.observe_active(&active, "ok", Duration::ZERO);
-    assert!(state.healthy());
-}
+    #[test]
+    fn passive_only_quarantine_expires_without_vhost_reload() {
+        let state = BackendState::new(HealthMode::Off);
+        let active = settings(HealthMode::Off);
+        let passive = PassiveHealth {
+            enabled: true,
+            fall: Some(1),
+            ..Default::default()
+        };
+        state.observe_passive(&active, &passive, "connect_error", Duration::ZERO);
+        assert!(!state.healthy());
+        lock(&state.health).passive_ejected_at = Some(Instant::now() - Duration::from_secs(10));
+        assert!(
+            state.healthy(),
+            "a half-open traffic attempt must become possible"
+        );
+    }
+
+    #[test]
+    fn active_probe_successes_recover_a_passively_ejected_backend() {
+        let state = BackendState::new(HealthMode::Http);
+        let active = HealthCheck {
+            fall: 1,
+            rise: 1,
+            ..settings(HealthMode::Http)
+        };
+        let passive = PassiveHealth {
+            enabled: true,
+            fall: Some(1),
+            ..Default::default()
+        };
+        state.observe_active(&active, "ok", Duration::ZERO);
+        assert!(state.healthy());
+        state.observe_passive(&active, &passive, "connect_error", Duration::ZERO);
+        assert!(!state.healthy());
+        state.observe_active(&active, "ok", Duration::ZERO);
+        assert!(!state.healthy());
+        state.observe_active(&active, "ok", Duration::ZERO);
+        assert!(state.healthy());
+    }
+
+} // mod tests