yang-base 0.2.2

个人使用构建后端服务器
Documentation
//! HTTP 客户端集成测试
//!
//! 测试 HttpClient 的完整功能流程

use crate::http::HttpClient;

#[tokio::test]
async fn test_http_client_full_workflow() {
    // 创建客户端
    let client = HttpClient::new(30).unwrap();

    // 设置默认 Token
    client.set_default_token("test_token_123".to_string());

    // 测试 GET 请求构建
    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);

    // 测试 POST 请求构建
    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);

    // 测试 PUT 请求
    let put_builder = client.put("https://httpbin.org/put").text("Hello, World!");

    drop(put_builder);

    // 测试 DELETE 请求
    let delete_builder = client.delete("https://httpbin.org/delete");

    drop(delete_builder);

    // 测试 PATCH 请求
    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() {
    // 经 Tools 资源槽获取客户端(替代原全局单例用法)
    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();

    // 测试 JSON content type
    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());

    // 测试 form content type
    let form_builder = client
        .post("https://api.example.com/form")
        .form(vec![("key", "value")]);
    drop(form_builder);

    // 测试 text content type
    let text_builder = client
        .post("https://api.example.com/text")
        .text("plain text");
    drop(text_builder);

    // 测试自定义 content type
    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();

    // 测试 Bearer Token
    let bearer_builder = client
        .get("https://api.example.com/protected")
        .bearer_token("my_access_token");
    drop(bearer_builder);

    // 测试自定义 Authorization header
    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);

    // 测试默认超时(30秒)
    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);
}

// ──────────────────────────────────────────────────────────────────────────────
// 重试策略(L-4)
// ──────────────────────────────────────────────────────────────────────────────

#[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]);
}

#[test]
fn test_request_builder_with_retry() {
    let client = HttpClient::new(30).unwrap();
    // .retry() 是链式 setter,应能与其他链式方法组合
    let builder = client
        .get("https://api.example.com/data")
        .retry(crate::http::RetryConfig {
            max_retries: 5,
            retry_on: vec![500, 503],
            backoff_ms: 10,
        })
        .header("X-Test", "1");
    drop(builder);
}

/// 验证传输错误(连接失败)会触发重试并最终返回 Err,且不 panic。
/// 标记 ignore:发起真实连接,依赖网络栈行为,默认跳过。
#[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![],
            backoff_ms: 1,
        })
        .send()
        .await;
    assert!(result.is_err(), "连接失败重试耗尽后应返回 Err");
}