1 #![cfg(not(target_arch = "wasm32"))]
2 mod support;
3 use futures_util::stream::StreamExt;
4 use support::*;
5
6 use reqwest::Client;
7
8 #[tokio::test]
auto_headers()9 async fn auto_headers() {
10 let server = server::http(move |req| async move {
11 assert_eq!(req.method(), "GET");
12
13 assert_eq!(req.headers()["accept"], "*/*");
14 assert_eq!(req.headers().get("user-agent"), None);
15 if cfg!(feature = "gzip") {
16 assert!(req.headers()["accept-encoding"]
17 .to_str()
18 .unwrap()
19 .contains("gzip"));
20 }
21 if cfg!(feature = "brotli") {
22 assert!(req.headers()["accept-encoding"]
23 .to_str()
24 .unwrap()
25 .contains("br"));
26 }
27 if cfg!(feature = "deflate") {
28 assert!(req.headers()["accept-encoding"]
29 .to_str()
30 .unwrap()
31 .contains("deflate"));
32 }
33
34 http::Response::default()
35 });
36
37 let url = format!("http://{}/1", server.addr());
38 let res = reqwest::Client::builder()
39 .no_proxy()
40 .build()
41 .unwrap()
42 .get(&url)
43 .send()
44 .await
45 .unwrap();
46
47 assert_eq!(res.url().as_str(), &url);
48 assert_eq!(res.status(), reqwest::StatusCode::OK);
49 assert_eq!(res.remote_addr(), Some(server.addr()));
50 }
51
52 #[tokio::test]
user_agent()53 async fn user_agent() {
54 let server = server::http(move |req| async move {
55 assert_eq!(req.headers()["user-agent"], "reqwest-test-agent");
56 http::Response::default()
57 });
58
59 let url = format!("http://{}/ua", server.addr());
60 let res = reqwest::Client::builder()
61 .user_agent("reqwest-test-agent")
62 .build()
63 .expect("client builder")
64 .get(&url)
65 .send()
66 .await
67 .expect("request");
68
69 assert_eq!(res.status(), reqwest::StatusCode::OK);
70 }
71
72 #[tokio::test]
response_text()73 async fn response_text() {
74 let _ = env_logger::try_init();
75
76 let server = server::http(move |_req| async { http::Response::new("Hello".into()) });
77
78 let client = Client::new();
79
80 let res = client
81 .get(&format!("http://{}/text", server.addr()))
82 .send()
83 .await
84 .expect("Failed to get");
85 assert_eq!(res.content_length(), Some(5));
86 let text = res.text().await.expect("Failed to get text");
87 assert_eq!("Hello", text);
88 }
89
90 #[tokio::test]
response_bytes()91 async fn response_bytes() {
92 let _ = env_logger::try_init();
93
94 let server = server::http(move |_req| async { http::Response::new("Hello".into()) });
95
96 let client = Client::new();
97
98 let res = client
99 .get(&format!("http://{}/bytes", server.addr()))
100 .send()
101 .await
102 .expect("Failed to get");
103 assert_eq!(res.content_length(), Some(5));
104 let bytes = res.bytes().await.expect("res.bytes()");
105 assert_eq!("Hello", bytes);
106 }
107
108 #[tokio::test]
109 #[cfg(feature = "json")]
response_json()110 async fn response_json() {
111 let _ = env_logger::try_init();
112
113 let server = server::http(move |_req| async { http::Response::new("\"Hello\"".into()) });
114
115 let client = Client::new();
116
117 let res = client
118 .get(&format!("http://{}/json", server.addr()))
119 .send()
120 .await
121 .expect("Failed to get");
122 let text = res.json::<String>().await.expect("Failed to get json");
123 assert_eq!("Hello", text);
124 }
125
126 #[tokio::test]
body_pipe_response()127 async fn body_pipe_response() {
128 let _ = env_logger::try_init();
129
130 let server = server::http(move |mut req| async move {
131 if req.uri() == "/get" {
132 http::Response::new("pipe me".into())
133 } else {
134 assert_eq!(req.uri(), "/pipe");
135 assert_eq!(req.headers()["transfer-encoding"], "chunked");
136
137 let mut full: Vec<u8> = Vec::new();
138 while let Some(item) = req.body_mut().next().await {
139 full.extend(&*item.unwrap());
140 }
141
142 assert_eq!(full, b"pipe me");
143
144 http::Response::default()
145 }
146 });
147
148 let client = Client::new();
149
150 let res1 = client
151 .get(&format!("http://{}/get", server.addr()))
152 .send()
153 .await
154 .expect("get1");
155
156 assert_eq!(res1.status(), reqwest::StatusCode::OK);
157 assert_eq!(res1.content_length(), Some(7));
158
159 // and now ensure we can "pipe" the response to another request
160 let res2 = client
161 .post(&format!("http://{}/pipe", server.addr()))
162 .body(res1)
163 .send()
164 .await
165 .expect("res2");
166
167 assert_eq!(res2.status(), reqwest::StatusCode::OK);
168 }
169
170 #[tokio::test]
overridden_dns_resolution_with_gai()171 async fn overridden_dns_resolution_with_gai() {
172 let _ = env_logger::builder().is_test(true).try_init();
173 let server = server::http(move |_req| async { http::Response::new("Hello".into()) });
174
175 let overridden_domain = "rust-lang.org";
176 let url = format!(
177 "http://{}:{}/domain_override",
178 overridden_domain,
179 server.addr().port()
180 );
181 let client = reqwest::Client::builder()
182 .resolve(overridden_domain, server.addr())
183 .build()
184 .expect("client builder");
185 let req = client.get(&url);
186 let res = req.send().await.expect("request");
187
188 assert_eq!(res.status(), reqwest::StatusCode::OK);
189 let text = res.text().await.expect("Failed to get text");
190 assert_eq!("Hello", text);
191 }
192
193 #[cfg(feature = "trust-dns")]
194 #[tokio::test]
overridden_dns_resolution_with_trust_dns()195 async fn overridden_dns_resolution_with_trust_dns() {
196 let _ = env_logger::builder().is_test(true).try_init();
197 let server = server::http(move |_req| async { http::Response::new("Hello".into()) });
198
199 let overridden_domain = "rust-lang.org";
200 let url = format!(
201 "http://{}:{}/domain_override",
202 overridden_domain,
203 server.addr().port()
204 );
205 let client = reqwest::Client::builder()
206 .resolve(overridden_domain, server.addr())
207 .trust_dns(true)
208 .build()
209 .expect("client builder");
210 let req = client.get(&url);
211 let res = req.send().await.expect("request");
212
213 assert_eq!(res.status(), reqwest::StatusCode::OK);
214 let text = res.text().await.expect("Failed to get text");
215 assert_eq!("Hello", text);
216 }
217
218 #[cfg(any(feature = "native-tls", feature = "__rustls",))]
219 #[test]
use_preconfigured_tls_with_bogus_backend()220 fn use_preconfigured_tls_with_bogus_backend() {
221 struct DefinitelyNotTls;
222
223 reqwest::Client::builder()
224 .use_preconfigured_tls(DefinitelyNotTls)
225 .build()
226 .expect_err("definitely is not TLS");
227 }
228
229 #[cfg(feature = "native-tls")]
230 #[test]
use_preconfigured_native_tls_default()231 fn use_preconfigured_native_tls_default() {
232 extern crate native_tls_crate;
233
234 let tls = native_tls_crate::TlsConnector::builder()
235 .build()
236 .expect("tls builder");
237
238 reqwest::Client::builder()
239 .use_preconfigured_tls(tls)
240 .build()
241 .expect("preconfigured default tls");
242 }
243
244 #[cfg(feature = "__rustls")]
245 #[test]
use_preconfigured_rustls_default()246 fn use_preconfigured_rustls_default() {
247 extern crate rustls;
248
249 let root_cert_store = rustls::RootCertStore::empty();
250 let tls = rustls::ClientConfig::builder()
251 .with_safe_defaults()
252 .with_root_certificates(root_cert_store)
253 .with_no_client_auth();
254
255 reqwest::Client::builder()
256 .use_preconfigured_tls(tls)
257 .build()
258 .expect("preconfigured rustls tls");
259 }
260
261 #[cfg(feature = "__rustls")]
262 #[tokio::test]
263 #[ignore = "Needs TLS support in the test server"]
http2_upgrade()264 async fn http2_upgrade() {
265 let server = server::http(move |_| async move { http::Response::default() });
266
267 let url = format!("https://localhost:{}", server.addr().port());
268 let res = reqwest::Client::builder()
269 .danger_accept_invalid_certs(true)
270 .use_rustls_tls()
271 .build()
272 .expect("client builder")
273 .get(&url)
274 .send()
275 .await
276 .expect("request");
277
278 assert_eq!(res.status(), reqwest::StatusCode::OK);
279 assert_eq!(res.version(), reqwest::Version::HTTP_2);
280 }
281
282 #[cfg(feature = "default-tls")]
283 #[tokio::test]
test_allowed_methods()284 async fn test_allowed_methods() {
285 let resp = reqwest::Client::builder()
286 .https_only(true)
287 .build()
288 .expect("client builder")
289 .get("https://google.com")
290 .send()
291 .await;
292
293 assert!(resp.is_ok());
294
295 let resp = reqwest::Client::builder()
296 .https_only(true)
297 .build()
298 .expect("client builder")
299 .get("http://google.com")
300 .send()
301 .await;
302
303 assert!(resp.is_err());
304 }
305