product-os-request 0.0.55

Product OS : Request provides a fully featured HTTP request library combining elements of reqwest and hyper for async requests with a series of helper methods to allow for easier usage depending upon your needs for one-time or repeat usage.
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

//! Tests for optional hyper features (timeout, cookies, compression)

#[cfg(all(feature = "std_hyper", feature = "hyper_timeout", feature = "json"))]
#[tokio::test]
async fn test_hyper_timeout() {
    use product_os_request::{Method, ProductOSClient, ProductOSHyperClient, ProductOSRequester};

    let mut requester = ProductOSRequester::new();
    // Set very short timeout (will likely timeout on slow connections)
    requester.set_timeout(1); // 1ms - very likely to timeout

    let mut client = ProductOSHyperClient::new();
    requester.build(&mut client);

    let request = client.new_request(Method::GET, "https://httpbin.org/delay/5");
    let response = client.request(request).await;

    // Should timeout
    assert!(response.is_err(), "Request should timeout");
    if let Err(e) = response {
        let error_msg = e.to_string();
        assert!(
            error_msg.contains("timeout") || error_msg.contains("timed out"),
            "Error should mention timeout: {}",
            error_msg
        );
    }
}

#[cfg(all(feature = "std_hyper", feature = "hyper_timeout", feature = "json"))]
#[tokio::test]
async fn test_hyper_no_timeout() {
    use product_os_request::{Method, ProductOSClient, ProductOSHyperClient, ProductOSRequester};

    let mut requester = ProductOSRequester::new();
    requester.set_timeout(5000); // 5 second timeout

    let mut client = ProductOSHyperClient::new();
    requester.build(&mut client);

    let request = client.new_request(Method::GET, "https://httpbin.org/get");
    let response = client.request(request).await;

    // Should succeed
    assert!(response.is_ok(), "Request should not timeout");
}

#[cfg(all(feature = "std_hyper", feature = "hyper_cookies", feature = "json"))]
#[tokio::test]
async fn test_hyper_cookies() {
    use product_os_request::{Method, ProductOSClient, ProductOSHyperClient, ProductOSRequester};

    let mut requester = ProductOSRequester::new();
    requester.set_timeout(5000);

    let mut client = ProductOSHyperClient::new();
    requester.build(&mut client);

    // Test that cookie feature is enabled and compiles
    // Full cookie functionality testing would require a test server that returns Set-Cookie headers
    let request = client.new_request(Method::GET, "https://httpbin.org/get");
    let response = client.request(request).await;

    assert!(
        response.is_ok(),
        "Request should succeed with cookie feature enabled"
    );
}

#[cfg(all(feature = "std_hyper", feature = "hyper_compression", feature = "json"))]
#[tokio::test]
async fn test_hyper_compression_headers() {
    use product_os_request::{Method, ProductOSClient, ProductOSHyperClient, ProductOSRequester};

    let mut requester = ProductOSRequester::new();
    requester.set_timeout(5000);

    let mut client = ProductOSHyperClient::new();
    requester.build(&mut client);

    // Test that compression feature is enabled and Accept-Encoding header is sent
    // Full compression/decompression would require more complex body handling
    let request = client.new_request(Method::GET, "https://httpbin.org/get");
    let response = client.request(request).await;

    assert!(
        response.is_ok(),
        "Request should succeed with compression feature enabled"
    );
    let response = response.unwrap();
    assert_eq!(response.status_code(), 200, "Status code should be 200");
}

#[cfg(all(feature = "std_hyper_full", feature = "json"))]
#[tokio::test]
async fn test_hyper_all_features() {
    use product_os_request::{
        Method, ProductOSClient, ProductOSHyperClient, ProductOSRequester, RedirectPolicy,
    };

    let mut requester = ProductOSRequester::new();
    requester.set_timeout(5000);
    requester.set_redirect_policy(RedirectPolicy::Limit(10));
    requester.add_header("X-Test-Header", "test-value", false);

    let mut client = ProductOSHyperClient::new();
    requester.build(&mut client);

    // Test with cookies, compression, timeout, and redirects all together
    let request = client.new_request(
        Method::GET,
        "https://httpbin.org/redirect-to?url=https://httpbin.org/cookies/set?fulltest=working",
    );
    let response = client.request(request).await;

    assert!(response.is_ok(), "Request with all features should succeed");
    let response = response.unwrap();
    assert_eq!(
        response.status_code(),
        200,
        "Should successfully follow redirect"
    );
}