cyper 0.8.3

HTTP client library based on compio and hyper
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

use std::sync::Once;

use nyquest::{ClientBuilder, Request};

mod server;

static REGISTER: Once = Once::new();

fn register() {
    REGISTER.call_once(|| {
        cyper::nyquest::register();
    })
}

#[test]
fn register_backend() {
    register();
    register(); // should not panic
}

fn builder() -> ClientBuilder {
    register();
    ClientBuilder::default().no_proxy().no_redirects()
}

#[cfg(feature = "nyquest-async")]
#[compio::test]
async fn response_text_async() {
    let server = server::http(move |_req| async { "Hello" }).await;

    let client = builder().build_async().await.unwrap();

    let text = client
        .request(Request::get(format!("http://{}/text", server.addr())))
        .await
        .unwrap()
        .text()
        .await
        .unwrap();
    assert_eq!("Hello", text);
}

#[cfg(feature = "nyquest-blocking")]
#[compio::test]
async fn response_text_blocking() {
    use futures_channel::oneshot;

    let server = server::http(move |_req| async { "Hello" }).await;

    let (tx, rx) = oneshot::channel();

    let handle = std::thread::spawn(move || {
        let client = builder().build_blocking().unwrap();

        let text = client
            .request(Request::get(format!("http://{}/text", server.addr())))
            .unwrap()
            .text()
            .unwrap();
        assert_eq!("Hello", text);
        tx.send(()).unwrap();
    });

    rx.await.unwrap();

    if let Err(e) = handle.join() {
        std::panic::resume_unwind(e)
    }
}

#[cfg(all(feature = "nyquest-multipart", feature = "nyquest-async"))]
#[compio::test]
async fn multipart_form() {
    use http_body_util::BodyExt;

    let form = nyquest::r#async::Body::multipart([nyquest::Part::new_with_content_type(
        "text",
        "text/plain",
        nyquest::PartBody::text("ttt"),
    )]);

    let server = server::http(move |mut req: http::Request<axum::body::Body>| async move {
        assert_eq!(req.method(), "POST");

        let mut full: Vec<u8> = Vec::new();
        while let Some(item) = req.body_mut().frame().await {
            full.extend(&*item.unwrap().into_data().unwrap());
        }

        full
    })
    .await;

    let url = format!("http://{}/multipart/1", server.addr());

    let client = builder().build_async().await.unwrap();

    let res = client
        .request(Request::post(url).with_body(form))
        .await
        .unwrap();

    let text = res.text().await.unwrap();
    assert!(text.contains(
        "Content-Disposition: form-data; name=\"text\"\r\ncontent-type: text/plain\r\n\r\nttt\r\n"
    ));
}