nexus-async-net 0.5.0

Async WebSocket adapter for nexus-net. Tokio-compatible, zero-copy, SIMD-accelerated.
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

//! Async HTTP/1.1 REST client integration tests against httpbin.org.
//!
//! Mirrors nexus-net's httpbin tests but uses AsyncHttpConnection.
//! Proves the async adapter produces identical results to sync.
//!
//! Run with:
//!   cargo test -p nexus-async-net --test httpbin -- --ignored --nocapture

use nexus_async_net::rest::AsyncHttpConnection;
use nexus_net::http::ResponseReader;
use nexus_net::rest::RequestWriter;
use nexus_net::tls::TlsConfig;

async fn setup() -> (
    RequestWriter,
    ResponseReader,
    AsyncHttpConnection<nexus_async_net::rest::MaybeTls>,
) {
    let tls = TlsConfig::new().unwrap();
    let mut writer = RequestWriter::new("httpbin.org").unwrap();
    let _ = writer.default_header("Accept", "application/json");
    let reader = ResponseReader::new(64 * 1024).max_body_size(64 * 1024);
    let conn = nexus_async_net::rest::AsyncHttpConnectionBuilder::new()
        .tls(&tls)
        .disable_nagle()
        .connect("https://httpbin.org")
        .await
        .unwrap();
    (writer, reader, conn)
}

#[tokio::test]
#[ignore = "requires network access to httpbin.org"]
async fn async_httpbin_get() {
    let (mut writer, mut reader, mut conn) = setup().await;

    let req = writer.get("/get").finish().unwrap();
    let resp = conn.send(req, &mut reader).await.unwrap();

    assert_eq!(resp.status(), 200);
    let body = resp.body_str().unwrap();
    assert!(body.contains("\"url\""));
    assert!(body.contains("httpbin.org/get"));
}

#[tokio::test]
#[ignore = "requires network access to httpbin.org"]
async fn async_httpbin_get_with_query() {
    let (mut writer, mut reader, mut conn) = setup().await;

    let req = writer
        .get("/get")
        .query("symbol", "ETH-USD")
        .query("limit", "50")
        .finish()
        .unwrap();
    let resp = conn.send(req, &mut reader).await.unwrap();

    assert_eq!(resp.status(), 200);
    let body = resp.body_str().unwrap();
    assert!(body.contains("ETH-USD"));
    assert!(body.contains("50"));
}

#[tokio::test]
#[ignore = "requires network access to httpbin.org"]
async fn async_httpbin_post_json() {
    let (mut writer, mut reader, mut conn) = setup().await;

    let json = r#"{"action":"place_order"}"#;
    let req = writer
        .post("/post")
        .header("Content-Type", "application/json")
        .body(json.as_bytes())
        .finish()
        .unwrap();
    let resp = conn.send(req, &mut reader).await.unwrap();

    assert_eq!(resp.status(), 200);
    assert!(resp.body_str().unwrap().contains("place_order"));
}

#[tokio::test]
#[ignore = "requires network access to httpbin.org"]
async fn async_httpbin_keep_alive() {
    let (mut writer, mut reader, mut conn) = setup().await;

    // Three sequential requests on the same connection
    for i in 1..=3 {
        let req = writer
            .get("/get")
            .query("req", &i.to_string())
            .finish()
            .unwrap();
        let resp = conn.send(req, &mut reader).await.unwrap();
        assert_eq!(resp.status(), 200);
        drop(resp);
    }
}

#[tokio::test]
#[ignore = "requires network access to httpbin.org"]
async fn async_httpbin_status_codes() {
    let (mut writer, mut reader, mut conn) = setup().await;

    for (path, expected) in [
        ("/status/200", 200),
        ("/status/404", 404),
        ("/status/204", 204),
    ] {
        let req = writer.get(path).finish().unwrap();
        let resp = conn.send(req, &mut reader).await.unwrap();
        assert_eq!(resp.status(), expected, "failed for {path}");
        drop(resp);
    }
}

#[tokio::test]
#[ignore = "requires network access to httpbin.org"]
async fn async_httpbin_response_headers() {
    let (mut writer, mut reader, mut conn) = setup().await;

    let req = writer
        .get("/response-headers")
        .query("X-Async-Test", "works")
        .finish()
        .unwrap();
    let resp = conn.send(req, &mut reader).await.unwrap();

    assert_eq!(resp.status(), 200);
    assert_eq!(resp.header("X-Async-Test"), Some("works"));
}

#[tokio::test]
#[ignore = "requires network access to httpbin.org"]
async fn async_httpbin_large_response() {
    let (mut writer, _, mut conn) = setup().await;
    let mut reader = ResponseReader::new(64 * 1024).max_body_size(64 * 1024);

    let req = writer.get("/bytes/8192").finish().unwrap();
    let resp = conn.send(req, &mut reader).await.unwrap();

    assert_eq!(resp.status(), 200);
    assert_eq!(resp.body().len(), 8192);
}