Added a unit test for the SSV node mock

Author: jclapis

Cargo.lock

@@ -13,6 +13,7 @@ cb-signer.workspace = true
 eyre.workspace = true
 lh_types.workspace = true
 reqwest.workspace = true
+serde.workspace = true
 serde_json.workspace = true
 tempfile.workspace = true
 tokio.workspace = true

tests/Cargo.toml

@@ -0,0 +1,22 @@
+{
+  "data": [
+    {
+      "public_key": "aa370f6250d421d00437b9900407a7ad93b041aeb7259d99b55ab8b163277746680e93e841f87350737bceee46aa104d",
+      "index": "1311498",
+      "status": "active_ongoing",
+      "activation_epoch": "273156",
+      "exit_epoch": "18446744073709551615",
+      "owner": "5e33db0b37622f7e6b2f0654aa7b985d854ea9cb",
+      "committee": [
+        1,
+        2,
+        3,
+        4
+      ],
+      "quorum": 0,
+      "partial_quorum": 0,
+      "graffiti": "",
+      "liquidated": false
+    }
+  ]
+}

tests/data/ssv_valid_node.json

@@ -1,4 +1,5 @@
 pub mod mock_relay;
-pub mod mock_ssv;
+pub mod mock_ssv_node;
+pub mod mock_ssv_public;
 pub mod mock_validator;
 pub mod utils;

tests/data/ssv_valid.json tests/data/ssv_valid_public.jsontests/data/ssv_valid.json renamed to tests/data/ssv_valid_public.json

@@ -0,0 +1,118 @@
+use std::{net::SocketAddr, sync::Arc};
+
+use alloy::primitives::U256;
+use axum::{
+    extract::{Json, State},
+    response::Response,
+    routing::get,
+};
+use cb_common::{
+    config::MUXER_HTTP_MAX_LENGTH,
+    interop::ssv::types::{SSVNodeResponse, SSVNodeValidator},
+};
+use serde::Deserialize;
+use tokio::{net::TcpListener, sync::RwLock, task::JoinHandle};
+use tracing::info;
+
+pub const TEST_HTTP_TIMEOUT: u64 = 2;
+
+/// State for the mock server
+#[derive(Clone)]
+pub struct SsvNodeMockState {
+    /// List of pubkeys for the mock server to return
+    pub validators: Arc<RwLock<Vec<SSVNodeValidator>>>,
+
+    /// Whether to force a timeout response to simulate a server error
+    pub force_timeout: Arc<RwLock<bool>>,
+}
+
+#[derive(Deserialize)]
+struct SsvNodeValidatorsRequestBody {
+    pub operators: Vec<U256>,
+}
+
+/// Creates a simple mock server to simulate the SSV API endpoint under
+/// various conditions for testing. Note this ignores
+pub async fn create_mock_ssv_node_server(
+    port: u16,
+    state: Option<SsvNodeMockState>,
+) -> Result<JoinHandle<()>, axum::Error> {
+    let data = include_str!("../../tests/data/ssv_valid_node.json");
+    let response =
+        serde_json::from_str::<SSVNodeResponse>(data).expect("failed to parse test data");
+    let state = state.unwrap_or(SsvNodeMockState {
+        validators: Arc::new(RwLock::new(response.data)),
+        force_timeout: Arc::new(RwLock::new(false)),
+    });
+    let router = axum::Router::new()
+        .route("/v1/validators", get(handle_validators))
+        .route("/big_data", get(handle_big_data))
+        .with_state(state)
+        .into_make_service();
+
+    let address = SocketAddr::from(([127, 0, 0, 1], port));
+    let listener = TcpListener::bind(address).await.map_err(axum::Error::new)?;
+    let server = axum::serve(listener, router).with_graceful_shutdown(async {
+        tokio::signal::ctrl_c().await.expect("Failed to listen for shutdown signal");
+    });
+    let result = Ok(tokio::spawn(async move {
+        if let Err(e) = server.await {
+            eprintln!("Server error: {e}");
+        }
+    }));
+    info!("Mock server started on http://localhost:{port}/");
+    result
+}
+
+/// Returns a valid SSV validators response, or a timeout if requested in
+/// the server state
+async fn handle_validators(
+    State(state): State<SsvNodeMockState>,
+    Json(body): Json<SsvNodeValidatorsRequestBody>,
+) -> Response {
+    // Time out if requested
+    if *state.force_timeout.read().await {
+        return handle_timeout().await;
+    }
+
+    // Make sure the request deserialized properly
+    let _operators = body.operators;
+
+    // Generate the response based on the current validators
+    let response: SSVNodeResponse;
+    {
+        let validators = state.validators.read().await;
+        response = SSVNodeResponse { data: validators.clone() };
+    }
+
+    // Create a valid response
+    Response::builder()
+        .status(200)
+        .header("Content-Type", "application/json")
+        .body(serde_json::to_string(&response).unwrap().into())
+        .unwrap()
+}
+
+/// Sends a response with a large body - larger than the maximum allowed.
+/// Note that hyper overwrites the content-length header automatically, so
+/// setting it here wouldn't actually change the value that ultimately
+/// gets sent to the server.
+async fn handle_big_data() -> Response {
+    let body = "f".repeat(2 * MUXER_HTTP_MAX_LENGTH);
+    Response::builder()
+        .status(200)
+        .header("Content-Type", "application/text")
+        .body(body.into())
+        .unwrap()
+}
+
+/// Simulates a timeout by sleeping for a long time
+async fn handle_timeout() -> Response {
+    // Sleep for a long time to simulate a timeout
+    tokio::time::sleep(std::time::Duration::from_secs(2 * TEST_HTTP_TIMEOUT)).await;
+    Response::builder()
+        .status(200)
+        .header("Content-Type", "application/text")
+        .body("Timeout response".into())
+        .unwrap()
+}

