//! Integration tests for the OpenCode HTTP client and protocol adapter over a //! **real** local TCP server and the **real** curl transport. //! //! These exercise the parts the fake-client unit tests cannot: the curl config //! encoding, HTTP status/marker parsing, de-chunking (including a multibyte //! character split across chunks), body-size limits, redirect refusal, and the //! request authentication. The server is a minimal hand-rolled HTTP/1.1 //! responder that terminates cleanly. use std::io::{Read, Write}; use std::net::{TcpListener, TcpStream}; use std::sync::atomic::{AtomicBool, Ordering}; use std::sync::{Arc, Mutex}; use std::thread; use std::time::Duration; use phoebus_core::{Redactor, SecretString}; use phoebus_executor::opencode_client::{CurlHttpClient, HttpClient, HttpRequest, OpenCodeClient}; use phoebus_executor::opencode_server::{probe, Endpoint, ProbeRequest}; use phoebus_executor::{Exec, Logger, RealRunner}; #[derive(Clone)] struct Route { method: String, /// Exact path match, or a prefix if it ends with `*`, or any method when /// `method` is `*`. path: String, status: u16, body: Vec, chunked: bool, require_auth: Option, location: Option, close_without_response: bool, } impl Route { fn get(path: &str, status: u16, body: &str) -> Self { Self { method: "GET".into(), path: path.into(), status, body: body.as_bytes().to_vec(), chunked: false, require_auth: None, location: None, close_without_response: false, } } fn method(method: &str, path: &str, status: u16, body: &str) -> Self { let mut route = Self::get(path, status, body); route.method = method.into(); route } fn matches(&self, method: &str, path: &str) -> bool { if self.method != "*" && self.method != method { return false; } if let Some(prefix) = self.path.strip_suffix('*') { path.starts_with(prefix) } else { path == self.path } } } struct Server { port: u16, stop: Arc, auth_seen: Arc>>, } impl Drop for Server { fn drop(&mut self) { self.stop.store(true, Ordering::SeqCst); } } fn spawn_server(routes: Vec) -> Server { let listener = TcpListener::bind("127.0.0.1:0").unwrap(); let port = listener.local_addr().unwrap().port(); listener.set_nonblocking(true).unwrap(); let stop = Arc::new(AtomicBool::new(false)); let stop_thread = stop.clone(); let auth_seen = Arc::new(Mutex::new(Vec::new())); let auth_thread = auth_seen.clone(); thread::spawn(move || { while !stop_thread.load(Ordering::SeqCst) { match listener.accept() { Ok((mut stream, _)) => { let _ = stream.set_read_timeout(Some(Duration::from_secs(5))); let _ = handle(&mut stream, &routes, &auth_thread); } Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock => { thread::sleep(Duration::from_millis(5)); } Err(_) => break, } } }); Server { port, stop, auth_seen, } } fn handle( stream: &mut TcpStream, routes: &[Route], auth_seen: &Arc>>, ) -> std::io::Result<()> { let mut buf = [0u8; 16384]; let n = stream.read(&mut buf)?; if n == 0 { return Ok(()); } let request = String::from_utf8_lossy(&buf[..n]).to_string(); let mut lines = request.lines(); let request_line = lines.next().unwrap_or(""); let mut parts = request_line.split_whitespace(); let method = parts.next().unwrap_or("").to_string(); let path = parts.next().unwrap_or("").to_string(); let auth = request .lines() .find_map(|l| { l.strip_prefix("Authorization:") .map(|v| v.trim().to_string()) }) .unwrap_or_default(); if !auth.is_empty() { auth_seen.lock().unwrap().push(auth.clone()); } // Routes are permanent: a test may issue the same request more than once // (e.g. once unauthenticated, once authenticated). let Some(route) = routes.iter().find(|r| r.matches(&method, &path)).cloned() else { let body = b"{}"; write_response(stream, 404, &[], body, false, None)?; return Ok(()); }; if route.close_without_response { return Ok(()); // drop the stream without a response } if let Some(expected) = &route.require_auth { if &auth != expected { write_response(stream, 401, &[], b"{}", false, None)?; return Ok(()); } } write_response( stream, route.status, &[], &route.body, route.chunked, route.location.as_deref(), ) } fn write_response( stream: &mut TcpStream, status: u16, extra: &[(String, String)], body: &[u8], chunked: bool, location: Option<&str>, ) -> std::io::Result<()> { let mut head = format!("HTTP/1.1 {status} X\r\n"); if let Some(location) = location { head.push_str(&format!("Location: {location}\r\n")); } for (k, v) in extra { head.push_str(&format!("{k}: {v}\r\n")); } if chunked { head.push_str("Transfer-Encoding: chunked\r\n"); } else { head.push_str(&format!("Content-Length: {}\r\n", body.len())); } head.push_str("Connection: close\r\n\r\n"); stream.write_all(head.as_bytes())?; if chunked { // Split the body into small chunks; the first cut may fall inside a // multibyte UTF-8 sequence. for chunk in body.chunks(3) { stream.write_all(format!("{:x}\r\n", chunk.len()).as_bytes())?; stream.write_all(chunk)?; stream.write_all(b"\r\n")?; } stream.write_all(b"0\r\n\r\n")?; } else { stream.write_all(body)?; } stream.flush() } fn test_exec() -> Exec { let dir = tempfile::tempdir().unwrap().keep(); let logger = Logger::open(dir.join("opencode.log"), Redactor::new(), false); Exec::new(Box::new(RealRunner::new()), logger, false, dir.clone(), dir) } fn base(port: u16) -> String { format!("http://127.0.0.1:{port}") } #[test] fn curl_transport_round_trips_and_preserves_status() { let server = spawn_server(vec![ Route::get("/global/health", 200, r#"{"healthy":true}"#), Route::get("/provider", 500, r#"{"all":[{"id":"x","models":{}}]}"#), ]); let exec = test_exec(); let http = CurlHttpClient::new(&exec); let ok = http .request(&HttpRequest::get(format!( "{}/global/health", base(server.port) ))) .unwrap(); assert_eq!(ok.status, 200); assert!(ok.body.contains("healthy")); // A 500 with a providers-shaped body is a 500; the status is not discarded. let failure = http .request(&HttpRequest::get(format!("{}/provider", base(server.port)))) .unwrap(); assert_eq!(failure.status, 500); } #[test] fn curl_transport_dechunks_a_multibyte_body_split_across_chunks() { // "héllo wörld" in UTF-8; chunk boundaries at 3 bytes split the multibyte // characters. curl must reassemble the bytes before we decode them. let text = "héllo wörld"; let server = spawn_server(vec![Route { chunked: true, ..Route::get("/chunked", 200, text) }]); let exec = test_exec(); let http = CurlHttpClient::new(&exec); let response = http .request(&HttpRequest::get(format!("{}/chunked", base(server.port)))) .unwrap(); assert_eq!(response.status, 200); assert_eq!(response.body, text); } #[test] fn curl_transport_refuses_an_oversized_body() { let big = "x".repeat(2 * 1024 * 1024); let server = spawn_server(vec![Route::get("/big", 200, &big)]); let exec = test_exec(); let http = CurlHttpClient::new(&exec); let mut request = HttpRequest::get(format!("{}/big", base(server.port))); request.max_body = 4096; assert!( http.request(&request).is_err(), "an oversized body must fail" ); } #[test] fn curl_transport_does_not_follow_redirects() { let mut redirect = Route::get("/redir", 302, ""); redirect.location = Some("/final".into()); let server = spawn_server(vec![redirect, Route::get("/final", 200, "landed")]); let exec = test_exec(); let http = CurlHttpClient::new(&exec); let response = http .request(&HttpRequest::get(format!("{}/redir", base(server.port)))) .unwrap(); assert_eq!(response.status, 302, "a redirect must not be followed"); assert!(!response.body.contains("landed")); } #[test] fn curl_transport_reports_an_abrupt_disconnect() { let server = spawn_server(vec![Route { close_without_response: true, ..Route::get("/drop", 200, "") }]); let exec = test_exec(); let http = CurlHttpClient::new(&exec); assert!(http .request(&HttpRequest::get(format!("{}/drop", base(server.port)))) .is_err()); } #[test] fn opencode_client_adapts_over_real_http() { let server = spawn_server(vec![ Route::get( "/global/health", 200, r#"{"healthy":true,"version":"1.18.32"}"#, ), Route::get( "/provider", 200, r#"{"all":[{"id":"deepseek","name":"DeepSeek","models":{"deepseek-chat":{}}}], "connected":["deepseek"],"default":{"deepseek":"deepseek-chat"}}"#, ), Route::method("POST", "/session", 200, r#"{"id":"ses_abc"}"#), Route::method( "POST", "/session/ses_abc/message", 200, r#"{"info":{"role":"assistant","time":{"created":1,"completed":2}}, "parts":[{"type":"text","text":"{\"version\":1}"}]}"#, ), Route::method("DELETE", "/session/ses_abc", 200, "true"), ]); let exec = test_exec(); let http = CurlHttpClient::new(&exec); let endpoint = Endpoint::parse(&base(server.port)).unwrap(); let mut request = ProbeRequest::new(); request.provider = Some("deepseek".into()); request.model = Some("deepseek-chat".into()); let capability = probe(&http, &endpoint, &request); assert_eq!( capability.state, phoebus_executor::opencode_server::ConnectionState::ModelCatalog ); assert!(capability.selected_model_available); let client = OpenCodeClient::new(&http, base(server.port), "deepseek", "deepseek-chat"); let reply = client.one_shot("system", "user").unwrap(); assert_eq!(reply.content, "{\"version\":1}"); assert!(reply.completed); } #[test] fn authentication_is_required_and_presented() { // The endpoint demands basic auth; the matching header is recorded. // base64("opencode:sekret"). let required = "Basic b3BlbmNvZGU6c2VrcmV0".to_string(); let mut route = Route::get( "/provider", 200, r#"{"all":[{"id":"x","models":{"m":{}}}],"connected":[]}"#, ); route.require_auth = Some(required.clone()); let server = spawn_server(vec![ Route { require_auth: Some(required), ..Route::get("/global/health", 200, r#"{"healthy":true}"#) }, route, ]); let exec = test_exec(); let http = CurlHttpClient::new(&exec); let endpoint = Endpoint::parse(&base(server.port)).unwrap(); // Without a credential the probe reports "authentication required". let mut request = ProbeRequest::new(); request.provider = Some("x".into()); request.model = Some("m".into()); let capability = probe(&http, &endpoint, &request); assert_eq!( capability.state, phoebus_executor::opencode_server::ConnectionState::AuthenticationRequired ); // With the credential it succeeds and the header was actually sent. let mut request = ProbeRequest::new(); request.auth = Some(SecretString::new("sekret")); let capability = probe(&http, &endpoint, &request); assert_eq!( capability.state, phoebus_executor::opencode_server::ConnectionState::ModelCatalog, "{capability:?}" ); assert!( server .auth_seen .lock() .unwrap() .iter() .any(|h| h.starts_with("Basic ")), "the Authorization header never reached the server" ); }