reqres 1.0.0

A pure Rust async HTTP client library based on Tokio with HTTP/2, connection pooling, proxy, cookie, compression, benchmarks, and comprehensive tests
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

use reqres::Client;
use serde::{Deserialize, Serialize};

#[derive(Debug, Serialize)]
struct CreateUserRequest {
    name: String,
    job: String,
}

#[derive(Debug, Deserialize)]
struct CreateUserResponse {
    name: String,
    job: String,
    id: String,
    created_at: String,
}

#[derive(Debug, Deserialize)]
struct HttpBinResponse {
    url: String,
    origin: String,
    headers: std::collections::HashMap<String, String>,
    #[serde(default)]
    json: Option<serde_json::Value>,
    #[serde(default)]
    data: String,
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== reqres v0.4.0 JSON Client Demo ===\n");

    let client = Client::new()?;

    // JSON POST 请求示例
    println!("Sending JSON POST request...");
    let user = CreateUserRequest {
        name: "John Doe".to_string(),
        job: "Software Engineer".to_string(),
    };

    match client.post_json("https://httpbin.org/post", &user).await {
        Ok(response) => {
            println!("✓ JSON POST request successful!");
            println!("  Status: {}", response.status());
            
            // 解析 JSON 响应
            match response.json::<HttpBinResponse>() {
                Ok(data) => {
                    println!("  Parsed Response:");
                    println!("    URL: {}", data.url);
                    println!("    Origin: {}", data.origin);
                    if let Some(json) = data.json {
                        println!("    JSON Body: {}", serde_json::to_string_pretty(&json)?);
                    }
                }
                Err(e) => {
                    eprintln!("  Failed to parse JSON: {}", e);
                }
            }
        }
        Err(e) => {
            eprintln!("✗ JSON POST request failed: {}", e);
        }
    }

    println!("\n{}\n", &"=".repeat(50));

    // 使用 RequestBuilder 发送 JSON
    println!("Sending JSON using RequestBuilder...");
    let json_body = serde_json::json!({
        "title": "reqres v0.2.0",
        "features": ["HTTPS", "JSON", "Redirects"],
        "awesome": true
    });

    let request = reqres::Request::post("https://httpbin.org/post")
        .json(&json_body)?
        .header("X-Custom-Header", "reqres-demo")
        .build()?;

    match client.request(request).await {
        Ok(response) => {
            println!("✓ RequestBuilder JSON POST successful!");
            println!("  Status: {}", response.status());
            
            if let Ok(text) = response.text() {
                let preview = if text.len() > 300 {
                    &text[..300]
                } else {
                    &text
                };
                println!("  Body preview:\n{}", preview);
            }
        }
        Err(e) => {
            eprintln!("✗ RequestBuilder request failed: {}", e);
        }
    }

    println!("\n=== Demo completed ===");
    Ok(())
}