1 mod support;
2 use support::*;
3
4 #[test]
test_response_text()5 fn test_response_text() {
6 let server = server::http(move |_req| async { http::Response::new("Hello".into()) });
7
8 let url = format!("http://{}/text", server.addr());
9 let res = reqwest::blocking::get(&url).unwrap();
10 assert_eq!(res.url().as_str(), &url);
11 assert_eq!(res.status(), reqwest::StatusCode::OK);
12 assert_eq!(res.content_length(), Some(5));
13
14 let body = res.text().unwrap();
15 assert_eq!(b"Hello", body.as_bytes());
16 }
17
18 #[test]
test_response_non_utf_8_text()19 fn test_response_non_utf_8_text() {
20 let server = server::http(move |_req| async {
21 http::Response::builder()
22 .header("content-type", "text/plain; charset=gbk")
23 .body(b"\xc4\xe3\xba\xc3"[..].into())
24 .unwrap()
25 });
26
27 let url = format!("http://{}/text", server.addr());
28 let res = reqwest::blocking::get(&url).unwrap();
29 assert_eq!(res.url().as_str(), &url);
30 assert_eq!(res.status(), reqwest::StatusCode::OK);
31 assert_eq!(res.content_length(), Some(4));
32
33 let body = res.text().unwrap();
34 assert_eq!("你好", &body);
35 assert_eq!(b"\xe4\xbd\xa0\xe5\xa5\xbd", body.as_bytes()); // Now it's utf-8
36 }
37
38 #[test]
39 #[cfg(feature = "json")]
test_response_json()40 fn test_response_json() {
41 let server = server::http(move |_req| async { http::Response::new("\"Hello\"".into()) });
42
43 let url = format!("http://{}/json", server.addr());
44 let res = reqwest::blocking::get(&url).unwrap();
45 assert_eq!(res.url().as_str(), &url);
46 assert_eq!(res.status(), reqwest::StatusCode::OK);
47 assert_eq!(res.content_length(), Some(7));
48
49 let body = res.json::<String>().unwrap();
50 assert_eq!("Hello", body);
51 }
52
53 #[test]
test_response_copy_to()54 fn test_response_copy_to() {
55 let server = server::http(move |_req| async { http::Response::new("Hello".into()) });
56
57 let url = format!("http://{}/1", server.addr());
58 let mut res = reqwest::blocking::get(&url).unwrap();
59 assert_eq!(res.url().as_str(), &url);
60 assert_eq!(res.status(), reqwest::StatusCode::OK);
61
62 let mut dst = Vec::new();
63 res.copy_to(&mut dst).unwrap();
64 assert_eq!(dst, b"Hello");
65 }
66
67 #[test]
test_get()68 fn test_get() {
69 let server = server::http(move |_req| async { http::Response::default() });
70
71 let url = format!("http://{}/1", server.addr());
72 let res = reqwest::blocking::get(&url).unwrap();
73
74 assert_eq!(res.url().as_str(), &url);
75 assert_eq!(res.status(), reqwest::StatusCode::OK);
76 assert_eq!(res.remote_addr(), Some(server.addr()));
77
78 assert_eq!(res.text().unwrap().len(), 0)
79 }
80
81 #[test]
test_post()82 fn test_post() {
83 let server = server::http(move |req| async move {
84 assert_eq!(req.method(), "POST");
85 assert_eq!(req.headers()["content-length"], "5");
86
87 let data = hyper::body::to_bytes(req.into_body()).await.unwrap();
88 assert_eq!(&*data, b"Hello");
89
90 http::Response::default()
91 });
92
93 let url = format!("http://{}/2", server.addr());
94 let res = reqwest::blocking::Client::new()
95 .post(&url)
96 .body("Hello")
97 .send()
98 .unwrap();
99
100 assert_eq!(res.url().as_str(), &url);
101 assert_eq!(res.status(), reqwest::StatusCode::OK);
102 }
103
104 #[test]
test_post_form()105 fn test_post_form() {
106 let server = server::http(move |req| async move {
107 assert_eq!(req.method(), "POST");
108 assert_eq!(req.headers()["content-length"], "24");
109 assert_eq!(
110 req.headers()["content-type"],
111 "application/x-www-form-urlencoded"
112 );
113
114 let data = hyper::body::to_bytes(req.into_body()).await.unwrap();
115 assert_eq!(&*data, b"hello=world&sean=monstar");
116
117 http::Response::default()
118 });
119
120 let form = &[("hello", "world"), ("sean", "monstar")];
121
122 let url = format!("http://{}/form", server.addr());
123 let res = reqwest::blocking::Client::new()
124 .post(&url)
125 .form(form)
126 .send()
127 .expect("request send");
128
129 assert_eq!(res.url().as_str(), &url);
130 assert_eq!(res.status(), reqwest::StatusCode::OK);
131 }
132
133 /// Calling `Response::error_for_status`` on a response with status in 4xx
134 /// returns a error.
135 #[test]
test_error_for_status_4xx()136 fn test_error_for_status_4xx() {
137 let server = server::http(move |_req| async {
138 http::Response::builder()
139 .status(400)
140 .body(Default::default())
141 .unwrap()
142 });
143
144 let url = format!("http://{}/1", server.addr());
145 let res = reqwest::blocking::get(&url).unwrap();
146
147 let err = res.error_for_status().unwrap_err();
148 assert!(err.is_status());
149 assert_eq!(err.status(), Some(reqwest::StatusCode::BAD_REQUEST));
150 }
151
152 /// Calling `Response::error_for_status`` on a response with status in 5xx
153 /// returns a error.
154 #[test]
test_error_for_status_5xx()155 fn test_error_for_status_5xx() {
156 let server = server::http(move |_req| async {
157 http::Response::builder()
158 .status(500)
159 .body(Default::default())
160 .unwrap()
161 });
162
163 let url = format!("http://{}/1", server.addr());
164 let res = reqwest::blocking::get(&url).unwrap();
165
166 let err = res.error_for_status().unwrap_err();
167 assert!(err.is_status());
168 assert_eq!(
169 err.status(),
170 Some(reqwest::StatusCode::INTERNAL_SERVER_ERROR)
171 );
172 }
173
174 #[test]
test_default_headers()175 fn test_default_headers() {
176 let server = server::http(move |req| async move {
177 assert_eq!(req.headers()["reqwest-test"], "orly");
178 http::Response::default()
179 });
180
181 let mut headers = http::HeaderMap::with_capacity(1);
182 headers.insert("reqwest-test", "orly".parse().unwrap());
183 let client = reqwest::blocking::Client::builder()
184 .default_headers(headers)
185 .build()
186 .unwrap();
187
188 let url = format!("http://{}/1", server.addr());
189 let res = client.get(&url).send().unwrap();
190
191 assert_eq!(res.url().as_str(), &url);
192 assert_eq!(res.status(), reqwest::StatusCode::OK);
193 }
194
195 #[test]
test_override_default_headers()196 fn test_override_default_headers() {
197 let server = server::http(move |req| {
198 async move {
199 // not 'iamatoken'
200 assert_eq!(req.headers()[&http::header::AUTHORIZATION], "secret");
201 http::Response::default()
202 }
203 });
204
205 let mut headers = http::HeaderMap::with_capacity(1);
206 headers.insert(
207 http::header::AUTHORIZATION,
208 http::header::HeaderValue::from_static("iamatoken"),
209 );
210 let client = reqwest::blocking::Client::builder()
211 .default_headers(headers)
212 .build()
213 .unwrap();
214
215 let url = format!("http://{}/3", server.addr());
216 let res = client
217 .get(&url)
218 .header(
219 http::header::AUTHORIZATION,
220 http::header::HeaderValue::from_static("secret"),
221 )
222 .send()
223 .unwrap();
224
225 assert_eq!(res.url().as_str(), &url);
226 assert_eq!(res.status(), reqwest::StatusCode::OK);
227 }
228
229 #[test]
test_appended_headers_not_overwritten()230 fn test_appended_headers_not_overwritten() {
231 let server = server::http(move |req| async move {
232 let mut accepts = req.headers().get_all("accept").into_iter();
233 assert_eq!(accepts.next().unwrap(), "application/json");
234 assert_eq!(accepts.next().unwrap(), "application/json+hal");
235 assert_eq!(accepts.next(), None);
236
237 http::Response::default()
238 });
239
240 let client = reqwest::blocking::Client::new();
241
242 let url = format!("http://{}/4", server.addr());
243 let res = client
244 .get(&url)
245 .header(header::ACCEPT, "application/json")
246 .header(header::ACCEPT, "application/json+hal")
247 .send()
248 .unwrap();
249
250 assert_eq!(res.url().as_str(), &url);
251 assert_eq!(res.status(), reqwest::StatusCode::OK);
252
253 // make sure this also works with default headers
254 use reqwest::header;
255 let mut headers = header::HeaderMap::with_capacity(1);
256 headers.insert(
257 header::ACCEPT,
258 header::HeaderValue::from_static("text/html"),
259 );
260 let client = reqwest::blocking::Client::builder()
261 .default_headers(headers)
262 .build()
263 .unwrap();
264
265 let url = format!("http://{}/4", server.addr());
266 let res = client
267 .get(&url)
268 .header(header::ACCEPT, "application/json")
269 .header(header::ACCEPT, "application/json+hal")
270 .send()
271 .unwrap();
272
273 assert_eq!(res.url().as_str(), &url);
274 assert_eq!(res.status(), reqwest::StatusCode::OK);
275 }
276
277 #[cfg_attr(not(debug_assertions), ignore)]
278 #[test]
279 #[should_panic]
test_blocking_inside_a_runtime()280 fn test_blocking_inside_a_runtime() {
281 let server = server::http(move |_req| async { http::Response::new("Hello".into()) });
282
283 let url = format!("http://{}/text", server.addr());
284
285 let rt = tokio::runtime::Builder::new_current_thread()
286 .build()
287 .expect("new rt");
288
289 rt.block_on(async move {
290 let _should_panic = reqwest::blocking::get(&url);
291 });
292 }
293
294 #[cfg(feature = "default-tls")]
295 #[test]
test_allowed_methods_blocking()296 fn test_allowed_methods_blocking() {
297 let resp = reqwest::blocking::Client::builder()
298 .https_only(true)
299 .build()
300 .expect("client builder")
301 .get("https://google.com")
302 .send();
303
304 assert_eq!(resp.is_err(), false);
305
306 let resp = reqwest::blocking::Client::builder()
307 .https_only(true)
308 .build()
309 .expect("client builder")
310 .get("http://google.com")
311 .send();
312
313 assert_eq!(resp.is_err(), true);
314 }
315
316 /// Test that a [`reqwest::blocking::Body`] can be created from [`bytes::Bytes`].
317 #[test]
test_body_from_bytes()318 fn test_body_from_bytes() {
319 let body = "abc";
320 // No external calls are needed. Only the request building is tested.
321 let request = reqwest::blocking::Client::builder()
322 .build()
323 .expect("Could not build the client")
324 .put("https://google.com")
325 .body(bytes::Bytes::from(body))
326 .build()
327 .expect("Invalid body");
328
329 assert_eq!(request.body().unwrap().as_bytes(), Some(body.as_bytes()));
330 }
331