oxihttp 0.1.0

OxiHTTP Pure-Rust HTTP facade for the COOLJAPAN ecosystem.
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

//! Integration tests for M7 Block B/C: DNS resolver injection, HTTP/2 tuning, TCP knobs.

use oxihttp_client::{ClientBuilder, Http2Settings};
use oxihttp_server::{Router, Server, ServerHttp2Settings};
use std::time::Duration;

#[tokio::test]
async fn test_client_with_http2_settings() {
    // Build a client with H2 settings — verify no error on construction
    let _client = ClientBuilder::new()
        .with_http2_settings(Http2Settings {
            initial_stream_window_size: Some(1024 * 1024),
            adaptive_window: Some(true),
            ..Default::default()
        })
        .build()
        .expect("build with http2 settings");
    // If we get here without panic, settings were accepted
}

#[tokio::test]
async fn test_client_with_tcp_settings() {
    let _client = ClientBuilder::new()
        .with_tcp_nodelay(true)
        .with_tcp_keepalive(Duration::from_secs(30))
        .build()
        .expect("build with tcp settings");
}

#[tokio::test]
async fn test_client_with_all_h2_settings() {
    let _client = ClientBuilder::new()
        .with_http2_settings(Http2Settings {
            initial_stream_window_size: Some(512 * 1024),
            initial_connection_window_size: Some(2 * 1024 * 1024),
            adaptive_window: Some(false),
            keep_alive_interval: Some(Duration::from_secs(10)),
            keep_alive_timeout: Some(Duration::from_secs(5)),
            max_frame_size: Some(16_384),
            max_concurrent_reset_streams: Some(10),
            max_send_buf_size: Some(1024 * 1024),
        })
        .build()
        .expect("build with all h2 settings");
}

#[tokio::test]
async fn test_server_with_tcp_nodelay() {
    async fn handler(
        _req: oxihttp_server::Request,
    ) -> Result<hyper::Response<http_body_util::Full<bytes::Bytes>>, oxihttp_core::OxiHttpError>
    {
        Ok(hyper::Response::new(http_body_util::Full::new(
            bytes::Bytes::from("ok"),
        )))
    }

    let router = Router::new().get("/", handler);
    let (tx, rx) = tokio::sync::oneshot::channel::<()>();

    let (addr, _handle) = Server::bind("127.0.0.1:0")
        .with_tcp_nodelay(true)
        .with_http2_settings(ServerHttp2Settings {
            max_concurrent_streams: Some(100),
            ..Default::default()
        })
        .with_graceful_shutdown(async move {
            let _ = rx.await;
        })
        .serve_with_addr(router)
        .await
        .expect("bind");

    // Give the server a moment to start.
    tokio::time::sleep(Duration::from_millis(10)).await;

    let client = ClientBuilder::new().build().expect("client");
    let resp = client
        .get(&format!("http://{addr}/"))
        .expect("GET")
        .send()
        .await
        .expect("send");
    assert_eq!(resp.status(), http::StatusCode::OK);

    let _ = tx.send(());
}

#[tokio::test]
async fn test_server_with_tcp_keepalive() {
    async fn handler(
        _req: oxihttp_server::Request,
    ) -> Result<hyper::Response<http_body_util::Full<bytes::Bytes>>, oxihttp_core::OxiHttpError>
    {
        Ok(hyper::Response::new(http_body_util::Full::new(
            bytes::Bytes::from("keepalive ok"),
        )))
    }

    let router = Router::new().get("/ping", handler);
    let (tx, rx) = tokio::sync::oneshot::channel::<()>();

    let (addr, _handle) = Server::bind("127.0.0.1:0")
        .with_tcp_nodelay(true)
        .with_tcp_keepalive(Duration::from_secs(60))
        .with_graceful_shutdown(async move {
            let _ = rx.await;
        })
        .serve_with_addr(router)
        .await
        .expect("bind");

    tokio::time::sleep(Duration::from_millis(10)).await;

    let client = ClientBuilder::new().build().expect("client");
    let resp = client
        .get(&format!("http://{addr}/ping"))
        .expect("GET")
        .send()
        .await
        .expect("send");
    assert_eq!(resp.status(), http::StatusCode::OK);
    let body = resp.body_text().await.expect("body");
    assert_eq!(body, "keepalive ok");

    let _ = tx.send(());
}

#[tokio::test]
async fn test_resolver_build_with_resolver_no_resolver_error() {
    // Calling build_with_resolver without with_resolver should return Dns error
    let result = ClientBuilder::new().build_with_resolver();
    assert!(result.is_err());
    let err = result.expect_err("should fail");
    assert!(matches!(err, oxihttp_core::OxiHttpError::Dns(_)));
}