remove all hardcoded ports from tests

Author: JasonVranek

benches/microbench/src/get_header.rs

@@ -43,13 +43,13 @@ use axum::http::HeaderMap;
 use cb_common::{pbs::GetHeaderParams, signer::random_secret, types::Chain, utils::EncodingType};
 use cb_pbs::{PbsState, get_header};
 use cb_tests::{
-    mock_relay::{MockRelayState, start_mock_relay_service},
-    utils::{generate_mock_relay, get_pbs_config, to_pbs_config},
+    mock_relay::{MockRelayState, start_mock_relay_service_with_listener},
+    utils::{generate_mock_relay, get_free_listener, get_pbs_config, to_pbs_config},
 };
 use criterion::{Criterion, black_box, criterion_group, criterion_main};
 
-// Ports 19201–19205 are reserved for the microbenchmark mock relays.
-const BASE_PORT: u16 = 19200;
+// Mock relay ports are allocated dynamically via get_free_listener() so that
+// parallel test/bench runs don't collide on hardcoded ports.
 const CHAIN: Chain = Chain::Hoodi;
 const MAX_RELAYS: usize = 5;
 const RELAY_COUNTS: [usize; 3] = [1, 3, MAX_RELAYS];
@@ -83,10 +83,23 @@ fn bench_get_header(c: &mut Criterion) {
         let pubkey = signer.public_key();
         let mock_state = Arc::new(MockRelayState::new(CHAIN, signer));
 
-        let relay_clients: Vec<_> = (0..MAX_RELAYS)
-            .map(|i| {
-                let port = BASE_PORT + 1 + i as u16;
-                tokio::spawn(start_mock_relay_service(mock_state.clone(), port));
+        // Allocate all listeners upfront so each port is reserved until the
+        // server takes ownership — avoids TOCTOU bind races.
+        let listeners: Vec<_> = {
+            let mut v = Vec::with_capacity(MAX_RELAYS);
+            for _ in 0..MAX_RELAYS {
+                v.push(get_free_listener().await);
+            }
+            v
+        };
+        let ports: Vec<u16> = listeners.iter().map(|l| l.local_addr().unwrap().port()).collect();
+
+        let relay_clients: Vec<_> = listeners
+            .into_iter()
+            .enumerate()
+            .map(|(i, listener)| {
+                let port = ports[i];
+                tokio::spawn(start_mock_relay_service_with_listener(mock_state.clone(), listener));
                 generate_mock_relay(port, pubkey.clone()).expect("relay client")
             })
             .collect();

tests/src/mock_relay.rs

@@ -40,11 +40,17 @@ use tracing::{debug, error};
 use tree_hash::TreeHash;
 
 pub async fn start_mock_relay_service(state: Arc<MockRelayState>, port: u16) -> eyre::Result<()> {
-    let app = mock_relay_app_router(state);
-
     let socket = SocketAddr::new("0.0.0.0".parse()?, port);
     let listener = TcpListener::bind(socket).await?;
+    start_mock_relay_service_with_listener(state, listener).await
+}
 
+/// Like [`start_mock_relay_service`], but accepts a pre-bound [`TcpListener`].
+pub async fn start_mock_relay_service_with_listener(
+    state: Arc<MockRelayState>,
+    listener: TcpListener,
+) -> eyre::Result<()> {
+    let app = mock_relay_app_router(state);
     axum::serve(listener, app).await?;
     Ok(())
 }

tests/src/mock_ssv_public.rs

@@ -30,6 +30,18 @@ pub async fn create_mock_public_ssv_server(
     port: u16,
     state: Option<PublicSsvMockState>,
 ) -> Result<JoinHandle<()>, axum::Error> {
+    let address = SocketAddr::from(([127, 0, 0, 1], port));
+    let listener = TcpListener::bind(address).await.map_err(axum::Error::new)?;
+    create_mock_public_ssv_server_with_listener(listener, state).await
+}
+
+/// Like [`create_mock_public_ssv_server`], but accepts a pre-bound
+/// [`TcpListener`].
+pub async fn create_mock_public_ssv_server_with_listener(
+    listener: TcpListener,
+    state: Option<PublicSsvMockState>,
+) -> Result<JoinHandle<()>, axum::Error> {
+    let port = listener.local_addr().map(|a| a.port()).unwrap_or(0);
     let data = include_str!("../../tests/data/ssv_valid_public.json");
     let response =
         serde_json::from_str::<SSVPublicResponse>(data).expect("failed to parse test data");
@@ -46,8 +58,6 @@ pub async fn create_mock_public_ssv_server(
         .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");
     });

tests/src/utils.rs

@@ -27,6 +27,18 @@ pub fn get_local_address(port: u16) -> String {
     format!("http://0.0.0.0:{port}")
 }
 
+/// Bind to port 0 and let the OS assign an unused ephemeral port.
+///
+/// The returned listener keeps the port reserved. Pass it to
+/// [`start_mock_relay_service_with_listener`] so the socket is never released
+/// between allocation and use (zero TOCTOU race). For servers that bind
+/// internally (e.g. `PbsService::run`), read the port with
+/// `listener.local_addr().unwrap().port()`, then `drop` the listener
+/// immediately before starting the server.
+pub async fn get_free_listener() -> tokio::net::TcpListener {
+    tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap()
+}
+
 static SYNC_SETUP: Once = Once::new();
 pub fn setup_test_env() {
     SYNC_SETUP.call_once(|| {

tests/tests/pbs_cfg_file_update.rs

@@ -12,9 +12,11 @@ use cb_common::{
 };
 use cb_pbs::{DefaultBuilderApi, PbsService, PbsState};
 use cb_tests::{
-    mock_relay::{MockRelayState, start_mock_relay_service},
+    mock_relay::{MockRelayState, start_mock_relay_service_with_listener},
     mock_validator::MockValidator,
-    utils::{generate_mock_relay, get_pbs_config, setup_test_env, to_pbs_config},
+    utils::{
+        generate_mock_relay, get_free_listener, get_pbs_config, setup_test_env, to_pbs_config,
+    },
 };
 use eyre::Result;
 use lh_types::ForkName;
@@ -32,20 +34,23 @@ async fn test_cfg_file_update() -> Result<()> {
     let pubkey = signer.public_key();
 
     let chain = Chain::Hoodi;
-    let pbs_port = 3730;
+    let pbs_listener = get_free_listener().await;
+    let relay1_listener = get_free_listener().await;
+    let relay2_listener = get_free_listener().await;
+    let pbs_port = pbs_listener.local_addr().unwrap().port();
+    let relay1_port = relay1_listener.local_addr().unwrap().port();
+    let relay2_port = relay2_listener.local_addr().unwrap().port();
 
     // Start relay 1
-    let relay1_port = pbs_port + 1;
     let relay1 = generate_mock_relay(relay1_port, pubkey.clone())?;
     let relay1_state = Arc::new(MockRelayState::new(chain, signer.clone()));
-    tokio::spawn(start_mock_relay_service(relay1_state.clone(), relay1_port));
+    tokio::spawn(start_mock_relay_service_with_listener(relay1_state.clone(), relay1_listener));
 
     // Start relay 2
-    let relay2_port = relay1_port + 1;
     let relay2 = generate_mock_relay(relay2_port, pubkey.clone())?;
     let relay2_id = relay2.id.clone().to_string();
     let relay2_state = Arc::new(MockRelayState::new(chain, signer));
-    tokio::spawn(start_mock_relay_service(relay2_state.clone(), relay2_port));
+    tokio::spawn(start_mock_relay_service_with_listener(relay2_state.clone(), relay2_listener));
 
     // Make a config with relay 1 only
     let pbs_config = PbsConfig {
@@ -109,6 +114,7 @@ async fn test_cfg_file_update() -> Result<()> {
     // Run the PBS service
     let config = to_pbs_config(chain, get_pbs_config(pbs_port), vec![relay1.clone()]);
     let state = PbsState::new(config, config_path.clone());
+    drop(pbs_listener);
     tokio::spawn(PbsService::run::<(), DefaultBuilderApi>(state));
 
     // leave some time to start servers - extra time for the file watcher