386 lines
12 KiB
Rust
386 lines
12 KiB
Rust
//! 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<u8>,
|
|
chunked: bool,
|
|
require_auth: Option<String>,
|
|
location: Option<String>,
|
|
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<AtomicBool>,
|
|
auth_seen: Arc<Mutex<Vec<String>>>,
|
|
}
|
|
|
|
impl Drop for Server {
|
|
fn drop(&mut self) {
|
|
self.stop.store(true, Ordering::SeqCst);
|
|
}
|
|
}
|
|
|
|
fn spawn_server(routes: Vec<Route>) -> 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<Mutex<Vec<String>>>,
|
|
) -> 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"
|
|
);
|
|
}
|