zenwave 0.7.0

Ergonomic HTTP client framework.
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
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

//! Integration tests for Zenwave using real HTTP requests.

mod common;
use common::httpbin_uri;
use serde_json::Value;
use zenwave::{Client, Method, client, get};

fn endpoint(path: &str) -> String {
    httpbin_uri(path)
}

#[test_executors::async_test]
async fn test_real_world_api_request() {
    // Test with a real JSON API
    let response = get(endpoint("/json")).await.unwrap();
    assert!(response.status().is_success());

    let json: Value = response.into_body().into_json().await.unwrap();
    assert!(json.is_object());
}

#[test_executors::async_test]
async fn test_user_agent_header() {
    let response = get(endpoint("/user-agent")).await.unwrap();
    let text = response.into_body().into_string().await.unwrap();

    // Should contain some user agent info
    assert!(!text.is_empty());
}

#[test_executors::async_test]
async fn test_custom_headers() {
    let mut client = client();
    let response = client.get(endpoint("/headers")).unwrap().await.unwrap();
    let text = response.into_body().into_string().await.unwrap();

    // Should contain header information
    assert!(text.contains("headers"));
}

#[test_executors::async_test]
async fn test_post_with_json_body() {
    let mut client = client();
    let request = client.method(Method::POST, endpoint("/post")).unwrap();
    // Note: In a real implementation, you'd want to add a body() method to RequestBuilder
    let response = request.await;

    assert!(response.is_ok());
    let response = response.unwrap();
    assert!(response.status().is_success());
}

#[test_executors::async_test]
async fn test_response_status_codes() {
    for status_code in [200, 201, 400, 401, 403, 404, 500, 502, 503] {
        let url = endpoint(&format!("/status/{status_code}"));
        let response = get(url).await;
        if status_code < 400 {
            let response = response.unwrap();
            assert_eq!(response.status().as_u16(), status_code);
        } else {
            let error = response.expect_err("expected error status to surface as Err");
            let description = format!("{error}");
            assert!(
                description.contains(&status_code.to_string()),
                "error message should mention status code {status_code}: {description}"
            );
        }
    }
}

#[test_executors::async_test]
async fn test_redirect_chain() {
    let mut client = client();

    // Test a redirect chain
    let response = client.get(endpoint("/redirect/5")).unwrap().await.unwrap();
    assert!(response.status().is_success());
}

#[test_executors::async_test]
async fn test_large_response() {
    // Test handling of larger responses
    let response = get(endpoint("/base64/aGVsbG8gd29ybGQ=")).await;
    assert!(response.is_ok());
    let response = response.unwrap();
    let body = response.into_body().into_bytes().await;
    assert!(body.is_ok());
    let bytes = body.unwrap();
    assert!(!bytes.is_empty());
}

#[test_executors::async_test]
async fn test_gzip_compression() {
    // Local test server advertises gzip support
    let response = get(endpoint("/gzip")).await;
    assert!(response.is_ok());
    let response = response.unwrap();
    let bytes = response.into_body().into_bytes().await.unwrap();
    // Should get some response data (gzipped content is handled by the HTTP client)
    assert!(!bytes.is_empty());
}

#[test_executors::async_test]
async fn test_cookie_persistence() {
    let mut client = client().enable_cookie();

    // Set a cookie
    let _response = client
        .get(endpoint("/cookies/set/test/cookievalue"))
        .unwrap()
        .await
        .unwrap();

    // Verify cookie is sent in subsequent request
    let response = client.get(endpoint("/cookies")).unwrap().await.unwrap();
    let body = response.into_body().into_string().await.unwrap();
    assert!(body.contains("test"));
    assert!(body.contains("cookievalue"));
}

#[test_executors::async_test]
async fn test_method_overrides() {
    let mut client = client();

    // Test different HTTP methods
    let methods = [
        (Method::GET, "/get"),
        (Method::POST, "/post"),
        (Method::PUT, "/put"),
        (Method::DELETE, "/delete"),
        (Method::PATCH, "/patch"),
    ];

    for (method, url) in methods {
        let method_clone = method.clone();
        let response = client.method(method, endpoint(url)).unwrap().await;
        assert!(response.is_ok(), "Failed for method: {method_clone:?}");
        let response = response.unwrap();
        assert!(
            response.status().is_success(),
            "Failed for method: {method_clone:?}"
        );
    }
}