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