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 tls = rustls::ClientConfig::new();
250
251 reqwest::Client::builder()
252 .use_preconfigured_tls(tls)
253 .build()
254 .expect("preconfigured rustls tls");
255 }
256
257 #[cfg(feature = "__rustls")]
258 #[tokio::test]
259 #[ignore = "Needs TLS support in the test server"]
http2_upgrade()260 async fn http2_upgrade() {
261 let server = server::http(move |_| async move { http::Response::default() });
262
263 let url = format!("https://localhost:{}", server.addr().port());
264 let res = reqwest::Client::builder()
265 .danger_accept_invalid_certs(true)
266 .use_rustls_tls()
267 .build()
268 .expect("client builder")
269 .get(&url)
270 .send()
271 .await
272 .expect("request");
273
274 assert_eq!(res.status(), reqwest::StatusCode::OK);
275 assert_eq!(res.version(), reqwest::Version::HTTP_2);
276 }
277
278 #[cfg(feature = "default-tls")]
279 #[tokio::test]
test_allowed_methods()280 async fn test_allowed_methods() {
281 let resp = reqwest::Client::builder()
282 .https_only(true)
283 .build()
284 .expect("client builder")
285 .get("https://google.com")
286 .send()
287 .await;
288
289 assert!(resp.is_ok());
290
291 let resp = reqwest::Client::builder()
292 .https_only(true)
293 .build()
294 .expect("client builder")
295 .get("http://google.com")
296 .send()
297 .await;
298
299 assert!(resp.is_err());
300 }
301