aioduct 0.2.5

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
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
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178

use super::*;

// ---- Constructor and config method tests ----

#[test]
fn with_webpki_roots_construction_and_alpn() {
    install_crypto_provider();
    let connector = RustlsConnector::with_webpki_roots();
    assert_eq!(
        connector.config().alpn_protocols,
        vec![b"h2".to_vec(), b"http/1.1".to_vec()],
        "with_webpki_roots should set default ALPN protocols"
    );
}

#[test]
fn with_webpki_roots_versioned_tls13_only() {
    install_crypto_provider();
    let connector = RustlsConnector::with_webpki_roots_versioned(&[&rustls::version::TLS13]);
    assert_eq!(
        connector.config().alpn_protocols,
        vec![b"h2".to_vec(), b"http/1.1".to_vec()],
        "versioned constructor should still set default ALPN"
    );
}

#[test]
fn with_extra_roots_empty_works_like_webpki_roots() {
    install_crypto_provider();
    let connector = RustlsConnector::with_extra_roots(&[]);
    assert_eq!(
        connector.config().alpn_protocols,
        vec![b"h2".to_vec(), b"http/1.1".to_vec()],
        "with_extra_roots with empty certs should set default ALPN"
    );
}

#[test]
fn with_extra_roots_versioned_empty_tls13_only() {
    install_crypto_provider();
    let connector = RustlsConnector::with_extra_roots_versioned(&[], &[&rustls::version::TLS13]);
    assert_eq!(
        connector.config().alpn_protocols,
        vec![b"h2".to_vec(), b"http/1.1".to_vec()],
        "versioned extra roots constructor should still set default ALPN"
    );
}

#[test]
fn config_returns_arc_reference() {
    install_crypto_provider();
    let connector = RustlsConnector::danger_accept_invalid_certs();
    let cfg = connector.config();
    // Verify it returns a reference to the Arc
    assert_eq!(Arc::strong_count(cfg), 1);
    // Clone the connector to increase the strong count
    let connector2 = connector.clone();
    assert_eq!(Arc::strong_count(connector2.config()), 2);
}

#[test]
fn config_mut_clones_on_write_when_shared() {
    install_crypto_provider();
    let connector = RustlsConnector::danger_accept_invalid_certs();
    let connector2 = connector.clone();
    // Both share the same Arc
    assert_eq!(Arc::strong_count(connector.config()), 2);

    // Drop connector2 to reduce count, then take a mutable ref on a shared arc
    let connector_a = connector.clone(); // count = 3
    let mut connector_b = connector.clone(); // count = 4
    let count_before = Arc::strong_count(connector_a.config());
    assert!(count_before > 1, "should be shared before config_mut");

    // config_mut triggers Arc::make_mut which clones because count > 1
    let _cfg_mut = connector_b.config_mut();
    // connector_b now has its own Arc, so connector_a's count decreased
    assert_eq!(
        Arc::strong_count(connector_a.config()),
        count_before - 1,
        "config_mut should clone the Arc when shared"
    );
    drop(connector2);
}

#[cfg(feature = "rustls-native-roots")]
#[test]
fn with_native_roots_construction() {
    install_crypto_provider();
    let connector = RustlsConnector::with_native_roots();
    assert_eq!(
        connector.config().alpn_protocols,
        vec![b"h2".to_vec(), b"http/1.1".to_vec()],
        "with_native_roots should set default ALPN"
    );
}

#[cfg(feature = "rustls-native-roots")]
#[test]
fn with_native_roots_versioned_tls13_only() {
    install_crypto_provider();
    let connector = RustlsConnector::with_native_roots_versioned(&[&rustls::version::TLS13]);
    assert_eq!(
        connector.config().alpn_protocols,
        vec![b"h2".to_vec(), b"http/1.1".to_vec()],
        "with_native_roots_versioned should set default ALPN"
    );
}

#[test]
fn danger_accept_invalid_certs_construction() {
    install_crypto_provider();
    let connector = RustlsConnector::danger_accept_invalid_certs();
    assert_eq!(
        connector.config().alpn_protocols,
        vec![b"h2".to_vec(), b"http/1.1".to_vec()],
    );
}

// ---- build_configured tests ----

#[test]
fn build_configured_basic_path_no_crls_no_skip() {
    install_crypto_provider();
    let root_store =
        rustls::RootCertStore::from_iter(webpki_roots::TLS_SERVER_ROOTS.iter().cloned());
    let connector = RustlsConnector::build_configured(
        root_store,
        &[&rustls::version::TLS12, &rustls::version::TLS13],
        vec![],
        false,
        None,
    )
    .expect("build_configured with empty CRLs and no skip should succeed");
    assert_eq!(
        connector.config().alpn_protocols,
        vec![b"h2".to_vec(), b"http/1.1".to_vec()],
    );
}

#[test]
fn build_configured_skip_hostname_verification() {
    install_crypto_provider();
    let root_store =
        rustls::RootCertStore::from_iter(webpki_roots::TLS_SERVER_ROOTS.iter().cloned());
    let connector = RustlsConnector::build_configured(
        root_store,
        &[&rustls::version::TLS12, &rustls::version::TLS13],
        vec![],
        true,
        None,
    )
    .expect("build_configured with skip_hostname_verification should succeed");
    assert_eq!(
        connector.config().alpn_protocols,
        vec![b"h2".to_vec(), b"http/1.1".to_vec()],
    );
}

#[test]
fn build_configured_with_identity_none() {
    install_crypto_provider();
    let root_store =
        rustls::RootCertStore::from_iter(webpki_roots::TLS_SERVER_ROOTS.iter().cloned());
    // identity=None with skip=true exercises the NoHostnameVerifier + no_client_auth path
    let connector = RustlsConnector::build_configured(
        root_store,
        &[&rustls::version::TLS13],
        vec![],
        true,
        None,
    )
    .expect("build_configured with identity=None should succeed");
    assert_eq!(
        connector.config().alpn_protocols,
        vec![b"h2".to_vec(), b"http/1.1".to_vec()],
    );
}