diff --git a/codex-rs/Cargo.lock b/codex-rs/Cargo.lock index a72f837ac4..dcd85231bd 100644 --- a/codex-rs/Cargo.lock +++ b/codex-rs/Cargo.lock @@ -3089,8 +3089,15 @@ dependencies = [ name = "codex-exec-server-test-support" version = "0.0.0" dependencies = [ + "anyhow", "codex-exec-server", "codex-http-client", + "futures", + "prost", + "serde_json", + "tokio", + "tokio-tungstenite", + "wiremock", ] [[package]] diff --git a/codex-rs/exec-server/BUILD.bazel b/codex-rs/exec-server/BUILD.bazel index edd3380811..d70b389698 100644 --- a/codex-rs/exec-server/BUILD.bazel +++ b/codex-rs/exec-server/BUILD.bazel @@ -1,5 +1,10 @@ load("//:defs.bzl", "codex_rust_crate") +exports_files( + ["src/proto/codex.exec_server.relay.v1.rs"], + visibility = ["//codex-rs/exec-server/tests/support:__pkg__"], +) + codex_rust_crate( name = "exec-server", crate_name = "codex_exec_server", diff --git a/codex-rs/exec-server/tests/common/relay.rs b/codex-rs/exec-server/tests/common/relay.rs index 977b70d1ba..cca0f967a4 100644 --- a/codex-rs/exec-server/tests/common/relay.rs +++ b/codex-rs/exec-server/tests/common/relay.rs @@ -1,34 +1,20 @@ -#[path = "../../src/proto/codex.exec_server.relay.v1.rs"] -mod relay_proto; - use std::sync::Arc; use std::sync::Mutex; -use std::time::Duration; use anyhow::Context; use anyhow::Result; use codex_api::AuthProvider; use codex_exec_server::ExecServerClient; use codex_exec_server::NoiseChannelIdentity; -use codex_exec_server::NoiseChannelPublicKey; use codex_exec_server::NoiseRendezvousConnectArgs; use codex_exec_server::NoiseRendezvousConnectBundle; use codex_exec_server::RemoteEnvironmentConfig; use codex_http_client::HttpClientFactory; use codex_http_client::OutboundProxyPolicy; -use futures::SinkExt; -use futures::StreamExt; use http::HeaderMap; use http::HeaderValue; -use prost::Message as ProstMessage; -use relay_proto::RelayMessageFrame; -use relay_proto::relay_message_frame; use tokio::net::TcpListener; -use tokio::net::TcpStream; use tokio::time::timeout; -use tokio_tungstenite::WebSocketStream; -use tokio_tungstenite::accept_async; -use tokio_tungstenite::tungstenite::Message; use tokio_util::task::AbortOnDropHandle; use wiremock::Mock; use wiremock::MockServer; @@ -37,11 +23,16 @@ use wiremock::matchers::header; use wiremock::matchers::method; use wiremock::matchers::path; +pub(crate) use codex_exec_server_test_support::relay::TEST_TIMEOUT; +pub(crate) use codex_exec_server_test_support::relay::accept_websocket; +pub(crate) use codex_exec_server_test_support::relay::assert_relay_data_is_encrypted; +pub(crate) use codex_exec_server_test_support::relay::proxy_relay_frames; +pub(crate) use codex_exec_server_test_support::relay::registered_executor_public_key; + pub(crate) const ENVIRONMENT_ID: &str = "env-noise-relay-test"; pub(crate) const EXECUTOR_REGISTRATION_ID: &str = "registration-1"; pub(crate) const HARNESS_KEY_AUTHORIZATION: &str = "harness-key-authorization"; pub(crate) const REGISTRY_TOKEN: &str = "registry-token"; -pub(crate) const TEST_TIMEOUT: Duration = Duration::from_secs(30); #[derive(Debug)] struct StaticRegistryAuthProvider; @@ -163,92 +154,3 @@ impl RelayConnection { let _ = self.relay_task.await; } } - -pub(crate) async fn accept_websocket( - listener: &TcpListener, - role: &str, -) -> Result> { - let (socket, _peer_addr) = timeout(TEST_TIMEOUT, listener.accept()) - .await - .with_context(|| format!("remote {role} should connect to fake rendezvous"))??; - timeout(TEST_TIMEOUT, accept_async(socket)) - .await - .with_context(|| format!("fake rendezvous should accept {role} websocket"))? - .map_err(Into::into) -} - -pub(crate) async fn registered_executor_public_key( - registry: &MockServer, -) -> Result { - let requests = registry - .received_requests() - .await - .context("wiremock should retain requests")?; - let request = requests - .iter() - .find(|request| request.url.path().ends_with("/register")) - .context("exec-server should register before connecting")?; - let body: serde_json::Value = serde_json::from_slice(&request.body)?; - let key = serde_json::from_value(body["executor_public_key"].clone())?; - Ok(key) -} - -pub(crate) async fn proxy_relay_frames( - mut environment: WebSocketStream, - mut harness: WebSocketStream, - captured_frames: Arc>>>, -) -> Result<()> { - loop { - tokio::select! { - message = environment.next() => { - let Some(message) = message else { - break; - }; - let message = message?; - capture_binary_frame(&captured_frames, &message); - harness.send(message).await?; - } - message = harness.next() => { - let Some(message) = message else { - break; - }; - let message = message?; - capture_binary_frame(&captured_frames, &message); - environment.send(message).await?; - } - } - } - Ok(()) -} - -fn capture_binary_frame(captured_frames: &Mutex>>, message: &Message) { - if let Message::Binary(bytes) = message { - captured_frames - .lock() - .unwrap_or_else(std::sync::PoisonError::into_inner) - .push(bytes.to_vec()); - } -} - -pub(crate) fn assert_relay_data_is_encrypted(captured_frames: &Mutex>>) -> Result<()> { - let captured_frames = captured_frames - .lock() - .unwrap_or_else(std::sync::PoisonError::into_inner); - let mut data_frames = 0; - for encoded in captured_frames.iter() { - let frame = RelayMessageFrame::decode(encoded.as_slice())?; - let Some(relay_message_frame::Body::Data(data)) = frame.body else { - continue; - }; - data_frames += 1; - let payload = String::from_utf8_lossy(&data.payload); - assert!(!payload.contains("initialize")); - assert!(!payload.contains("process/start")); - assert!(!payload.contains("noise-relay-test")); - } - assert!( - data_frames >= 4, - "expected encrypted request and response frames" - ); - Ok(()) -} diff --git a/codex-rs/exec-server/tests/support/BUILD.bazel b/codex-rs/exec-server/tests/support/BUILD.bazel index 8e09d7dafd..6bb55d52be 100644 --- a/codex-rs/exec-server/tests/support/BUILD.bazel +++ b/codex-rs/exec-server/tests/support/BUILD.bazel @@ -2,6 +2,7 @@ load("//:defs.bzl", "codex_rust_crate") codex_rust_crate( name = "support", + compile_data = ["//codex-rs/exec-server:src/proto/codex.exec_server.relay.v1.rs"], crate_name = "codex_exec_server_test_support", crate_srcs = glob(["*.rs"]), ) diff --git a/codex-rs/exec-server/tests/support/Cargo.toml b/codex-rs/exec-server/tests/support/Cargo.toml index 85ad347b6c..073d4e3411 100644 --- a/codex-rs/exec-server/tests/support/Cargo.toml +++ b/codex-rs/exec-server/tests/support/Cargo.toml @@ -13,5 +13,12 @@ doctest = false workspace = true [dependencies] +anyhow = { workspace = true } codex-exec-server = { workspace = true } codex-http-client = { workspace = true } +futures = { workspace = true } +prost = "0.14.3" +serde_json = { workspace = true } +tokio = { workspace = true, features = ["macros", "net", "time"] } +tokio-tungstenite = { workspace = true } +wiremock = { workspace = true } diff --git a/codex-rs/exec-server/tests/support/lib.rs b/codex-rs/exec-server/tests/support/lib.rs index 5234363564..bc29a2b17c 100644 --- a/codex-rs/exec-server/tests/support/lib.rs +++ b/codex-rs/exec-server/tests/support/lib.rs @@ -2,6 +2,8 @@ use codex_exec_server::EnvironmentManager; use codex_http_client::HttpClientFactory; use codex_http_client::OutboundProxyPolicy; +pub mod relay; + /// Builds a manager without environments using the legacy outbound HTTP policy. pub fn environment_manager_without_environments() -> EnvironmentManager { EnvironmentManager::without_environments(HttpClientFactory::new( diff --git a/codex-rs/exec-server/tests/support/relay.rs b/codex-rs/exec-server/tests/support/relay.rs new file mode 100644 index 0000000000..569f15dfb9 --- /dev/null +++ b/codex-rs/exec-server/tests/support/relay.rs @@ -0,0 +1,113 @@ +#[path = "../../src/proto/codex.exec_server.relay.v1.rs"] +mod relay_proto; + +use std::sync::Arc; +use std::sync::Mutex; +use std::time::Duration; + +use anyhow::Context; +use anyhow::Result; +use codex_exec_server::NoiseChannelPublicKey; +use futures::SinkExt; +use futures::StreamExt; +use prost::Message as ProstMessage; +use relay_proto::RelayMessageFrame; +use relay_proto::relay_message_frame; +use tokio::net::TcpListener; +use tokio::net::TcpStream; +use tokio::time::timeout; +use tokio_tungstenite::WebSocketStream; +use tokio_tungstenite::accept_async; +use tokio_tungstenite::tungstenite::Message; +use wiremock::MockServer; + +pub const TEST_TIMEOUT: Duration = Duration::from_secs(30); + +pub async fn accept_websocket( + listener: &TcpListener, + role: &str, +) -> Result> { + let (socket, _peer_addr) = timeout(TEST_TIMEOUT, listener.accept()) + .await + .with_context(|| format!("remote {role} should connect to fake rendezvous"))??; + timeout(TEST_TIMEOUT, accept_async(socket)) + .await + .with_context(|| format!("fake rendezvous should accept {role} websocket"))? + .map_err(Into::into) +} + +pub async fn registered_executor_public_key( + registry: &MockServer, +) -> Result { + let requests = registry + .received_requests() + .await + .context("wiremock should retain requests")?; + let request = requests + .iter() + .find(|request| request.url.path().ends_with("/register")) + .context("exec-server should register before connecting")?; + let body: serde_json::Value = serde_json::from_slice(&request.body)?; + let key = serde_json::from_value(body["executor_public_key"].clone())?; + Ok(key) +} + +pub async fn proxy_relay_frames( + mut environment: WebSocketStream, + mut harness: WebSocketStream, + captured_frames: Arc>>>, +) -> Result<()> { + loop { + tokio::select! { + message = environment.next() => { + let Some(message) = message else { + break; + }; + let message = message?; + capture_binary_frame(&captured_frames, &message); + harness.send(message).await?; + } + message = harness.next() => { + let Some(message) = message else { + break; + }; + let message = message?; + capture_binary_frame(&captured_frames, &message); + environment.send(message).await?; + } + } + } + Ok(()) +} + +fn capture_binary_frame(captured_frames: &Mutex>>, message: &Message) { + if let Message::Binary(bytes) = message { + captured_frames + .lock() + .unwrap_or_else(std::sync::PoisonError::into_inner) + .push(bytes.to_vec()); + } +} + +pub fn assert_relay_data_is_encrypted(captured_frames: &Mutex>>) -> Result<()> { + let captured_frames = captured_frames + .lock() + .unwrap_or_else(std::sync::PoisonError::into_inner); + let mut data_frames = 0; + for encoded in captured_frames.iter() { + let frame = RelayMessageFrame::decode(encoded.as_slice())?; + let Some(relay_message_frame::Body::Data(data)) = frame.body else { + continue; + }; + data_frames += 1; + let payload = String::from_utf8_lossy(&data.payload); + assert!(!payload.contains("initialize")); + assert!(!payload.contains("process/start")); + assert!(!payload.contains("noise-relay-test")); + } + assert!( + data_frames >= 4, + "expected encrypted request and response frames" + ); + Ok(()) +}