Files
2026-10-16 21:09:00 -03:00

205 lines
8.7 KiB
Rust

//! Local HTTP coverage for the OpenAI-compatible curl backend.
use std::io::{Read, Write};
use std::net::{TcpListener, TcpStream};
use std::sync::mpsc::{Receiver, channel};
use std::time::{Duration, Instant};
use notescraft_acp::{ChatMessage, Event, OpenAiConfig, OpenAiProcess, SessionUpdate, test_connection};
const WAIT: Duration = Duration::from_secs(5);
fn server(handler: impl FnOnce(TcpStream) + Send + 'static) -> String {
let listener = TcpListener::bind("127.0.0.1:0").expect("bind");
let address = listener.local_addr().expect("address");
listener.set_nonblocking(true).expect("nonblocking");
std::thread::spawn(move || {
let start = Instant::now();
while start.elapsed() < WAIT {
match listener.accept() {
Ok((stream, _)) => {
stream.set_nonblocking(false).expect("blocking stream");
stream.set_read_timeout(Some(WAIT)).expect("read timeout");
stream.set_write_timeout(Some(WAIT)).expect("write timeout");
handler(stream);
return;
}
Err(error) if error.kind() == std::io::ErrorKind::WouldBlock => std::thread::sleep(Duration::from_millis(5)),
Err(error) => panic!("accept: {error}"),
}
}
});
format!("http://{address}/v1")
}
fn read_request(stream: &mut TcpStream) -> String {
let mut bytes = Vec::new();
loop {
let mut byte = [0];
assert_eq!(stream.read(&mut byte).expect("request"), 1);
bytes.extend_from_slice(&byte);
if bytes.ends_with(b"\r\n\r\n") {
break;
}
}
let headers = String::from_utf8(bytes).expect("headers");
let length = headers
.lines()
.find_map(|line| line.to_lowercase().strip_prefix("content-length: ").and_then(|value| value.parse::<usize>().ok()))
.expect("content length");
let mut body = vec![0; length];
stream.read_exact(&mut body).expect("body");
format!("{headers}{}", String::from_utf8(body).expect("JSON"))
}
fn config(url: String) -> OpenAiConfig {
OpenAiConfig::new(url, "test-model", "PATH")
}
fn messages() -> Vec<ChatMessage> {
vec![ChatMessage { role: "user".into(), content: "hello".into() }]
}
fn next(events: &Receiver<Event>) -> Event {
events.recv_timeout(WAIT).expect("event within deadline")
}
#[test]
fn streams_chunks_before_completion_and_sends_request() {
let (tx, rx) = channel();
let url = server(move |mut stream| {
tx.send(read_request(&mut stream)).expect("request channel");
stream.write_all(b"HTTP/1.1 200 OK\r\nContent-Type: text/event-stream\r\nConnection: close\r\n\r\n: comment\r\ndata: {\"choices\":[{\"delta\":{\"content\":\"hello\"},\"finish_reason\":null}]}\r\n\r\n").expect("first chunk");
std::thread::sleep(Duration::from_millis(300));
stream.write_all(b"data: {\"choices\":[{\"delta\":{\"content\":\" world\"},\"finish_reason\":\"stop\"}]}\n\ndata: [DONE]\n\n").expect("last chunk");
});
let process = OpenAiProcess::spawn(&config(url), &messages()).expect("spawn");
assert!(matches!(next(process.events()), Event::Update(SessionUpdate::AgentMessageChunk(text)) if text == "hello"));
let request = rx.recv_timeout(WAIT).expect("request");
assert!(request.starts_with("POST /v1/chat/completions "));
assert!(request.contains("Authorization: Bearer "));
assert!(request.contains("\"stream\":true"));
assert!(matches!(next(process.events()), Event::Update(SessionUpdate::AgentMessageChunk(text)) if text == " world"));
assert!(matches!(next(process.events()), Event::PromptDone { stop_reason } if stop_reason == "stop"));
}
#[test]
fn reports_http_status_and_only_first_300_body_bytes() {
let url = server(|mut stream| {
read_request(&mut stream);
let body = format!("denied{}SENSITIVE_TAIL", "x".repeat(294));
write!(stream, "HTTP/1.1 401 Unauthorized\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}", body.len()).expect("response");
});
let process = OpenAiProcess::spawn(&config(url), &messages()).expect("spawn");
assert!(matches!(next(process.events()), Event::Error(text) if text.contains("401") && text.contains("denied") && !text.contains("SENSITIVE_TAIL")));
assert!(matches!(next(process.events()), Event::PromptDone { stop_reason } if stop_reason == "error"));
}
#[test]
fn silent_server_times_out() {
let url = server(|mut stream| {
read_request(&mut stream);
std::thread::sleep(Duration::from_secs(2));
});
let mut settings = config(url);
settings.timeout = Duration::from_millis(150);
let process = OpenAiProcess::spawn(&settings, &messages()).expect("spawn");
assert!(matches!(next(process.events()), Event::Error(text) if text.contains("timed out")));
}
#[test]
fn cancel_kills_connection_promptly() {
let (tx, rx) = channel();
let url = server(move |mut stream| {
read_request(&mut stream);
tx.send(()).expect("connected");
let mut byte = [0];
assert_eq!(stream.read(&mut byte).expect("peer closes"), 0);
});
let process = OpenAiProcess::spawn(&config(url), &messages()).expect("spawn");
rx.recv_timeout(WAIT).expect("connected");
let start = Instant::now();
process.cancel();
assert!(start.elapsed() < Duration::from_secs(1));
assert!(matches!(next(process.events()), Event::PromptDone { stop_reason } if stop_reason == "cancelled"));
}
#[test]
fn settings_test_uses_small_nonstreaming_request() {
let (tx, rx) = channel();
let url = server(move |mut stream| {
tx.send(read_request(&mut stream)).expect("request channel");
let body = r#"{"choices":[{"message":{"content":"OK"}}]}"#;
write!(stream, "HTTP/1.1 200 OK\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}", body.len()).expect("response");
});
test_connection(&config(url)).expect("test connection");
let request = rx.recv_timeout(WAIT).expect("request");
assert!(request.contains("\"stream\":false"));
assert!(request.contains("\"max_tokens\":1"));
}
#[test]
fn rejects_oversized_sse_line() {
let url = server(|mut stream| {
read_request(&mut stream);
stream.write_all(b"HTTP/1.1 200 OK\r\nConnection: close\r\n\r\ndata: ").expect("headers");
stream.write_all(&vec![b'x'; 1024 * 1024 + 1]).expect("oversized data");
stream.shutdown(std::net::Shutdown::Write).expect("finish sending");
let mut byte = [0];
let _ = stream.read(&mut byte);
});
let process = OpenAiProcess::spawn(&config(url), &messages()).expect("spawn");
let event = next(process.events());
assert!(matches!(&event, Event::Error(text) if text.contains("size limit")), "{event:?}");
}
#[test]
fn malformed_sse_json_is_reported() {
let url = server(|mut stream| {
read_request(&mut stream);
stream.write_all(b"HTTP/1.1 200 OK\r\nConnection: close\r\n\r\ndata: {\n\n").expect("response");
});
let process = OpenAiProcess::spawn(&config(url), &messages()).expect("spawn");
assert!(matches!(next(process.events()), Event::Error(text) if text.contains("invalid SSE JSON")));
}
#[test]
fn drop_stops_worker_with_full_event_channel() {
let (tx, rx) = channel();
let url = server(move |mut stream| {
read_request(&mut stream);
stream.write_all(b"HTTP/1.1 200 OK\r\nConnection: close\r\n\r\n").expect("headers");
for _ in 0..2000 {
if stream.write_all(b"data: {\"choices\":[{\"delta\":{\"content\":\"x\"}}]}\n\n").is_err() {
return;
}
}
tx.send(()).expect("sent");
let mut byte = [0];
let _ = stream.read(&mut byte);
});
let process = OpenAiProcess::spawn(&config(url), &messages()).expect("spawn");
rx.recv_timeout(WAIT).expect("server sent chunks");
let start = Instant::now();
drop(process);
assert!(start.elapsed() < Duration::from_secs(1));
}
#[test]
fn rejects_missing_key_and_credentials_in_url_before_spawn() {
let mut settings = config("https://example.invalid/v1".into());
settings.api_key_env = "NOTESCRAFT_TEST_MISSING_KEY_3D3A21".into();
assert!(matches!(OpenAiProcess::spawn(&settings, &messages()), Err(error) if error.to_string().contains("set NOTESCRAFT_TEST_MISSING_KEY")));
assert!(OpenAiProcess::spawn(&config("https://secret@example.invalid/v1".into()), &messages()).is_err());
}
#[test]
fn settings_test_rejects_choices_without_message() {
let url = server(|mut stream| {
read_request(&mut stream);
let body = r#"{"choices":[{}]}"#;
write!(stream, "HTTP/1.1 200 OK\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}", body.len()).expect("response");
});
assert!(test_connection(&config(url)).is_err());
}