use crate::http::HttpClient;
#[tokio::test]
async fn test_http_client_full_workflow() {
let client = HttpClient::new(30).unwrap();
client.set_default_token("test_token_123".to_string());
let get_builder = client
.get("https://httpbin.org/get")
.header("X-Test-Header", "test-value")
.query("param1", "value1")
.query("param2", "value2")
.timeout(60);
drop(get_builder);
use serde::Serialize;
#[derive(Serialize)]
struct TestPayload {
name: String,
value: i32,
}
let payload = TestPayload {
name: "test".to_string(),
value: 42,
};
let post_builder = client
.post("https://httpbin.org/post")
.json(&payload)
.unwrap()
.bearer_token("override_token");
drop(post_builder);
let put_builder = client.put("https://httpbin.org/put").text("Hello, World!");
drop(put_builder);
let delete_builder = client.delete("https://httpbin.org/delete");
drop(delete_builder);
let patch_builder = client
.patch("https://httpbin.org/patch")
.form(vec![("key1", "value1"), ("key2", "value2")]);
drop(patch_builder);
}
#[tokio::test]
async fn test_tools_http_client_workflow() {
let tools = crate::tools::ToolsBuilder::new()
.http(HttpClient::new(30).unwrap())
.build()
.expect("注册 HTTP 客户端后应构建成功");
let client = tools.http().expect("已配置时应返回 HTTP 客户端");
let builder = client.get("https://httpbin.org/get").query("test", "value");
drop(builder);
}
#[test]
fn test_request_builder_content_types() {
let client = HttpClient::new(30).unwrap();
use serde::Serialize;
#[derive(Serialize)]
struct Data {
field: String,
}
let data = Data {
field: "value".to_string(),
};
let json_builder = client.post("https://api.example.com/data").json(&data);
assert!(json_builder.is_ok());
let form_builder = client
.post("https://api.example.com/form")
.form(vec![("key", "value")]);
drop(form_builder);
let text_builder = client
.post("https://api.example.com/text")
.text("plain text");
drop(text_builder);
let custom_builder = client
.post("https://api.example.com/custom")
.content_type("application/xml")
.body(b"<xml></xml>".to_vec());
drop(custom_builder);
}
#[test]
fn test_request_builder_authentication() {
let client = HttpClient::new(30).unwrap();
let bearer_builder = client
.get("https://api.example.com/protected")
.bearer_token("my_access_token");
drop(bearer_builder);
let custom_auth_builder = client
.get("https://api.example.com/protected")
.header("Authorization", "Basic dXNlcjpwYXNz");
drop(custom_auth_builder);
}
#[test]
fn test_request_builder_timeout() {
let client = HttpClient::new(30).unwrap();
let builder = client.get("https://api.example.com/slow").timeout(120);
drop(builder);
let default_builder = client.get("https://api.example.com/fast");
drop(default_builder);
}
#[test]
fn test_multiple_query_params() {
let client = HttpClient::new(30).unwrap();
let builder = client
.get("https://api.example.com/search")
.query("q", "rust")
.query("page", "1")
.query("limit", "10")
.query("sort", "relevance");
drop(builder);
let batch_builder = client.get("https://api.example.com/search").queries(vec![
("q", "rust"),
("page", "1"),
("limit", "10"),
("sort", "relevance"),
]);
drop(batch_builder);
}
#[test]
fn test_multiple_headers() {
let client = HttpClient::new(30).unwrap();
let builder = client
.get("https://api.example.com/data")
.header("X-Custom-1", "value1")
.header("X-Custom-2", "value2")
.header("X-Custom-3", "value3")
.user_agent("MyApp/1.0");
drop(builder);
let batch_builder = client.get("https://api.example.com/data").headers(vec![
("X-Custom-1", "value1"),
("X-Custom-2", "value2"),
("X-Custom-3", "value3"),
]);
drop(batch_builder);
}
#[test]
fn test_retry_config_default() {
let cfg = crate::http::RetryConfig::default();
assert_eq!(cfg.max_retries, 3);
assert_eq!(cfg.backoff_ms, 100);
assert_eq!(cfg.retry_on, vec![502, 503, 504]);
assert_eq!(cfg.total_budget_ms, 30_000);
assert_eq!(cfg.jitter_percent, 25);
}
#[test]
fn test_request_builder_with_retry() {
let client = HttpClient::new(30).unwrap();
let builder = client
.get("https://api.example.com/data")
.retry(crate::http::RetryConfig {
max_retries: 5,
retry_on: vec![500, 503],
backoff_ms: 10,
retry_non_idempotent: false,
total_budget_ms: 30_000,
jitter_percent: 25,
})
.header("X-Test", "1");
drop(builder);
}
#[tokio::test]
#[ignore = "依赖网络栈行为,发起真实连接;默认跳过"]
async fn test_retry_exhausts_on_connection_error() {
let client = HttpClient::new(1).unwrap();
let result = client
.get("http://127.0.0.1:1/never")
.retry(crate::http::RetryConfig {
max_retries: 2,
retry_on: vec![503],
backoff_ms: 1,
retry_non_idempotent: false,
total_budget_ms: 30_000,
jitter_percent: 25,
})
.send()
.await;
assert!(result.is_err(), "连接失败重试耗尽后应返回 Err");
}
async fn serve_once(
status_line: &'static str,
headers: String,
body: Vec<u8>,
) -> std::net::SocketAddr {
use tokio::io::{AsyncReadExt, AsyncWriteExt};
let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
.await
.expect("本地监听端口应可绑定");
let addr = listener.local_addr().expect("应能取得监听地址");
tokio::spawn(async move {
let Ok((mut stream, _)) = listener.accept().await else {
return;
};
let mut buf = [0u8; 4096];
let _ = stream.read(&mut buf).await;
let mut resp = Vec::new();
resp.extend_from_slice(status_line.as_bytes());
resp.extend_from_slice(headers.as_bytes());
resp.extend_from_slice(b"\r\n");
resp.extend_from_slice(&body);
let _ = stream.write_all(&resp).await;
let _ = stream.shutdown().await;
});
addr
}
#[tokio::test]
async fn test_response_bytes_exceeds_limit_via_content_length() {
let addr = serve_once(
"HTTP/1.1 200 OK\r\n",
"Content-Type: text/plain\r\nContent-Length: 1024\r\nConnection: close\r\n".to_string(),
vec![b'x'; 1024],
)
.await;
let client = HttpClient::with_config(crate::http::HttpClientConfig {
max_response_bytes: 64,
..crate::http::HttpClientConfig::default()
})
.expect("合法配置应创建客户端");
let response = client
.get(&format!("http://{addr}/large"))
.send()
.await
.expect("请求应成功(响应体读取前)");
let err = match response.bytes().await {
Ok(_) => panic!("超限响应体应被拒绝"),
Err(err) => err,
};
match err {
crate::error::BaseError::HttpResponseTooLarge { limit, actual } => {
assert_eq!(limit, 64);
assert_eq!(actual, Some(1024));
}
other => panic!("期望 HttpResponseTooLarge,实际: {other:?}"),
}
}
#[tokio::test]
async fn test_response_bytes_exceeds_limit_streaming() {
let addr = serve_once(
"HTTP/1.1 200 OK\r\n",
"Content-Type: text/plain\r\nConnection: close\r\n".to_string(),
vec![b'y'; 1024],
)
.await;
let client = HttpClient::with_config(crate::http::HttpClientConfig {
max_response_bytes: 64,
..crate::http::HttpClientConfig::default()
})
.expect("合法配置应创建客户端");
let response = client
.get(&format!("http://{addr}/large"))
.send()
.await
.expect("请求应成功(响应体读取前)");
let err = match response.bytes().await {
Ok(_) => panic!("超限响应体应被拒绝"),
Err(err) => err,
};
match err {
crate::error::BaseError::HttpResponseTooLarge { limit, actual } => {
assert_eq!(limit, 64);
assert_eq!(actual, None);
}
other => panic!("期望 HttpResponseTooLarge,实际: {other:?}"),
}
}
#[tokio::test]
async fn test_response_bytes_exactly_at_limit_succeeds() {
let limit = 1024usize;
let headers =
format!("Content-Type: text/plain\r\nContent-Length: {limit}\r\nConnection: close\r\n");
let addr = serve_once("HTTP/1.1 200 OK\r\n", headers, vec![b'z'; limit]).await;
let client = HttpClient::with_config(crate::http::HttpClientConfig {
max_response_bytes: limit,
..crate::http::HttpClientConfig::default()
})
.expect("合法配置应创建客户端");
let response = client
.get(&format!("http://{addr}/exact"))
.send()
.await
.expect("请求应成功");
let body = response
.bytes()
.await
.expect("恰好等于上限的响应体应成功读取");
assert_eq!(body.len(), limit);
}