zenwave 0.4.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
146
147
148

//! Tests for backend implementations

#[cfg(any(feature = "hyper-backend", feature = "curl-backend"))]
use http_kit::{Endpoint, Method};
#[cfg(feature = "hyper-backend")]
use zenwave::backend::HyperBackend;

#[cfg(any(feature = "hyper-backend", feature = "curl-backend"))]
mod common;
#[cfg(any(feature = "hyper-backend", feature = "curl-backend"))]
use common::httpbin_uri;

#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
#[cfg_attr(not(target_arch = "wasm32"), test)]
#[cfg(feature = "hyper-backend")]
fn test_hyper_backend_creation() {
    let backend = HyperBackend::new();
    // Just ensure it can be created
    assert!(!format!("{backend:?}").is_empty());
}

#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
#[cfg_attr(not(target_arch = "wasm32"), test)]
#[cfg(feature = "hyper-backend")]
fn test_hyper_backend_default() {
    let backend = HyperBackend::default();
    assert!(!format!("{backend:?}").is_empty());
}

#[test_executors::async_test]
#[cfg(feature = "hyper-backend")]
async fn test_hyper_backend_get_request() {
    let mut backend = HyperBackend::new();
    let mut request = http::Request::builder()
        .method(Method::GET)
        .uri(httpbin_uri("/get"))
        .body(http_kit::Body::empty())
        .unwrap();
    let response = backend.respond(&mut request).await;
    assert!(response.is_ok());
    let response = response.unwrap();
    assert!(response.status().is_success());
}

#[test_executors::async_test]
#[cfg(feature = "hyper-backend")]
async fn test_hyper_backend_post_request() {
    let mut backend = HyperBackend::new();
    let mut request = http::Request::builder()
        .method(Method::POST)
        .uri(httpbin_uri("/post"))
        .body(http_kit::Body::empty())
        .unwrap();
    let response = backend.respond(&mut request).await;
    assert!(response.is_ok());
    let response = response.unwrap();
    assert!(response.status().is_success());
}

#[test_executors::async_test]
#[cfg(feature = "hyper-backend")]
async fn test_hyper_backend_https_request() {
    let mut backend = HyperBackend::new();
    let mut request = http::Request::builder()
        .method(Method::GET)
        .uri(httpbin_uri("/get"))
        .body(http_kit::Body::empty())
        .unwrap();
    let response = backend.respond(&mut request).await;
    assert!(response.is_ok());
    let response = response.unwrap();
    assert!(response.status().is_success());
}

#[test_executors::async_test]
#[cfg(feature = "hyper-backend")]
async fn test_hyper_backend_invalid_uri() {
    let mut backend = HyperBackend::new();
    let mut request = http::Request::builder()
        .method(Method::GET)
        .uri("invalid-uri")
        .body(http_kit::Body::empty())
        .unwrap();
    let response = backend.respond(&mut request).await;
    assert!(response.is_err());
}

#[test_executors::async_test]
#[cfg(feature = "hyper-backend")]
async fn test_hyper_backend_http_error_returns_err() {
    let mut backend = HyperBackend::new();
    let mut request = http::Request::builder()
        .method(Method::GET)
        .uri(httpbin_uri("/status/404"))
        .body(http_kit::Body::empty())
        .unwrap();

    let response = backend.respond(&mut request).await;
    assert!(
        response.is_err(),
        "expected non-success status to surface as Err"
    );
}

#[test_executors::async_test]
#[cfg(all(not(target_arch = "wasm32"), feature = "curl-backend"))]
async fn test_curl_backend_http_error_returns_err() {
    use zenwave::backend::CurlBackend;

    let mut backend = CurlBackend::new();
    let mut request = http::Request::builder()
        .method(Method::GET)
        .uri(httpbin_uri("/status/500"))
        .body(http_kit::Body::empty())
        .unwrap();

    let response = backend.respond(&mut request).await;
    assert!(
        response.is_err(),
        "expected non-success status to surface as Err"
    );
}

#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
#[cfg_attr(not(target_arch = "wasm32"), test)]
#[cfg(feature = "hyper-backend")]
#[cfg(not(target_arch = "wasm32"))]
fn test_hyper_backend_request_cancellation() {}

// Note: WebBackend tests are more challenging to write without a browser environment
// These would typically require wasm-pack test or a specialized test runner
#[cfg(target_arch = "wasm32")]
mod web_backend_tests {
    use super::*;
    use zenwave::backend::WebBackend;

    #[test_executors::async_test]
    async fn test_web_backend_creation() {
        let backend = WebBackend::new();
        // Basic creation test - we can't test much without a browser context
    }

    #[test_executors::async_test]
    async fn test_web_backend_default() {
        let backend = WebBackend::default();
        // Basic default test
    }
}