aioduct 0.2.2

Async-native HTTP client built directly on hyper 1.x — no hyper-util, no legacy
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

use std::convert::Infallible;
use std::time::Duration;

use aioduct::HttpEngineSend;
use aioduct::runtime::TokioRuntime;
use aioduct::runtime::tokio_rt::TcpConnector;
use aioduct_test_server::h1::spawn_h1_server_with;
use bytes::Bytes;
use http_body_util::Full;
use hyper::Response;

// ═══════════════════════════════════════════════════════════════════════════
// 1. https_only_blocks_http_redirect_target
//    Client with https_only(true) must reject HTTP requests, including
//    redirect targets that resolve to HTTP.
// ═══════════════════════════════════════════════════════════════════════════

#[cfg(feature = "tokio")]
#[tokio::test]
async fn https_only_blocks_http_redirect_target_tokio() {
    let _addr = spawn_h1_server_with(|_req| async move {
        Ok::<_, Infallible>(Response::new(Full::new(Bytes::from("ok"))))
    });

    let client = HttpEngineSend::<TokioRuntime, TcpConnector>::builder()
        .https_only(true)
        .timeout(Duration::from_secs(5))
        .build()
        .unwrap();

    let result = client
        .get(&format!("http://{_addr}/"))
        .unwrap()
        .send()
        .await;
    assert!(result.is_err(), "https_only should block HTTP requests");
    let err_str = format!("{}", result.unwrap_err());
    assert!(
        err_str.to_lowercase().contains("https"),
        "error should mention HTTPS requirement, got: {err_str}"
    );
}

#[cfg(feature = "smol")]
#[test]
fn https_only_blocks_http_redirect_target_smol() {
    smol::block_on(async {
        let _addr = spawn_h1_server_with(|_req| async move {
            Ok::<_, Infallible>(Response::new(Full::new(Bytes::from("ok"))))
        });

        let client = HttpEngineSend::<
            aioduct::runtime::smol_rt::SmolRuntime,
            aioduct::runtime::smol_rt::TcpConnector,
        >::builder()
        .https_only(true)
        .timeout(Duration::from_secs(5))
        .build()
        .unwrap();

        let result = client
            .get(&format!("http://{_addr}/"))
            .unwrap()
            .send()
            .await;
        assert!(result.is_err(), "https_only should block HTTP requests");
        let err_str = format!("{}", result.unwrap_err());
        assert!(
            err_str.to_lowercase().contains("https"),
            "error should mention HTTPS requirement, got: {err_str}"
        );
    });
}

#[cfg(feature = "compio")]
#[test]
fn https_only_blocks_http_redirect_target_compio() {
    compio_runtime::Runtime::new().unwrap().block_on(async {
        let _addr = spawn_h1_server_with(|_req| async move {
            Ok::<_, Infallible>(Response::new(Full::new(Bytes::from("ok"))))
        });

        let client: aioduct::HttpEngineLocal<
            aioduct::runtime::compio_rt::CompioRuntime,
            aioduct::runtime::compio_rt::TcpConnector,
        > = aioduct::HttpEngineLocal::builder()
            .https_only(true)
            .timeout(Duration::from_secs(5))
            .build_local()
            .unwrap();

        let result = client
            .get_local(&format!("http://{_addr}/"))
            .unwrap()
            .send()
            .await;
        assert!(result.is_err(), "https_only should block HTTP requests");
        let err_str = format!("{}", result.unwrap_err());
        assert!(
            err_str.to_lowercase().contains("https"),
            "error should mention HTTPS requirement, got: {err_str}"
        );
    });
}