fix and add tests

Author: AlexanderKlump

src/service.rs

@@ -8,9 +8,8 @@ use std::pin::Pin;
 
 type BoxFuture<T> = Pin<Box<dyn Future<Output = T> + Send + 'static>>;
 
-/// Wraps an S3 service and short-circuits `GET /` and `GET /health` requests,
-/// returning `200 OK` with a plain-text `"Status OK"` body without forwarding
-/// them to the S3 layer or requiring authentication.
+/// Wraps an S3 service and short-circuits `GET /health` and `GET /upstream-health`
+/// requests without forwarding them to the S3 layer or requiring authentication.
 #[derive(Clone)]
 pub struct S3CachingServiceProxy<S> {
     inner: S,

tests/integration_health.rs

@@ -5,9 +5,15 @@ use std::net::SocketAddr;
 use tokio::net::TcpStream;
 
 async fn start_test_server() -> (SocketAddr, tokio::sync::oneshot::Sender<()>) {
+    start_test_server_with_upstream("http://127.0.0.1:1").await
+}
+
+async fn start_test_server_with_upstream(
+    upstream: &str,
+) -> (SocketAddr, tokio::sync::oneshot::Sender<()>) {
     let config = s3_cache::Config {
         listen_addr: "127.0.0.1:0".parse().unwrap(),
-        upstream_endpoint: "http://127.0.0.1:1".to_string(),
+        upstream_endpoint: upstream.to_string(),
         upstream_access_key_id: "test".to_string(),
         upstream_secret_access_key: "test".to_string(),
         upstream_region: "us-east-1".to_string(),
@@ -60,6 +66,37 @@ async fn http_get(addr: SocketAddr, path: &str) -> (u16, String) {
     (status, String::from_utf8_lossy(&body).to_string())
 }
 
+async fn start_fake_upstream(status: u16) -> (SocketAddr, tokio::sync::oneshot::Sender<()>) {
+    let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
+    let addr = listener.local_addr().unwrap();
+
+    let (shutdown_tx, mut shutdown_rx) = tokio::sync::oneshot::channel::<()>();
+
+    tokio::spawn(async move {
+        loop {
+            let (stream, _) = tokio::select! {
+                result = listener.accept() => result.unwrap(),
+                _ = &mut shutdown_rx => break,
+            };
+            tokio::spawn(async move {
+                let service = hyper::service::service_fn(move |_req| {
+                    let resp = hyper::Response::builder()
+                        .status(status)
+                        .body(http_body_util::Empty::<Bytes>::new())
+                        .unwrap();
+                    std::future::ready(Ok::<_, std::convert::Infallible>(resp))
+                });
+                hyper::server::conn::http1::Builder::new()
+                    .serve_connection(TokioIo::new(stream), service)
+                    .await
+                    .ok();
+            });
+        }
+    });
+
+    (addr, shutdown_tx)
+}
+
 // MARK: - Health
 
 #[tokio::test(flavor = "multi_thread")]
@@ -69,25 +106,51 @@ async fn health_check_ok() {
     let (status, body) = http_get(addr, "/health").await;
 
     assert_eq!(status, 200);
-    assert_eq!(body, "Status OK");
+    assert_eq!(body, "");
 }
 
 #[tokio::test(flavor = "multi_thread")]
-async fn health_check_root_ok() {
+async fn health_check_does_not_require_auth() {
     let (addr, _shutdown) = start_test_server().await;
 
-    let (status, body) = http_get(addr, "/").await;
+    // No Authorization header — must still succeed
+    let (status, _) = http_get(addr, "/health").await;
 
     assert_eq!(status, 200);
-    assert_eq!(body, "Status OK");
 }
 
 #[tokio::test(flavor = "multi_thread")]
-async fn health_check_does_not_require_auth() {
-    let (addr, _shutdown) = start_test_server().await;
+async fn upstream_health_returns_ok_when_upstream_is_healthy() {
+    let (upstream_addr, _upstream_shutdown) = start_fake_upstream(200).await;
+    let upstream_url = format!("http://{upstream_addr}");
 
-    // No Authorization header — must still succeed
-    let (status, _) = http_get(addr, "/health").await;
+    let (addr, _shutdown) = start_test_server_with_upstream(&upstream_url).await;
+    let (status, _) = http_get(addr, "/upstream-health").await;
 
     assert_eq!(status, 200);
 }
+
+#[tokio::test(flavor = "multi_thread")]
+async fn upstream_health_returns_same_status_code_as_upstream() {
+    let random_http_status_code = 201;
+    let (upstream_addr, _upstream_shutdown) = start_fake_upstream(random_http_status_code).await;
+    let upstream_url = format!("http://{upstream_addr}");
+
+    let (addr, _shutdown) = start_test_server_with_upstream(&upstream_url).await;
+    let (status, _) = http_get(addr, "/upstream-health").await;
+
+    assert_eq!(status, random_http_status_code);
+}
+
+#[tokio::test(flavor = "multi_thread")]
+async fn upstream_health_returns_500_when_upstream_is_unreachable() {
+    let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
+    let dead_addr = listener.local_addr().unwrap();
+    drop(listener);
+
+    let upstream_url = format!("http://{dead_addr}");
+    let (addr, _shutdown) = start_test_server_with_upstream(&upstream_url).await;
+    let (status, _) = http_get(addr, "/upstream-health").await;
+
+    assert_eq!(status, 500);
+}