205 lines
8.7 KiB
Rust
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());
|
|
}
|