tests: add tests to check user-agent in request headers

Author: anshalshukla

Cargo.lock

@@ -38,5 +38,3 @@ zeroize = { workspace = true }
 
 [dev-dependencies]
 tokio = { workspace = true }
-mockito = { workspace = true }
-regex = { workspace = true }

common/eth2/Cargo.toml

@@ -691,6 +691,10 @@ impl ValidatorClientHttpClient {
         let url = self.make_graffiti_url(pubkey)?;
         self.delete(url).await
     }
+
+    pub async fn create_request<U: IntoUrl>(&self, url: U) -> Result<Response, Error> {
+        self.client.get(url).send().await.map_err(Error::from)
+    }
 }
 
 /// Returns `Ok(response)` if the response is a `200 OK` response or a
@@ -709,87 +713,3 @@ async fn ok_or_error(response: Response) -> Result<Response, Error> {
         Err(Error::StatusCode(status))
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use mockito::{Matcher, Server};
-    use std::str::FromStr;
-
-    #[test]
-    fn test_validator_client_creation_with_user_agent() {
-        let server = SensitiveUrl::parse("http://localhost:5062").unwrap();
-        let secret = "test-secret".to_string();
-
-        // Test authenticated client
-        let client = ValidatorClientHttpClient::new(server.clone(), secret.clone()).unwrap();
-        assert!(client.api_token().is_some());
-        assert_eq!(client.authorization_header, AuthorizationHeader::Bearer);
-
-        // Test unauthenticated client
-        let unauth_client = ValidatorClientHttpClient::new_unauthenticated(server).unwrap();
-        assert!(unauth_client.api_token().is_none());
-        assert_eq!(unauth_client.authorization_header, AuthorizationHeader::Omit);
-    }
-
-    #[tokio::test]
-    async fn test_validator_client_user_agent_in_requests() {
-        // Create mock server
-        let mut server = Server::new_async().await;
-        let expected_user_agent = lighthouse_version::user_agent();
-
-        // Mock the auth endpoint with user agent verification
-        let auth_mock = server
-            .mock("GET", "/lighthouse/auth")
-            .match_header("user-agent", expected_user_agent.as_str())
-            .with_status(200)
-            .with_body(r#"{"token_path":"/tmp/test","api_token":"test-token"}"#)
-            .create_async()
-            .await;
-
-        // Create client
-        let server_url = SensitiveUrl::parse(&server.url()).unwrap();
-        let client = ValidatorClientHttpClient::new_unauthenticated(server_url).unwrap();
-
-        // Make request - this should include the user agent header
-        let _result = client.get_auth().await;
-
-        // Verify the mock was called with correct user agent
-        auth_mock.assert_async().await;
-    }
-
-    #[tokio::test]
-    async fn test_validator_client_user_agent_with_auth_token() {
-        // Create mock server
-        let mut server = Server::new_async().await;
-        let expected_user_agent = lighthouse_version::user_agent();
-        let auth_token = "test-bearer-token";
-
-        // Mock the keystores endpoint with both user agent and authorization verification
-        let keystores_mock = server
-            .mock("GET", "/eth/v1/keystores")
-            .match_header("user-agent", expected_user_agent.as_str())
-            .match_header("authorization", format!("Bearer {}", auth_token).as_str())
-            .with_status(200)
-            .with_body(r#"{"data":[]}"#)
-            .create_async()
-            .await;
-
-        // Create authenticated client
-        let server_url = SensitiveUrl::parse(&server.url()).unwrap();
-        let client = ValidatorClientHttpClient::new(server_url, auth_token.to_string()).unwrap();
-
-        // Make request - this should include both user agent and authorization headers
-        let _result = client.get_keystores().await;
-
-        // Verify the mock was called with correct headers
-        keystores_mock.assert_async().await;
-    }
-
-    #[test]
-    fn test_authorization_header_display() {
-        assert_eq!(AuthorizationHeader::Omit.to_string(), "Omit");
-        assert_eq!(AuthorizationHeader::Basic.to_string(), "Basic");
-        assert_eq!(AuthorizationHeader::Bearer.to_string(), "Bearer");
-    }
-}

common/eth2/src/lighthouse_vc/http_client.rs

@@ -22,12 +22,14 @@ use slot_clock::{SlotClock, TestingSlotClock};
 use std::future::Future;
 use std::net::{IpAddr, Ipv4Addr};
 use std::sync::Arc;
+use std::sync::Mutex;
 use std::time::Duration;
 use task_executor::test_utils::TestRuntime;
 use tempfile::{TempDir, tempdir};
 use tokio::sync::oneshot;
 use types::ChainSpec;
 use validator_services::block_service::BlockService;
+use warp::Filter;
 use zeroize::Zeroizing;
 
 pub const PASSWORD_BYTES: &[u8] = &[42, 50, 37];
@@ -436,6 +438,33 @@ impl ApiTester {
         self
     }
 
+    pub async fn test_user_agent_is_set(self) -> Self {
+        let captured: Arc<Mutex<Option<String>>> = Arc::new(Mutex::new(None));
+        let captured_filter = captured.clone();
+
+        // Warp route: capture User-Agent header
+        let route = warp::any()
+            .and(warp::header::optional::<String>("user-agent"))
+            .map(move |ua: Option<String>| {
+                *captured_filter.lock().unwrap() = ua;
+                warp::reply()
+            });
+
+        // Start ephemeral server
+        let (addr, server) = warp::serve(route).bind_ephemeral(([127, 0, 0, 1], 0));
+        tokio::spawn(server);
+
+        // Make a request (simulate Lighthouse client)
+        let url = format!("http://{}/", addr);
+        let _client = self.client.create_request(&url).await;
+
+        // Check captured User-Agent
+        let ua = captured.lock().unwrap().clone().unwrap();
+        assert_eq!(ua, lighthouse_version::user_agent());
+
+        self
+    }
+
     pub async fn create_keystore_validators(self, s: KeystoreValidatorScenario) -> Self {
         let initial_vals = self.vals_total();
         let initial_enabled_vals = self.vals_enabled();

validator_client/http_api/src/test_utils.rs

@@ -1,4 +1,3 @@
-#![cfg(test)]
 #![cfg(not(debug_assertions))]
 
 mod keystores;
@@ -27,11 +26,13 @@ use std::future::Future;
 use std::net::{IpAddr, Ipv4Addr};
 use std::str::FromStr;
 use std::sync::Arc;
+use std::sync::Mutex;
 use std::time::Duration;
 use task_executor::test_utils::TestRuntime;
 use tempfile::{TempDir, tempdir};
 use types::graffiti::GraffitiString;
 use validator_store::ValidatorStore;
+use warp::Filter;
 use zeroize::Zeroizing;
 
 const PASSWORD_BYTES: &[u8] = &[42, 50, 37];
@@ -401,6 +402,33 @@ impl ApiTester {
         self
     }
 
+    pub async fn test_user_agent_is_set(self) -> Self {
+        let captured: Arc<Mutex<Option<String>>> = Arc::new(Mutex::new(None));
+        let captured_filter = captured.clone();
+
+        // Warp route: capture User-Agent header
+        let route = warp::any()
+            .and(warp::header::optional::<String>("user-agent"))
+            .map(move |ua: Option<String>| {
+                *captured_filter.lock().unwrap() = ua;
+                warp::reply()
+            });
+
+        // Start ephemeral server
+        let (addr, server) = warp::serve(route).bind_ephemeral(([127, 0, 0, 1], 0));
+        tokio::spawn(server);
+
+        // Make a request (simulate Lighthouse client)
+        let url = format!("http://{}/", addr);
+        let _client = self.client.create_request(&url).await;
+
+        // Check captured User-Agent
+        let ua = captured.lock().unwrap().clone().unwrap();
+        assert_eq!(ua, lighthouse_version::user_agent());
+
+        self
+    }
+
     pub async fn create_keystore_validators(self, s: KeystoreValidatorScenario) -> Self {
         let initial_vals = self.vals_total();
         let initial_enabled_vals = self.vals_enabled();
@@ -1043,6 +1071,11 @@ async fn validator_exit() {
         .await;
 }
 
+#[tokio::test]
+async fn user_agent_is_set() {
+    ApiTester::new().await.test_user_agent_is_set().await;
+}
+
 #[tokio::test]
 async fn validator_enabling() {
     ApiTester::new()