v0.25.1

src/balance/tests/part_02.rs

@@ -0,0 +1,170 @@
+    #[tokio::test]
+    async fn opaque_cookie_is_removed_from_origin_requests_and_protected_on_responses() {
+        let pool = pool(Algorithm::RoundRobin, StickyMode::Cookie);
+        let first = select(&pool);
+        let cookie = first.cookie.unwrap().to_str().unwrap().to_owned();
+        assert!(
+            cookie.contains("HttpOnly")
+                && cookie.contains("SameSite=Lax")
+                && !cookie.contains("Secure")
+        );
+        let cookie = cookie.split(';').next().unwrap();
+        let mut headers = HeaderMap::new();
+        headers.insert("cookie", format!("{cookie}; app=ok").parse().unwrap());
+        let next = pool
+            .select("10.0.0.1".parse().unwrap(), &headers, false)
+            .unwrap();
+        assert_eq!(
+            next.lease.member.definition.id,
+            first.lease.member.definition.id
+        );
+        assert!(next.cookie.is_none());
+        pool.strip_affinity(&mut headers);
+        assert_eq!(headers["cookie"], "app=ok");
+        headers.append(
+            "set-cookie",
+            format!("{}=origin-spoof", pool.cookie_name)
+                .parse()
+                .unwrap(),
+        );
+        headers.append("set-cookie", "app=ok".parse().unwrap());
+        pool.strip_affinity_response(&mut headers);
+        assert_eq!(headers.get_all("set-cookie").iter().count(), 1);
+        assert_eq!(headers["set-cookie"], "app=ok");
+        let secure = pool
+            .select("127.0.0.1".parse().unwrap(), &HeaderMap::new(), true)
+            .unwrap();
+        assert!(secure
+            .cookie
+            .unwrap()
+            .to_str()
+            .unwrap()
+            .contains("; Secure"));
+    }
+    #[tokio::test]
+    async fn failed_sticky_member_is_replaced_and_duplicate_cookies_are_ignored() {
+        let pool = pool(Algorithm::RoundRobin, StickyMode::Cookie);
+        let first = select(&pool);
+        let cookie = first
+            .cookie
+            .unwrap()
+            .to_str()
+            .unwrap()
+            .split(';')
+            .next()
+            .unwrap()
+            .to_owned();
+        let mut headers = HeaderMap::new();
+        headers.insert("cookie", format!("{cookie}; {cookie}").parse().unwrap());
+        assert!(pool.affinity(&headers).is_none());
+        headers.insert("cookie", cookie.parse().unwrap());
+        lock(&first.lease.member.state.health).healthy = false;
+        let next = pool
+            .select("127.0.0.1".parse().unwrap(), &headers, false)
+            .unwrap();
+        assert_ne!(
+            next.lease.member.definition.id,
+            first.lease.member.definition.id
+        );
+        assert!(next.cookie.is_some());
+        lock(&next.lease.member.state.health).healthy = false;
+        assert!(pool
+            .select("127.0.0.1".parse().unwrap(), &headers, false)
+            .is_none());
+    }
+    #[tokio::test]
+    async fn slow_start_ramps_weight_and_error_is_counted_once_per_exchange() {
+        let pool = pool(Algorithm::LeastConnections, StickyMode::Off);
+        let selected = select(&pool);
+        let state = &selected.lease.member.state;
+        assert!(state.weight(100, 100) < 100.0);
+        assert_eq!(state.weight(100, 0), 100.0);
+        selected.lease.started();
+        selected.lease.bytes(50, true);
+        selected.lease.bytes(100, false);
+        selected.lease.error("timeout", Duration::from_secs(1));
+        selected.lease.error("body", Duration::from_secs(2));
+        selected.lease.retry_attempted();
+        selected.lease.retry_succeeded();
+        assert_eq!(state.requests.load(Ordering::Relaxed), 1);
+        assert_eq!(state.errors.load(Ordering::Relaxed), 1);
+        assert_eq!(state.timeouts_total.load(Ordering::Relaxed), 1);
+        assert_eq!(state.io_errors_total.load(Ordering::Relaxed), 1);
+        assert_eq!(state.bytes_in.load(Ordering::Relaxed), 50);
+        assert_eq!(state.bytes_out.load(Ordering::Relaxed), 100);
+        assert_eq!(state.retry_attempts_total.load(Ordering::Relaxed), 1);
+        assert_eq!(state.retry_successes_total.load(Ordering::Relaxed), 1);
+        assert!(pool
+            .prometheus()
+            .contains("rust_proxy_backend_requests_total{vhost=\"app\",backend=\"a\"} 1"));
+        assert!(pool
+            .prometheus()
+            .contains("rust_proxy_backend_retry_attempts_total{vhost=\"app\",backend=\"a\"} 1"));
+    }
+    #[tokio::test]
+    async fn slow_5xx_counts_both_observability_classes_when_passive_is_off() {
+        let pool = pool(Algorithm::LeastConnections, StickyMode::Off);
+        let selected = select(&pool);
+        selected.lease.response(500, Duration::from_secs(20), true);
+        let state = &selected.lease.member.state;
+        assert_eq!(state.http_5xx_total.load(Ordering::Relaxed), 1);
+        assert_eq!(state.slow_responses_total.load(Ordering::Relaxed), 1);
+        assert_eq!(state.passive_health_failures_total.load(Ordering::Relaxed), 0);
+        assert!(state.healthy());
+    }
+
+    #[tokio::test]
+    async fn client_upload_duration_does_not_trigger_passive_slow_failure() {
+        let pool = pool(Algorithm::LeastConnections, StickyMode::Off);
+        let upload = select(&pool);
+        upload.lease.response(200, Duration::from_secs(20), false);
+        assert_eq!(upload.lease.member.state.errors.load(Ordering::Relaxed), 0);
+        let read = select(&pool);
+        read.lease.response(200, Duration::from_secs(20), true);
+        assert_eq!(read.lease.member.state.errors.load(Ordering::Relaxed), 1);
+    }
+    #[tokio::test]
+    async fn backup_is_only_new_assignment_when_no_primary_is_eligible() {
+        let mut pool = pool(Algorithm::RoundRobin, StickyMode::Off);
+        Arc::get_mut(&mut Arc::get_mut(&mut pool).unwrap().members[1])
+            .unwrap()
+            .definition
+            .backup = true;
+        for _ in 0..8 {
+            assert_eq!(select(&pool).lease.member.definition.id, "a");
+        }
+        lock(&pool.members[0].state.health).healthy = false;
+        assert_eq!(select(&pool).lease.member.definition.id, "b");
+        lock(&pool.members[0].state.health).healthy = true;
+        assert_eq!(select(&pool).lease.member.definition.id, "a");
+    }
+    #[tokio::test]
+    async fn drain_rejects_new_sessions_but_preserves_valid_existing_affinity() {
+        let mut pool = pool(Algorithm::RoundRobin, StickyMode::Cookie);
+        Arc::get_mut(&mut Arc::get_mut(&mut pool).unwrap().members[0])
+            .unwrap()
+            .definition
+            .drain = true;
+        assert_eq!(select(&pool).lease.member.definition.id, "b");
+        let mut headers = HeaderMap::new();
+        headers.insert(
+            "cookie",
+            format!("{}={}", pool.cookie_name, pool.members[0].token)
+                .parse()
+                .unwrap(),
+        );
+        let existing = pool
+            .select("127.0.0.1".parse().unwrap(), &headers, false)
+            .unwrap();
+        assert_eq!(existing.lease.member.definition.id, "a");
+        lock(&pool.members[0].state.health).healthy = false;
+        assert_eq!(
+            pool.select("127.0.0.1".parse().unwrap(), &headers, false)
+                .unwrap()
+                .lease
+                .member
+                .definition
+                .id,
+            "b"
+        );
+    }