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