tests/src/lib.rs

@@ -16,7 +16,7 @@ pub const TEST_HTTP_TIMEOUT: u64 = 2;
 
 /// State for the mock server
 #[derive(Clone)]
-pub struct SsvMockState {
+pub struct PublicSsvMockState {
     /// List of pubkeys for the mock server to return
     pub validators: Arc<RwLock<Vec<SSVPublicValidator>>>,
 
@@ -26,14 +26,14 @@ pub struct SsvMockState {
 
 /// Creates a simple mock server to simulate the SSV API endpoint under
 /// various conditions for testing. Note this ignores
-pub async fn create_mock_ssv_server(
+pub async fn create_mock_public_ssv_server(
     port: u16,
-    state: Option<SsvMockState>,
+    state: Option<PublicSsvMockState>,
 ) -> Result<JoinHandle<()>, axum::Error> {
-    let data = include_str!("../../tests/data/ssv_valid.json");
+    let data = include_str!("../../tests/data/ssv_valid_public.json");
     let response =
         serde_json::from_str::<SSVPublicResponse>(data).expect("failed to parse test data");
-    let state = state.unwrap_or(SsvMockState {
+    let state = state.unwrap_or(PublicSsvMockState {
         validators: Arc::new(RwLock::new(response.validators)),
         force_timeout: Arc::new(RwLock::new(false)),
     });
@@ -63,7 +63,7 @@ pub async fn create_mock_ssv_server(
 /// Returns a valid SSV validators response, or a timeout if requested in
 /// the server state
 async fn handle_validators(
-    State(state): State<SsvMockState>,
+    State(state): State<PublicSsvMockState>,
     Path((_, _)): Path<(String, u64)>,
 ) -> Response {
     // Time out if requested

tests/src/mock_ssv_node.rs

@@ -1,16 +1,18 @@
 use std::{collections::HashMap, sync::Arc, time::Duration};
 
+use alloy::primitives::U256;
 use cb_common::{
     config::{HTTP_TIMEOUT_SECONDS_DEFAULT, MUXER_HTTP_MAX_LENGTH, RuntimeMuxConfig},
-    interop::ssv::utils::request_ssv_pubkeys_from_public_api,
+    interop::ssv::utils::{request_ssv_pubkeys_from_public_api, request_ssv_pubkeys_from_ssv_node},
     signer::random_secret,
     types::Chain,
     utils::{ResponseReadError, set_ignore_content_length},
 };
 use cb_pbs::{DefaultBuilderApi, PbsService, PbsState};
 use cb_tests::{
     mock_relay::{MockRelayState, start_mock_relay_service},
-    mock_ssv::{SsvMockState, TEST_HTTP_TIMEOUT, create_mock_ssv_server},
+    mock_ssv_node::create_mock_ssv_node_server,
+    mock_ssv_public::{PublicSsvMockState, TEST_HTTP_TIMEOUT, create_mock_public_ssv_server},
     mock_validator::MockValidator,
     utils::{
         bls_pubkey_from_hex_unchecked, generate_mock_relay, get_pbs_static_config, setup_test_env,
@@ -25,10 +27,11 @@ use url::Url;
 
 #[tokio::test]
 /// Tests that a successful SSV network fetch is handled and parsed properly
-async fn test_ssv_network_fetch() -> Result<()> {
+/// from the public API
+async fn test_ssv_public_network_fetch() -> Result<()> {
     // Start the mock server
     let port = 30100;
-    let _server_handle = create_mock_ssv_server(port, None).await?;
+    let _server_handle = create_mock_public_ssv_server(port, None).await?;
     let url =
         Url::parse(&format!("http://localhost:{port}/api/v4/test_chain/validators/in_operator/1"))
             .unwrap();
@@ -37,11 +40,11 @@ async fn test_ssv_network_fetch() -> Result<()> {
             .await?;
 
     // Make sure the response is correct
-    // NOTE: requires that ssv_data.json dpesn't change
+    // NOTE: requires that ssv_valid_public.json doesn't change
     assert_eq!(response.validators.len(), 3);
     let expected_pubkeys = [
         bls_pubkey_from_hex_unchecked(
-            "967ba17a3e7f82a25aa5350ec34d6923e28ad8237b5a41efe2c5e325240d74d87a015bf04634f21900963539c8229b2a",
+            "aa370f6250d421d00437b9900407a7ad93b041aeb7259d99b55ab8b163277746680e93e841f87350737bceee46aa104d",
         ),
         bls_pubkey_from_hex_unchecked(
             "ac769e8cec802e8ffee34de3253be8f438a0c17ee84bdff0b6730280d24b5ecb77ebc9c985281b41ee3bda8663b6658c",
@@ -66,7 +69,8 @@ async fn test_ssv_network_fetch() -> Result<()> {
 async fn test_ssv_network_fetch_big_data() -> Result<()> {
     // Start the mock server
     let port = 30101;
-    let server_handle = cb_tests::mock_ssv::create_mock_ssv_server(port, None).await?;
+    let server_handle =
+        cb_tests::mock_ssv_public::create_mock_public_ssv_server(port, None).await?;
     let url = Url::parse(&format!("http://localhost:{port}/big_data")).unwrap();
     let response = request_ssv_pubkeys_from_public_api(url, Duration::from_secs(120)).await;
 
@@ -97,11 +101,11 @@ async fn test_ssv_network_fetch_big_data() -> Result<()> {
 async fn test_ssv_network_fetch_timeout() -> Result<()> {
     // Start the mock server
     let port = 30102;
-    let state = SsvMockState {
+    let state = PublicSsvMockState {
         validators: Arc::new(RwLock::new(vec![])),
         force_timeout: Arc::new(RwLock::new(true)),
     };
-    let server_handle = create_mock_ssv_server(port, Some(state)).await?;
+    let server_handle = create_mock_public_ssv_server(port, Some(state)).await?;
     let url =
         Url::parse(&format!("http://localhost:{port}/api/v4/test_chain/validators/in_operator/1"))
             .unwrap();
@@ -127,7 +131,7 @@ async fn test_ssv_network_fetch_big_data_without_content_length() -> Result<()>
     // Start the mock server
     let port = 30103;
     set_ignore_content_length(true);
-    let server_handle = create_mock_ssv_server(port, None).await?;
+    let server_handle = create_mock_public_ssv_server(port, None).await?;
     let url = Url::parse(&format!("http://localhost:{port}/big_data")).unwrap();
     let response = request_ssv_pubkeys_from_public_api(url, Duration::from_secs(120)).await;
 
@@ -152,6 +156,37 @@ async fn test_ssv_network_fetch_big_data_without_content_length() -> Result<()>
     Ok(())
 }
 
+#[tokio::test]
+/// Tests that a successful SSV network fetch is handled and parsed properly
+/// from the node API
+async fn test_ssv_node_network_fetch() -> Result<()> {
+    // Start the mock server
+    let port = 30104;
+    let _server_handle = create_mock_ssv_node_server(port, None).await?;
+    let url = Url::parse(&format!("http://localhost:{port}/v1/validators")).unwrap();
+    let response = request_ssv_pubkeys_from_ssv_node(
+        url,
+        U256::from(1),
+        Duration::from_secs(HTTP_TIMEOUT_SECONDS_DEFAULT),
+    )
+    .await?;
+
+    // Make sure the response is correct
+    // NOTE: requires that ssv_valid_node.json doesn't change
+    assert_eq!(response.data.len(), 1);
+    let expected_pubkeys = [bls_pubkey_from_hex_unchecked(
+        "aa370f6250d421d00437b9900407a7ad93b041aeb7259d99b55ab8b163277746680e93e841f87350737bceee46aa104d",
+    )];
+    for (i, validator) in response.data.iter().enumerate() {
+        assert_eq!(validator.public_key, expected_pubkeys[i]);
+    }
+
+    // Clean up the server handle
+    _server_handle.abort();
+
+    Ok(())
+}
+
 #[tokio::test]
 async fn test_mux() -> Result<()> {
     setup_test_env();

tests/src/mock_ssv.rs tests/src/mock_ssv_public.rstests/src/mock_ssv.rs renamed to tests/src/mock_ssv_public.rs

@@ -9,7 +9,7 @@ use cb_common::{
 use cb_pbs::{DefaultBuilderApi, PbsService, PbsState};
 use cb_tests::{
     mock_relay::{MockRelayState, start_mock_relay_service},
-    mock_ssv::{SsvMockState, create_mock_ssv_server},
+    mock_ssv_public::{PublicSsvMockState, create_mock_public_ssv_server},
     mock_validator::MockValidator,
     utils::{generate_mock_relay, get_pbs_static_config, to_pbs_config},
 };
@@ -44,14 +44,14 @@ async fn test_auto_refresh() -> Result<()> {
     let ssv_api_port = pbs_port + 1;
     // Intentionally missing a trailing slash to ensure this is handled properly
     let ssv_api_url = Url::parse(&format!("http://localhost:{ssv_api_port}/api/v4"))?;
-    let mock_ssv_state = SsvMockState {
+    let mock_ssv_state = PublicSsvMockState {
         validators: Arc::new(RwLock::new(vec![SSVPublicValidator {
             pubkey: existing_mux_pubkey.clone(),
         }])),
         force_timeout: Arc::new(RwLock::new(false)),
     };
     let ssv_server_handle =
-        create_mock_ssv_server(ssv_api_port, Some(mock_ssv_state.clone())).await?;
+        create_mock_public_ssv_server(ssv_api_port, Some(mock_ssv_state.clone())).await?;
 
     // Start a default relay for non-mux keys
     let default_relay_port = ssv_api_port + 1;