Python
use openworker_runtime::{
model::Progress,
provider::{self, Decoder, Failure},
};
use serde_json::json;
use tokio::{
io::{AsyncReadExt, AsyncWriteExt},
net::TcpListener,
sync::mpsc,
};
#[test]
fn terminal_failures_never_become_completion() {
let required = &openworker_runtime::compaction::DEVIATIONS["rust"];
for (event, kind) in [
(
json!({"type":"response.failed","response":{"status":"failed","error":{"code":"server_error"}}}),
Failure::Transient,
),
(
json!({"type":"response.incomplete","response":{"incomplete_details":{"reason":"max_output_tokens"}}}),
Failure::Truncated,
),
(
json!({"type":"error","code":"misalignment_policy_violation"}),
Failure::SafetyBlocked,
),
] {
let mut parser = Decoder::default();
assert_eq!(parser.event(&event).unwrap_err().kind, kind);
assert_eq!(
parser.finish().is_ok(),
required["failed_terminal_is_success"].as_bool().unwrap()
);
}
let mut parser = Decoder::default();
assert_eq!(
parser
.event(&json!({"type":"response.output_text.delta","delta":"partial"}))
.unwrap(),
Some("partial".into())
);
let result = parser.finish();
assert_eq!(
result.is_ok(),
required["missing_terminal_is_success"].as_bool().unwrap()
);
assert_eq!(result.unwrap_err().kind, Failure::IncompleteStream);
}
#[test]
fn usage_and_private_provider_items_are_preserved_only_on_valid_completion() {
let mut parser = Decoder::default();
let items = json!([{"type":"reasoning","encrypted_content":"opaque"},{"type":"message","content":[{"type":"output_text","text":"hello"}]}]);
parser.event(&json!({"type":"response.completed","response":{"status":"completed","output":items,"usage":{"input_tokens":100,"output_tokens":20,"input_tokens_details":{"cached_tokens":80}}}})).unwrap();
let completed = parser.finish().unwrap();
assert_eq!(completed.output, items.as_array().unwrap().clone());
assert_eq!(completed.usage.as_ref().unwrap().input_tokens, 100);
assert_eq!(completed.usage.unwrap().cached_input_tokens, 80);
}
#[test]
fn safety_auth_and_quota_never_retry() {
for (status, code) in [
(403, "misalignment_policy_violation"),
(401, ""),
(429, "insufficient_quota"),
(400, ""),
] {
assert!(!provider::Error::new(provider::classify(status, code)).retryable());
}
let mut e = provider::Error::new(Failure::RateLimit);
e.retry_after = Some(31);
assert!(!e.retryable());
e.retry_after = Some(2);
assert!(e.retryable());
}
#[test]
fn safety_error_after_completed_event_still_blocks_dispatch() {
let mut decoder = Decoder::default();
decoder.event(&json!({"type":"response.completed","response":{"status":"completed","output":[{"type":"message","content":[{"type":"output_text","text":"done"}]}]}})).unwrap();
assert_eq!(
decoder
.event(&json!({"type":"error","code":"misalignment_policy_violation"}))
.unwrap_err()
.kind,
Failure::SafetyBlocked
);
assert!(decoder.finish().is_err());
}
async fn http_once(response: &str) -> (String, tokio::task::JoinHandle<()>) {
let server = TcpListener::bind("127.0.0.1:0").await.unwrap();
let address = server.local_addr().unwrap();
let response = response.to_string();
let task = tokio::spawn(async move {
let (mut socket, _) = server.accept().await.unwrap();
let mut request = [0; 8192];
let _ = socket.read(&mut request).await.unwrap();
socket.write_all(response.as_bytes()).await.unwrap();
});
(format!("http://{address}"), task)
}
#[tokio::test]
async fn real_http_parser_handles_rate_limit_and_truncated_stream() {
let body = r#"{"error":{"code":"rate_limit_exceeded"}}"#;
let (url,server)=http_once(&format!("HTTP/1.1 429 Too Many Requests\r\nRetry-After: 2\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",body.len(),body)).await;
let (tx, _) = mpsc::channel(10);
let error = provider::request(&reqwest::Client::new(), &url, "test-only", json!({}), tx)
.await
.unwrap_err();
server.await.unwrap();
assert_eq!(error.kind, Failure::RateLimit);
assert_eq!(error.retry_after, Some(2));
let body = "data: {\"type\":\"response.output_text.delta\",\"delta\":\"partial\"}\n\n";
let response = format!(
"HTTP/1.1 200 OK\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
body.len(),
body
);
let (url, server) = http_once(&response).await;
let (tx, mut rx) = mpsc::channel(10);
let error = provider::request(&reqwest::Client::new(), &url, "test-only", json!({}), tx)
.await
.unwrap_err();
server.await.unwrap();
assert_eq!(error.kind, Failure::IncompleteStream);
assert!(matches!(rx.recv().await, Some(Progress::OutputStarted)));
assert!(matches!(rx.recv().await,Some(Progress::Delta(t)) if t=="partial"));
assert!(rx.recv().await.is_none());
}
#[tokio::test]
async fn http_diagnostics_retain_status_and_request_id_without_upstream_body() {
let body = r#"{"error":{"code":"invalid_api_key","message":"secret=BODY_SENTINEL"}}"#;
let (url,server)=http_once(&format!("HTTP/1.1 401 Unauthorized\r\nX-Request-ID: req_fixture\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",body.len(),body)).await;
let (tx, _) = mpsc::channel(10);
let e = provider::request(&reqwest::Client::new(), &url, "KEY_SENTINEL", json!({}), tx)
.await
.unwrap_err();
server.await.unwrap();
assert_eq!(e.http_status, Some(401));
assert_eq!(e.request_id.as_deref(), Some("req_fixture"));
assert!(!e.retryable());
for text in [
e.to_string(),
serde_json::to_string(&e.diagnostic()).unwrap(),
] {
assert!(!text.contains("BODY_SENTINEL"));
assert!(!text.contains("KEY_SENTINEL"));
}
}
#[tokio::test]
async fn broken_http_error_body_keeps_known_status_and_request_id() {
let (url,server)=http_once("HTTP/1.1 401 Unauthorized\r\nX-Request-ID: req_broken\r\nContent-Length: 999\r\nConnection: close\r\n\r\npartial").await;
let (tx, _) = mpsc::channel(10);
let error = provider::request(&reqwest::Client::new(), &url, "test-only", json!({}), tx)
.await
.unwrap_err();
server.await.unwrap();
assert_eq!(error.http_status, Some(401));
assert_eq!(error.request_id.as_deref(), Some("req_broken"));
assert_eq!(error.code, Some("http_error_body_unavailable"));
assert_eq!(error.kind, Failure::Authentication);
}