use crate::error::BaseError;
use crate::http::response::Response;
use reqwest::header::{HeaderMap, HeaderName, HeaderValue};
use reqwest::{Client, Method};
use serde::Serialize;
use std::time::Duration;
fn is_idempotent_method(method: &Method) -> bool {
*method == Method::GET
|| *method == Method::HEAD
|| *method == Method::OPTIONS
|| *method == Method::TRACE
|| *method == Method::PUT
|| *method == Method::DELETE
}
fn redact_url_for_log(url: &str) -> String {
let Ok(mut parsed_url) = reqwest::Url::parse(url) else {
return "<invalid-url>".to_string();
};
parsed_url.set_query(None);
parsed_url.set_fragment(None);
if !parsed_url.username().is_empty() {
let _ = parsed_url.set_username("***");
}
if parsed_url.password().is_some() {
let _ = parsed_url.set_password(Some("***"));
}
parsed_url.to_string()
}
#[derive(Debug, Clone)]
pub struct RetryConfig {
pub max_retries: u32,
pub retry_on: Vec<u16>,
pub backoff_ms: u64,
pub retry_non_idempotent: bool,
pub total_budget_ms: u64,
pub jitter_percent: u8,
}
impl Default for RetryConfig {
fn default() -> Self {
Self {
max_retries: 3,
retry_on: vec![502, 503, 504],
backoff_ms: 100,
retry_non_idempotent: false,
total_budget_ms: 30_000,
jitter_percent: 25,
}
}
}
impl RetryConfig {
const MAX_RETRIES: u32 = 10;
const MAX_BACKOFF_MS: u64 = 60_000;
const MAX_TOTAL_BUDGET_MS: u64 = 300_000;
pub fn validate(&self) -> Result<(), BaseError> {
if self.max_retries > Self::MAX_RETRIES {
return Err(BaseError::ParamInvalid(
"http.retry.max_retries".to_string(),
format!("最大重试次数不能超过 {}", Self::MAX_RETRIES),
));
}
if self.max_retries == 0 {
return Ok(());
}
if self.retry_on.is_empty() {
return Err(BaseError::ParamInvalid(
"http.retry.retry_on".to_string(),
"启用重试时 retry_on 不能为空".to_string(),
));
}
if let Some(status) = self
.retry_on
.iter()
.copied()
.find(|status| !(100..=599).contains(status))
{
return Err(BaseError::ParamInvalid(
"http.retry.retry_on".to_string(),
format!("非法 HTTP 状态码: {status}"),
));
}
if self.backoff_ms == 0 {
return Err(BaseError::ParamInvalid(
"http.retry.backoff_ms".to_string(),
"启用重试时初始退避时间必须大于 0 毫秒".to_string(),
));
}
if self.backoff_ms > Self::MAX_BACKOFF_MS {
return Err(BaseError::ParamInvalid(
"http.retry.backoff_ms".to_string(),
format!("初始退避时间不能超过 {} 毫秒", Self::MAX_BACKOFF_MS),
));
}
if self.total_budget_ms == 0 || self.total_budget_ms > Self::MAX_TOTAL_BUDGET_MS {
return Err(BaseError::ParamInvalid(
"http.retry.total_budget_ms".to_string(),
format!("重试总预算必须在 1..={} 毫秒内", Self::MAX_TOTAL_BUDGET_MS),
));
}
if self.jitter_percent > 100 {
return Err(BaseError::ParamInvalid(
"http.retry.jitter_percent".to_string(),
"退避抖动百分比不能超过 100".to_string(),
));
}
Ok(())
}
}
fn jittered_backoff(base_ms: u64, jitter_percent: u8, attempt: u32) -> u64 {
let jp = u64::from(jitter_percent.min(100));
if base_ms == 0 || jp == 0 {
return base_ms;
}
let span = base_ms / 100 * jp;
if span == 0 {
return base_ms;
}
let entropy = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map_or(0, |d| u64::from(d.subsec_nanos()))
^ u64::from(std::process::id())
^ u64::from(attempt);
base_ms
.saturating_sub(span)
.saturating_add(entropy % span.saturating_mul(2).saturating_add(1))
}
pub struct RequestBuilder {
client: Client,
method: Method,
url: String,
headers: HeaderMap,
header_errors: Vec<String>,
query_params: Vec<(String, String)>,
body: Option<Vec<u8>>,
timeout: Duration,
max_response_bytes: usize,
token: Option<String>,
retry: Option<RetryConfig>,
circuit_breaker: Option<crate::http::CircuitBreaker>,
}
impl RequestBuilder {
pub(crate) fn new(
client: Client,
method: Method,
url: String,
timeout: Duration,
max_response_bytes: usize,
token: Option<String>,
circuit_breaker: Option<crate::http::CircuitBreaker>,
) -> Self {
Self {
client,
method,
url,
headers: HeaderMap::new(),
header_errors: Vec::new(),
query_params: Vec::new(),
body: None,
timeout,
max_response_bytes,
token,
retry: None,
circuit_breaker,
}
}
pub fn header(mut self, name: &str, value: &str) -> Self {
let header_name = match HeaderName::from_bytes(name.as_bytes()) {
Ok(n) => n,
Err(e) => {
self.header_errors
.push(format!("非法 header 名称 '{}': {}", name, e));
return self;
}
};
let header_value = match HeaderValue::from_str(value) {
Ok(v) => v,
Err(e) => {
self.header_errors
.push(format!("非法 header 值 '{}': {}", value, e));
return self;
}
};
self.headers.insert(header_name, header_value);
self
}
pub fn headers(mut self, headers: Vec<(&str, &str)>) -> Self {
for (name, value) in headers {
let header_name = match HeaderName::from_bytes(name.as_bytes()) {
Ok(n) => n,
Err(e) => {
self.header_errors
.push(format!("非法 header 名称 '{}': {}", name, e));
continue;
}
};
let header_value = match HeaderValue::from_str(value) {
Ok(v) => v,
Err(e) => {
self.header_errors
.push(format!("非法 header 值 '{}': {}", value, e));
continue;
}
};
self.headers.insert(header_name, header_value);
}
self
}
pub fn content_type(self, content_type: &str) -> Self {
self.header("Content-Type", content_type)
}
pub fn bearer_token(mut self, token: &str) -> Self {
self.token = Some(token.to_string());
self
}
pub fn user_agent(self, user_agent: &str) -> Self {
self.header("User-Agent", user_agent)
}
pub fn query(mut self, key: &str, value: &str) -> Self {
self.query_params.push((key.to_string(), value.to_string()));
self
}
pub fn queries(mut self, params: Vec<(&str, &str)>) -> Self {
for (key, value) in params {
self.query_params.push((key.to_string(), value.to_string()));
}
self
}
pub fn json<T: Serialize>(mut self, json: &T) -> Result<Self, BaseError> {
let json_bytes =
serde_json::to_vec(json).map_err(|e| BaseError::JsonSerializeFailed(e.to_string()))?;
self.body = Some(json_bytes);
self = self.content_type("application/json");
Ok(self)
}
pub fn form(mut self, form: Vec<(&str, &str)>) -> Self {
match serde_urlencoded::to_string(&form) {
Ok(encoded) => {
self.body = Some(encoded.into_bytes());
self = self.content_type("application/x-www-form-urlencoded");
}
Err(e) => {
self.header_errors.push(format!("表单数据编码失败: {}", e));
}
}
self
}
pub fn body(mut self, body: Vec<u8>) -> Self {
self.body = Some(body);
self
}
pub fn text(mut self, text: &str) -> Self {
self.body = Some(text.as_bytes().to_vec());
self = self.content_type("text/plain");
self
}
pub fn timeout(mut self, timeout_secs: u64) -> Self {
self.timeout = Duration::from_secs(timeout_secs);
self
}
pub fn max_response_bytes(mut self, bytes: usize) -> Self {
self.max_response_bytes = bytes;
self
}
pub fn retry(mut self, config: RetryConfig) -> Self {
self.retry = Some(config);
self
}
pub async fn send(self) -> Result<Response, BaseError> {
if !self.header_errors.is_empty() {
return Err(BaseError::ParamInvalid(
"header".to_string(),
self.header_errors.join("; "),
));
}
if self
.query_params
.iter()
.any(|(key, _)| key.trim().is_empty())
{
return Err(BaseError::ParamInvalid(
"query".to_string(),
"query 参数名称不能为空".to_string(),
));
}
let parsed_url = reqwest::Url::parse(&self.url).map_err(|err| {
BaseError::ParamInvalid("url".to_string(), format!("非法 HTTP URL: {}", err))
})?;
if !matches!(parsed_url.scheme(), "http" | "https") {
return Err(BaseError::ParamInvalid(
"url".to_string(),
"HTTP 客户端仅支持 http 和 https URL".to_string(),
));
}
if let Some(token) = &self.token {
let auth_value = format!("Bearer {}", token);
if let Err(err) = HeaderValue::from_str(&auth_value) {
return Err(BaseError::ParamInvalid(
"authorization".to_string(),
format!("非法 bearer token,无法构造 Authorization 头: {}", err),
));
}
}
if self.timeout.is_zero() {
return Err(BaseError::ParamInvalid(
"http.timeout_secs".to_string(),
"HTTP 请求超时时间必须大于 0 秒".to_string(),
));
}
if self.max_response_bytes == 0 {
return Err(BaseError::ParamInvalid(
"http.max_response_bytes".to_string(),
"HTTP 响应体上限必须大于 0 字节".to_string(),
));
}
if let Some(retry) = &self.retry {
retry.validate()?;
}
let retry = self.retry.clone();
let host = self
.circuit_breaker
.as_ref()
.and_then(|_| parsed_url.host_str().map(|h| h.to_string()));
let Some(retry) = retry else {
return self.send_guarded(host.as_deref()).await;
};
if !is_idempotent_method(&self.method) && !retry.retry_non_idempotent {
return self.send_guarded(host.as_deref()).await;
}
let mut attempt: u32 = 0;
let mut remaining_budget_ms = retry.total_budget_ms;
loop {
let result = self.send_guarded(host.as_deref()).await;
let should_retry = match &result {
Ok(resp) => retry.retry_on.contains(&resp.status()),
Err(BaseError::HttpRequestFailed(_)) => true,
Err(_) => false,
};
if !should_retry || attempt >= retry.max_retries {
return result;
}
let base = retry.backoff_ms.saturating_mul(1u64 << attempt.min(20));
let sleep_ms =
jittered_backoff(base, retry.jitter_percent, attempt).min(remaining_budget_ms);
if sleep_ms == 0 {
return result;
}
tokio::time::sleep(Duration::from_millis(sleep_ms)).await;
remaining_budget_ms -= sleep_ms;
attempt += 1;
}
}
async fn send_guarded(&self, host: Option<&str>) -> Result<Response, BaseError> {
let breaker = self.circuit_breaker.as_ref();
if let (Some(breaker), Some(host)) = (breaker, host) {
if !breaker.allow(host) {
return Err(BaseError::HttpCircuitBreakerOpen(host.to_string()));
}
}
let result = self.send_once().await;
if let (Some(breaker), Some(host)) = (breaker, host) {
match &result {
Ok(resp) if resp.status() >= 500 => breaker.on_failure(host),
Ok(_) => breaker.on_success(host),
Err(_) => breaker.on_failure(host),
}
}
result
}
async fn send_once(&self) -> Result<Response, BaseError> {
let mut request = self
.client
.request(self.method.clone(), &self.url)
.timeout(self.timeout);
request = request.headers(self.headers.clone());
if let Some(token) = &self.token {
request = request.bearer_auth(token);
}
if !self.query_params.is_empty() {
request = request.query(&self.query_params);
}
if let Some(body) = &self.body {
request = request.body(body.clone());
}
let start = std::time::Instant::now();
let result = request.send().await;
let elapsed_ms = start.elapsed().as_millis();
let log_url = redact_url_for_log(&self.url);
match &result {
Ok(resp) => {
tracing::debug!(
target: "yang_base::http",
method = %self.method,
url = %log_url,
status = resp.status().as_u16(),
elapsed_ms = elapsed_ms as u64,
"HTTP 出站请求完成"
);
}
Err(e) => {
tracing::warn!(
target: "yang_base::http",
method = %self.method,
url = %log_url,
elapsed_ms = elapsed_ms as u64,
timeout = e.is_timeout(),
connect = e.is_connect(),
builder = e.is_builder(),
request = e.is_request(),
"HTTP 出站请求失败"
);
}
}
let response = result.map_err(BaseError::HttpRequestFailed)?;
Ok(Response::new(response, self.max_response_bytes))
}
}
#[cfg(test)]
mod retry_config_tests {
use super::*;
use std::sync::atomic::Ordering;
#[tokio::test]
async fn failed_request_logs_do_not_expose_url_secrets() {
let _ = rustls::crypto::ring::default_provider().install_default();
use std::io::Write;
use std::sync::{Arc, Mutex};
use tracing::instrument::WithSubscriber;
struct Writer(Arc<Mutex<Vec<u8>>>);
impl Write for Writer {
fn write(&mut self, bytes: &[u8]) -> std::io::Result<usize> {
self.0.lock().expect("日志锁").write(bytes)
}
fn flush(&mut self) -> std::io::Result<()> {
Ok(())
}
}
let buf = Arc::new(Mutex::new(Vec::new()));
let writer_buf = buf.clone();
let subscriber = tracing_subscriber::fmt()
.with_ansi(false)
.with_max_level(tracing::Level::DEBUG)
.with_writer(move || Writer(writer_buf.clone()))
.finish();
let listener = std::net::TcpListener::bind("127.0.0.1:0").expect("本地端口");
let port = listener.local_addr().expect("地址").port();
drop(listener);
let result = RequestBuilder::new(
Client::builder().no_proxy().build().expect("客户端"), Method::GET,
format!("http://user-secret:password-secret@127.0.0.1:{port}/path?token=query-secret#fragment-secret"),
Duration::from_secs(2), 1024, None, None
).query("extra", "builder-secret").send().with_subscriber(subscriber).await;
let Err(BaseError::HttpRequestFailed(error)) = result else {
panic!("应返回原始请求错误");
};
assert!(
error.is_connect() || error.is_builder() || error.is_request(),
"{error:?}"
);
if let Some(url) = error.url() {
assert!(
url.query()
.is_some_and(|query| query.contains("builder-secret")),
"{url}"
);
}
let logs = String::from_utf8(buf.lock().expect("日志锁").clone()).expect("日志 UTF8");
assert!(logs.contains("HTTP 出站请求失败"));
for secret in [
"user-secret",
"password-secret",
"query-secret",
"fragment-secret",
"builder-secret",
] {
assert!(!logs.contains(secret), "不得记录 {secret}: {logs}");
}
}
#[test]
fn test_redact_url_for_log_removes_query_and_userinfo() {
let redacted = redact_url_for_log("https://user:secret@example.com/path?token=secret&x=1");
assert_eq!(redacted, "https://***:***@example.com/path");
assert!(!redacted.contains("token"));
assert!(!redacted.contains("secret"));
assert!(!redacted.contains("user"));
}
#[test]
fn test_retry_config_validate_rejects_unsafe_values() {
let invalid_configs = [
RetryConfig {
max_retries: 11,
..RetryConfig::default()
},
RetryConfig {
max_retries: 1,
retry_on: Vec::new(),
..RetryConfig::default()
},
RetryConfig {
max_retries: 1,
backoff_ms: 0,
..RetryConfig::default()
},
RetryConfig {
max_retries: 1,
backoff_ms: 60_001,
..RetryConfig::default()
},
RetryConfig {
max_retries: 1,
retry_on: vec![99],
..RetryConfig::default()
},
RetryConfig {
max_retries: 1,
retry_on: vec![600],
..RetryConfig::default()
},
];
for config in invalid_configs {
assert!(matches!(
config.validate(),
Err(BaseError::ParamInvalid(_, _))
));
}
}
#[test]
fn test_retry_config_validate_rejects_bad_budget_and_jitter() {
let cases = [
(
"http.retry.total_budget_ms",
RetryConfig {
max_retries: 1,
total_budget_ms: 0,
..RetryConfig::default()
},
),
(
"http.retry.total_budget_ms",
RetryConfig {
max_retries: 1,
total_budget_ms: RetryConfig::MAX_TOTAL_BUDGET_MS + 1,
..RetryConfig::default()
},
),
(
"http.retry.jitter_percent",
RetryConfig {
max_retries: 1,
jitter_percent: 101,
..RetryConfig::default()
},
),
];
for (expected_field, config) in cases {
let err = match config.validate() {
Ok(()) => panic!("非法 {expected_field} 应被 validate() 拒绝"),
Err(err) => err,
};
assert!(
matches!(&err, BaseError::ParamInvalid(field, _) if field == expected_field),
"期望 ParamInvalid({expected_field}),实际 {err:?}"
);
}
}
#[test]
fn test_retry_config_default_and_boundaries_are_valid() {
assert!(
RetryConfig::default().validate().is_ok(),
"默认配置必须通过校验"
);
assert!(RetryConfig {
max_retries: 1,
total_budget_ms: RetryConfig::MAX_TOTAL_BUDGET_MS,
jitter_percent: 100,
..RetryConfig::default()
}
.validate()
.is_ok());
}
#[test]
fn test_jittered_backoff_identity_and_bounds() {
for base in [0_u64, 1, 99, 100, 1_000, u64::MAX] {
assert_eq!(
jittered_backoff(base, 0, 0),
base,
"jitter_percent=0 时退避时长不应改变"
);
}
assert_eq!(jittered_backoff(0, 100, 3), 0);
assert_eq!(jittered_backoff(50, 1, 0), 50);
let base = 1_000_u64;
let span = base / 100 * 100;
for attempt in 0..64 {
let got = jittered_backoff(base, 100, attempt);
assert!(
(base - span..=base + span).contains(&got),
"第 {attempt} 次抖动的退避 {got} 应落在 [{}, {}]",
base - span,
base + span
);
}
}
fn spawn_503_listener() -> (
std::net::SocketAddr,
std::sync::Arc<std::sync::atomic::AtomicUsize>,
) {
use std::io::{Read, Write};
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::Arc;
let listener = std::net::TcpListener::bind("127.0.0.1:0").expect("本地监听端口应可绑定");
let addr = listener.local_addr().expect("应能取得监听地址");
let counter = Arc::new(AtomicUsize::new(0));
let counter_for_thread = Arc::clone(&counter);
std::thread::spawn(move || {
for stream in listener.incoming() {
let Ok(mut stream) = stream else { break };
counter_for_thread.fetch_add(1, Ordering::SeqCst);
let mut buf = [0u8; 1024];
let _ = stream.read(&mut buf);
let _ = stream.write_all(
b"HTTP/1.1 503 Service Unavailable\r\nContent-Length: 0\r\nConnection: close\r\n\r\n",
);
let _ = stream.flush();
}
});
(addr, counter)
}
#[tokio::test]
async fn test_send_clamps_backoff_wait_to_total_budget() {
let (addr, counter) = spawn_503_listener();
let client = crate::http::HttpClient::new(30).expect("HTTP client should be valid");
let started = std::time::Instant::now();
let result = client
.get(&format!("http://{addr}/always-503"))
.retry(RetryConfig {
max_retries: 3,
retry_on: vec![503],
backoff_ms: 1_000,
jitter_percent: 0,
total_budget_ms: 5,
..RetryConfig::default()
})
.send()
.await;
let elapsed = started.elapsed();
let resp = match result {
Ok(resp) => resp,
Err(err) => panic!("预算耗尽后应返回最后一次响应而非错误: {err:?}"),
};
assert_eq!(resp.status(), 503);
assert!(
elapsed < Duration::from_millis(500),
"退避等待应被总预算钳制(未钳制需约 7s),实际耗时 {elapsed:?}"
);
tokio::time::sleep(Duration::from_millis(200)).await;
assert_eq!(
counter.load(Ordering::SeqCst),
2,
"预算耗尽后应停止重试(首次 + 1 次重试共 2 次请求)"
);
}
#[tokio::test]
async fn test_send_rejects_invalid_retry_config_before_network() {
let builder = RequestBuilder::new(
Client::new(),
Method::GET,
"http://127.0.0.1:1".to_string(),
Duration::from_secs(30),
10 * 1024 * 1024,
None,
None,
)
.retry(RetryConfig {
max_retries: 11,
..RetryConfig::default()
});
let err = match builder.send().await {
Ok(_) => panic!("无效 retry 配置应在网络请求前被拒绝"),
Err(err) => err,
};
assert!(
matches!(err, BaseError::ParamInvalid(field, _) if field == "http.retry.max_retries")
);
}
#[tokio::test]
async fn test_send_rejects_zero_request_timeout_before_network() {
let builder = RequestBuilder::new(
Client::new(),
Method::GET,
"http://127.0.0.1:1".to_string(),
Duration::from_secs(30),
10 * 1024 * 1024,
None,
None,
)
.timeout(0);
let err = match builder.send().await {
Ok(_) => panic!("0 秒请求超时应在网络请求前被拒绝"),
Err(err) => err,
};
assert!(matches!(err, BaseError::ParamInvalid(field, _) if field == "http.timeout_secs"));
}
#[tokio::test]
async fn test_send_rejects_blank_query_key_before_network() {
let client = crate::http::HttpClient::new(30).expect("HTTP client should be valid");
let result = client
.get("https://api.example.com/users")
.query(" ", "value")
.send()
.await;
let err = match result {
Err(err) => err,
Ok(_) => panic!("空白 query key 应在发送前被拒绝"),
};
assert!(matches!(
err,
crate::error::BaseError::ParamInvalid(field, _) if field == "query"
));
}
#[tokio::test]
async fn test_send_rejects_invalid_bearer_token_before_network() {
let builder = RequestBuilder::new(
Client::new(),
Method::GET,
"http://127.0.0.1:1".to_string(),
Duration::from_secs(30),
10 * 1024 * 1024,
Some("bad\r\ntoken".to_string()),
None,
);
let err = match builder.send().await {
Ok(_) => panic!("非法 bearer token 应在网络请求前被拒绝"),
Err(err) => err,
};
assert!(matches!(err, BaseError::ParamInvalid(field, _) if field == "authorization"));
}
#[tokio::test]
async fn test_send_rejects_invalid_url_before_network() {
let invalid_urls = ["not a url", "ftp://example.com/file"];
for url in invalid_urls {
let builder = RequestBuilder::new(
Client::new(),
Method::GET,
url.to_string(),
Duration::from_secs(30),
10 * 1024 * 1024,
None,
None,
);
let err = match builder.send().await {
Ok(_) => panic!("非法 URL 应在网络请求前被拒绝"),
Err(err) => err,
};
assert!(matches!(err, BaseError::ParamInvalid(field, _) if field == "url"));
}
}
#[test]
fn test_is_idempotent_method_classification() {
for method in [
Method::GET,
Method::HEAD,
Method::OPTIONS,
Method::TRACE,
Method::PUT,
Method::DELETE,
] {
assert!(
is_idempotent_method(&method),
"{method} 应被判定为幂等/安全方法"
);
}
for method in [Method::POST, Method::PATCH] {
assert!(
!is_idempotent_method(&method),
"{method} 不应被判定为幂等方法"
);
}
}
fn spawn_closing_listener() -> (
std::net::SocketAddr,
std::sync::Arc<std::sync::atomic::AtomicUsize>,
) {
use std::io::Read;
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::Arc;
let listener = std::net::TcpListener::bind("127.0.0.1:0").expect("本地监听端口应可绑定");
let addr = listener.local_addr().expect("应能取得监听地址");
let counter = Arc::new(AtomicUsize::new(0));
let counter_for_thread = Arc::clone(&counter);
std::thread::spawn(move || {
for stream in listener.incoming() {
let Ok(mut stream) = stream else { break };
counter_for_thread.fetch_add(1, Ordering::SeqCst);
let mut buf = [0u8; 1024];
let _ = stream.read(&mut buf);
}
});
(addr, counter)
}
#[tokio::test]
#[ignore = "依赖网络栈行为,发起真实连接;默认跳过"]
async fn test_post_not_retried_without_opt_in() {
let (addr, counter) = spawn_closing_listener();
let client = crate::http::HttpClient::new(1).expect("HTTP client should be valid");
let result = client
.post(&format!("http://{addr}/never"))
.retry(RetryConfig {
max_retries: 3,
retry_on: vec![503],
backoff_ms: 1,
retry_non_idempotent: false,
..RetryConfig::default()
})
.send()
.await;
assert!(result.is_err(), "监听器直接断开,应返回传输错误");
tokio::time::sleep(Duration::from_millis(200)).await;
assert_eq!(
counter.load(Ordering::SeqCst),
1,
"非幂等 POST 未 opt-in 时只应发送一次"
);
}
#[tokio::test]
#[ignore = "依赖网络栈行为,发起真实连接;默认跳过"]
async fn test_post_retried_when_opted_in() {
let (addr, counter) = spawn_closing_listener();
let client = crate::http::HttpClient::new(1).expect("HTTP client should be valid");
let result = client
.post(&format!("http://{addr}/never"))
.retry(RetryConfig {
max_retries: 3,
retry_on: vec![503],
backoff_ms: 1,
retry_non_idempotent: true,
..RetryConfig::default()
})
.send()
.await;
assert!(result.is_err(), "监听器直接断开,应返回传输错误");
tokio::time::sleep(Duration::from_millis(200)).await;
assert_eq!(
counter.load(Ordering::SeqCst),
4,
"opt-in 后应发送 1 + max_retries 次"
);
}
}