forked/reqwest-impersonate
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Newest rustfmt changes

Browse Source
This commit is contained in:
Sean McArthur
2020-02-06 10:17:40 -08:00
parent 4c1290fc2a
commit 04980689ce
5 changed files with 257 additions and 316 deletions
Download Patch File Download Diff File Expand all files Collapse all files

94
tests/blocking.rs
View File

@@ -17,13 +17,11 @@ fn test_response_text() {
#[test] #[test]
fn test_response_non_utf_8_text() { fn test_response_non_utf_8_text() {
let server = server::http(move |_req| { let server = server::http(move |_req| async {
async { http::Response::builder()
http::Response::builder() .header("content-type", "text/plain; charset=gbk")
.header("content-type", "text/plain; charset=gbk") .body(b"\xc4\xe3\xba\xc3"[..].into())
.body(b"\xc4\xe3\xba\xc3"[..].into()) .unwrap()
.unwrap()
}
}); });
let url = format!("http://{}/text", server.addr()); let url = format!("http://{}/text", server.addr());
@@ -82,16 +80,14 @@ fn test_get() {
#[test] #[test]
fn test_post() { fn test_post() {
let server = server::http(move |req| { let server = server::http(move |req| async move {
async move { assert_eq!(req.method(), "POST");
assert_eq!(req.method(), "POST"); assert_eq!(req.headers()["content-length"], "5");
assert_eq!(req.headers()["content-length"], "5");
let data = hyper::body::to_bytes(req.into_body()).await.unwrap(); let data = hyper::body::to_bytes(req.into_body()).await.unwrap();
assert_eq!(&*data, b"Hello"); assert_eq!(&*data, b"Hello");
http::Response::default() http::Response::default()
}
}); });
let url = format!("http://{}/2", server.addr()); let url = format!("http://{}/2", server.addr());
@@ -107,20 +103,18 @@ fn test_post() {
#[test] #[test]
fn test_post_form() { fn test_post_form() {
let server = server::http(move |req| { let server = server::http(move |req| async move {
async move { assert_eq!(req.method(), "POST");
assert_eq!(req.method(), "POST"); assert_eq!(req.headers()["content-length"], "24");
assert_eq!(req.headers()["content-length"], "24"); assert_eq!(
assert_eq!( req.headers()["content-type"],
req.headers()["content-type"], "application/x-www-form-urlencoded"
"application/x-www-form-urlencoded" );
);
let data = hyper::body::to_bytes(req.into_body()).await.unwrap(); let data = hyper::body::to_bytes(req.into_body()).await.unwrap();
assert_eq!(&*data, b"hello=world&sean=monstar"); assert_eq!(&*data, b"hello=world&sean=monstar");
http::Response::default() http::Response::default()
}
}); });
let form = &[("hello", "world"), ("sean", "monstar")]; let form = &[("hello", "world"), ("sean", "monstar")];
@@ -140,13 +134,11 @@ fn test_post_form() {
/// returns a error. /// returns a error.
#[test] #[test]
fn test_error_for_status_4xx() { fn test_error_for_status_4xx() {
let server = server::http(move |_req| { let server = server::http(move |_req| async {
async { http::Response::builder()
http::Response::builder() .status(400)
.status(400) .body(Default::default())
.body(Default::default()) .unwrap()
.unwrap()
}
}); });
let url = format!("http://{}/1", server.addr()); let url = format!("http://{}/1", server.addr());
@@ -161,13 +153,11 @@ fn test_error_for_status_4xx() {
/// returns a error. /// returns a error.
#[test] #[test]
fn test_error_for_status_5xx() { fn test_error_for_status_5xx() {
let server = server::http(move |_req| { let server = server::http(move |_req| async {
async { http::Response::builder()
http::Response::builder() .status(500)
.status(500) .body(Default::default())
.body(Default::default()) .unwrap()
.unwrap()
}
}); });
let url = format!("http://{}/1", server.addr()); let url = format!("http://{}/1", server.addr());
@@ -183,11 +173,9 @@ fn test_error_for_status_5xx() {
#[test] #[test]
fn test_default_headers() { fn test_default_headers() {
let server = server::http(move |req| { let server = server::http(move |req| async move {
async move { assert_eq!(req.headers()["reqwest-test"], "orly");
assert_eq!(req.headers()["reqwest-test"], "orly"); http::Response::default()
http::Response::default()
}
}); });
let mut headers = http::HeaderMap::with_capacity(1); let mut headers = http::HeaderMap::with_capacity(1);
@@ -240,15 +228,13 @@ fn test_override_default_headers() {
#[test] #[test]
fn test_appended_headers_not_overwritten() { fn test_appended_headers_not_overwritten() {
let server = server::http(move |req| { let server = server::http(move |req| async move {
async move { let mut accepts = req.headers().get_all("accept").into_iter();
let mut accepts = req.headers().get_all("accept").into_iter(); assert_eq!(accepts.next().unwrap(), "application/json");
assert_eq!(accepts.next().unwrap(), "application/json"); assert_eq!(accepts.next().unwrap(), "application/json+hal");
assert_eq!(accepts.next().unwrap(), "application/json+hal"); assert_eq!(accepts.next(), None);
assert_eq!(accepts.next(), None);
http::Response::default() http::Response::default()
}
}); });
let client = reqwest::blocking::Client::new(); let client = reqwest::blocking::Client::new();

54
tests/client.rs
View File

@@ -6,18 +6,16 @@ use reqwest::Client;
#[tokio::test] #[tokio::test]
async fn auto_headers() { async fn auto_headers() {
let server = server::http(move |req| { let server = server::http(move |req| async move {
async move { assert_eq!(req.method(), "GET");
assert_eq!(req.method(), "GET");
assert_eq!(req.headers()["accept"], "*/*"); assert_eq!(req.headers()["accept"], "*/*");
assert_eq!(req.headers().get("user-agent"), None); assert_eq!(req.headers().get("user-agent"), None);
if cfg!(feature = "gzip") { if cfg!(feature = "gzip") {
assert_eq!(req.headers()["accept-encoding"], "gzip"); assert_eq!(req.headers()["accept-encoding"], "gzip");
}
http::Response::default()
} }
http::Response::default()
}); });
let url = format!("http://{}/1", server.addr()); let url = format!("http://{}/1", server.addr());
@@ -30,11 +28,9 @@ async fn auto_headers() {
#[tokio::test] #[tokio::test]
async fn user_agent() { async fn user_agent() {
let server = server::http(move |req| { let server = server::http(move |req| async move {
async move { assert_eq!(req.headers()["user-agent"], "reqwest-test-agent");
assert_eq!(req.headers()["user-agent"], "reqwest-test-agent"); http::Response::default()
http::Response::default()
}
}); });
let url = format!("http://{}/ua", server.addr()); let url = format!("http://{}/ua", server.addr());
@@ -89,23 +85,21 @@ async fn response_json() {
async fn body_pipe_response() { async fn body_pipe_response() {
let _ = env_logger::try_init(); let _ = env_logger::try_init();
let server = server::http(move |mut req| { let server = server::http(move |mut req| async move {
async move { if req.uri() == "/get" {
if req.uri() == "/get" { http::Response::new("pipe me".into())
http::Response::new("pipe me".into()) } else {
} else { assert_eq!(req.uri(), "/pipe");
assert_eq!(req.uri(), "/pipe"); assert_eq!(req.headers()["transfer-encoding"], "chunked");
assert_eq!(req.headers()["transfer-encoding"], "chunked");
let mut full: Vec<u8> = Vec::new(); let mut full: Vec<u8> = Vec::new();
while let Some(item) = req.body_mut().next().await { while let Some(item) = req.body_mut().next().await {
full.extend(&*item.unwrap()); full.extend(&*item.unwrap());
}
assert_eq!(full, b"pipe me");
http::Response::default()
} }
assert_eq!(full, b"pipe me");
http::Response::default()
} }
}); });

142
tests/cookie.rs
View File

@@ -3,24 +3,22 @@ use support::*;
#[tokio::test] #[tokio::test]
async fn cookie_response_accessor() { async fn cookie_response_accessor() {
let server = server::http(move |_req| { let server = server::http(move |_req| async move {
async move { http::Response::builder()
http::Response::builder() .header("Set-Cookie", "key=val")
.header("Set-Cookie", "key=val") .header(
.header( "Set-Cookie",
"Set-Cookie", "expires=1; Expires=Wed, 21 Oct 2015 07:28:00 GMT",
"expires=1; Expires=Wed, 21 Oct 2015 07:28:00 GMT", )
) .header("Set-Cookie", "path=1; Path=/the-path")
.header("Set-Cookie", "path=1; Path=/the-path") .header("Set-Cookie", "maxage=1; Max-Age=100")
.header("Set-Cookie", "maxage=1; Max-Age=100") .header("Set-Cookie", "domain=1; Domain=mydomain")
.header("Set-Cookie", "domain=1; Domain=mydomain") .header("Set-Cookie", "secure=1; Secure")
.header("Set-Cookie", "secure=1; Secure") .header("Set-Cookie", "httponly=1; HttpOnly")
.header("Set-Cookie", "httponly=1; HttpOnly") .header("Set-Cookie", "samesitelax=1; SameSite=Lax")
.header("Set-Cookie", "samesitelax=1; SameSite=Lax") .header("Set-Cookie", "samesitestrict=1; SameSite=Strict")
.header("Set-Cookie", "samesitestrict=1; SameSite=Strict") .body(Default::default())
.body(Default::default()) .unwrap()
.unwrap()
}
}); });
let client = reqwest::Client::new(); let client = reqwest::Client::new();
@@ -75,16 +73,14 @@ async fn cookie_response_accessor() {
#[tokio::test] #[tokio::test]
async fn cookie_store_simple() { async fn cookie_store_simple() {
let server = server::http(move |req| { let server = server::http(move |req| async move {
async move { if req.uri() == "/2" {
if req.uri() == "/2" { assert_eq!(req.headers()["cookie"], "key=val");
assert_eq!(req.headers()["cookie"], "key=val");
}
http::Response::builder()
.header("Set-Cookie", "key=val; HttpOnly")
.body(Default::default())
.unwrap()
} }
http::Response::builder()
.header("Set-Cookie", "key=val; HttpOnly")
.body(Default::default())
.unwrap()
}); });
let client = reqwest::Client::builder() let client = reqwest::Client::builder()
@@ -101,24 +97,22 @@ async fn cookie_store_simple() {
#[tokio::test] #[tokio::test]
async fn cookie_store_overwrite_existing() { async fn cookie_store_overwrite_existing() {
let server = server::http(move |req| { let server = server::http(move |req| async move {
async move { if req.uri() == "/" {
if req.uri() == "/" { http::Response::builder()
http::Response::builder() .header("Set-Cookie", "key=val")
.header("Set-Cookie", "key=val") .body(Default::default())
.body(Default::default()) .unwrap()
.unwrap() } else if req.uri() == "/2" {
} else if req.uri() == "/2" { assert_eq!(req.headers()["cookie"], "key=val");
assert_eq!(req.headers()["cookie"], "key=val"); http::Response::builder()
http::Response::builder() .header("Set-Cookie", "key=val2")
.header("Set-Cookie", "key=val2") .body(Default::default())
.body(Default::default()) .unwrap()
.unwrap() } else {
} else { assert_eq!(req.uri(), "/3");
assert_eq!(req.uri(), "/3"); assert_eq!(req.headers()["cookie"], "key=val2");
assert_eq!(req.headers()["cookie"], "key=val2"); http::Response::default()
http::Response::default()
}
} }
}); });
@@ -139,14 +133,12 @@ async fn cookie_store_overwrite_existing() {
#[tokio::test] #[tokio::test]
async fn cookie_store_max_age() { async fn cookie_store_max_age() {
let server = server::http(move |req| { let server = server::http(move |req| async move {
async move { assert_eq!(req.headers().get("cookie"), None);
assert_eq!(req.headers().get("cookie"), None); http::Response::builder()
http::Response::builder() .header("Set-Cookie", "key=val; Max-Age=0")
.header("Set-Cookie", "key=val; Max-Age=0") .body(Default::default())
.body(Default::default()) .unwrap()
.unwrap()
}
}); });
let client = reqwest::Client::builder() let client = reqwest::Client::builder()
@@ -160,17 +152,15 @@ async fn cookie_store_max_age() {
#[tokio::test] #[tokio::test]
async fn cookie_store_expires() { async fn cookie_store_expires() {
let server = server::http(move |req| { let server = server::http(move |req| async move {
async move { assert_eq!(req.headers().get("cookie"), None);
assert_eq!(req.headers().get("cookie"), None); http::Response::builder()
http::Response::builder() .header(
.header( "Set-Cookie",
"Set-Cookie", "key=val; Expires=Wed, 21 Oct 2015 07:28:00 GMT",
"key=val; Expires=Wed, 21 Oct 2015 07:28:00 GMT", )
) .body(Default::default())
.body(Default::default()) .unwrap()
.unwrap()
}
}); });
let client = reqwest::Client::builder() let client = reqwest::Client::builder()
@@ -185,19 +175,17 @@ async fn cookie_store_expires() {
#[tokio::test] #[tokio::test]
async fn cookie_store_path() { async fn cookie_store_path() {
let server = server::http(move |req| { let server = server::http(move |req| async move {
async move { if req.uri() == "/" {
if req.uri() == "/" { assert_eq!(req.headers().get("cookie"), None);
assert_eq!(req.headers().get("cookie"), None); http::Response::builder()
http::Response::builder() .header("Set-Cookie", "key=val; Path=/subpath")
.header("Set-Cookie", "key=val; Path=/subpath") .body(Default::default())
.body(Default::default()) .unwrap()
.unwrap() } else {
} else { assert_eq!(req.uri(), "/subpath");
assert_eq!(req.uri(), "/subpath"); assert_eq!(req.headers()["cookie"], "key=val");
assert_eq!(req.headers()["cookie"], "key=val"); http::Response::default()
http::Response::default()
}
} }
}); });

43
tests/gzip.rs
View File

@@ -15,16 +15,14 @@ async fn gzip_single_byte_chunks() {
#[tokio::test] #[tokio::test]
async fn test_gzip_empty_body() { async fn test_gzip_empty_body() {
let server = server::http(move |req| { let server = server::http(move |req| async move {
async move { assert_eq!(req.method(), "HEAD");
assert_eq!(req.method(), "HEAD");
http::Response::builder() http::Response::builder()
.header("content-encoding", "gzip") .header("content-encoding", "gzip")
.header("content-length", 100) .header("content-length", 100)
.body(Default::default()) .body(Default::default())
.unwrap() .unwrap()
}
}); });
let client = reqwest::Client::new(); let client = reqwest::Client::new();
@@ -41,12 +39,10 @@ async fn test_gzip_empty_body() {
#[tokio::test] #[tokio::test]
async fn test_accept_header_is_not_changed_if_set() { async fn test_accept_header_is_not_changed_if_set() {
let server = server::http(move |req| { let server = server::http(move |req| async move {
async move { assert_eq!(req.headers()["accept"], "application/json");
assert_eq!(req.headers()["accept"], "application/json"); assert_eq!(req.headers()["accept-encoding"], "gzip");
assert_eq!(req.headers()["accept-encoding"], "gzip"); http::Response::default()
http::Response::default()
}
}); });
let client = reqwest::Client::new(); let client = reqwest::Client::new();
@@ -66,12 +62,10 @@ async fn test_accept_header_is_not_changed_if_set() {
#[tokio::test] #[tokio::test]
async fn test_accept_encoding_header_is_not_changed_if_set() { async fn test_accept_encoding_header_is_not_changed_if_set() {
let server = server::http(move |req| { let server = server::http(move |req| async move {
async move { assert_eq!(req.headers()["accept"], "*/*");
assert_eq!(req.headers()["accept"], "*/*"); assert_eq!(req.headers()["accept-encoding"], "identity");
assert_eq!(req.headers()["accept-encoding"], "identity"); http::Response::default()
http::Response::default()
}
}); });
let client = reqwest::Client::new(); let client = reqwest::Client::new();
@@ -122,13 +116,12 @@ async fn gzip_case(response_size: usize, chunk_size: usize) {
let gzipped = gzipped_content.clone(); let gzipped = gzipped_content.clone();
async move { async move {
let len = gzipped.len(); let len = gzipped.len();
let stream = futures_util::stream::unfold((gzipped, 0), move |(gzipped, pos)| { let stream =
async move { futures_util::stream::unfold((gzipped, 0), move |(gzipped, pos)| async move {
let chunk = gzipped.chunks(chunk_size).nth(pos)?.to_vec(); let chunk = gzipped.chunks(chunk_size).nth(pos)?.to_vec();
Some((chunk, (gzipped, pos + 1))) Some((chunk, (gzipped, pos + 1)))
} });
});
let body = hyper::Body::wrap_stream(stream.map(Ok::<_, std::convert::Infallible>)); let body = hyper::Body::wrap_stream(stream.map(Ok::<_, std::convert::Infallible>));

240
tests/redirect.rs
View File

@@ -8,24 +8,22 @@ async fn test_redirect_301_and_302_and_303_changes_post_to_get() {
let codes = [301u16, 302, 303]; let codes = [301u16, 302, 303];
for &code in codes.iter() { for &code in codes.iter() {
let redirect = server::http(move |req| { let redirect = server::http(move |req| async move {
async move { if req.method() == "POST" {
if req.method() == "POST" { assert_eq!(req.uri(), &*format!("/{}", code));
assert_eq!(req.uri(), &*format!("/{}", code)); http::Response::builder()
http::Response::builder() .status(code)
.status(code) .header("location", "/dst")
.header("location", "/dst") .header("server", "test-redirect")
.header("server", "test-redirect") .body(Default::default())
.body(Default::default()) .unwrap()
.unwrap() } else {
} else { assert_eq!(req.method(), "GET");
assert_eq!(req.method(), "GET");
http::Response::builder() http::Response::builder()
.header("server", "test-dst") .header("server", "test-dst")
.body(Default::default()) .body(Default::default())
.unwrap() .unwrap()
}
} }
}); });
@@ -46,24 +44,22 @@ async fn test_redirect_307_and_308_tries_to_get_again() {
let client = reqwest::Client::new(); let client = reqwest::Client::new();
let codes = [307u16, 308]; let codes = [307u16, 308];
for &code in codes.iter() { for &code in codes.iter() {
let redirect = server::http(move |req| { let redirect = server::http(move |req| async move {
async move { assert_eq!(req.method(), "GET");
assert_eq!(req.method(), "GET"); if req.uri() == &*format!("/{}", code) {
if req.uri() == &*format!("/{}", code) { http::Response::builder()
http::Response::builder() .status(code)
.status(code) .header("location", "/dst")
.header("location", "/dst") .header("server", "test-redirect")
.header("server", "test-redirect") .body(Default::default())
.body(Default::default()) .unwrap()
.unwrap() } else {
} else { assert_eq!(req.uri(), "/dst");
assert_eq!(req.uri(), "/dst");
http::Response::builder() http::Response::builder()
.header("server", "test-dst") .header("server", "test-dst")
.body(Default::default()) .body(Default::default())
.unwrap() .unwrap()
}
} }
}); });
@@ -85,29 +81,27 @@ async fn test_redirect_307_and_308_tries_to_post_again() {
let client = reqwest::Client::new(); let client = reqwest::Client::new();
let codes = [307u16, 308]; let codes = [307u16, 308];
for &code in codes.iter() { for &code in codes.iter() {
let redirect = server::http(move |mut req| { let redirect = server::http(move |mut req| async move {
async move { assert_eq!(req.method(), "POST");
assert_eq!(req.method(), "POST"); assert_eq!(req.headers()["content-length"], "5");
assert_eq!(req.headers()["content-length"], "5");
let data = req.body_mut().next().await.unwrap().unwrap(); let data = req.body_mut().next().await.unwrap().unwrap();
assert_eq!(&*data, b"Hello"); assert_eq!(&*data, b"Hello");
if req.uri() == &*format!("/{}", code) { if req.uri() == &*format!("/{}", code) {
http::Response::builder() http::Response::builder()
.status(code) .status(code)
.header("location", "/dst") .header("location", "/dst")
.header("server", "test-redirect") .header("server", "test-redirect")
.body(Default::default()) .body(Default::default())
.unwrap() .unwrap()
} else { } else {
assert_eq!(req.uri(), "/dst"); assert_eq!(req.uri(), "/dst");
http::Response::builder() http::Response::builder()
.header("server", "test-dst") .header("server", "test-dst")
.body(Default::default()) .body(Default::default())
.unwrap() .unwrap()
}
} }
}); });
@@ -129,22 +123,20 @@ fn test_redirect_307_does_not_try_if_reader_cannot_reset() {
let client = reqwest::blocking::Client::new(); let client = reqwest::blocking::Client::new();
let codes = [307u16, 308]; let codes = [307u16, 308];
for &code in codes.iter() { for &code in codes.iter() {
let redirect = server::http(move |mut req| { let redirect = server::http(move |mut req| async move {
async move { assert_eq!(req.method(), "POST");
assert_eq!(req.method(), "POST"); assert_eq!(req.uri(), &*format!("/{}", code));
assert_eq!(req.uri(), &*format!("/{}", code)); assert_eq!(req.headers()["transfer-encoding"], "chunked");
assert_eq!(req.headers()["transfer-encoding"], "chunked");
let data = req.body_mut().next().await.unwrap().unwrap(); let data = req.body_mut().next().await.unwrap().unwrap();
assert_eq!(&*data, b"Hello"); assert_eq!(&*data, b"Hello");
http::Response::builder() http::Response::builder()
.status(code) .status(code)
.header("location", "/dst") .header("location", "/dst")
.header("server", "test-redirect") .header("server", "test-redirect")
.body(Default::default()) .body(Default::default())
.unwrap() .unwrap()
}
}); });
let url = format!("http://{}/{}", redirect.addr(), code); let url = format!("http://{}/{}", redirect.addr(), code);
@@ -180,15 +172,13 @@ async fn test_redirect_removes_sensitive_headers() {
let end_addr = end_server.addr(); let end_addr = end_server.addr();
let mid_server = server::http(move |req| { let mid_server = server::http(move |req| async move {
async move { assert_eq!(req.headers()["cookie"], "foo=bar");
assert_eq!(req.headers()["cookie"], "foo=bar"); http::Response::builder()
http::Response::builder() .status(302)
.status(302) .header("location", format!("http://{}/end", end_addr))
.header("location", format!("http://{}/end", end_addr)) .body(Default::default())
.body(Default::default()) .unwrap()
.unwrap()
}
}); });
tx.broadcast(Some(mid_server.addr())).unwrap(); tx.broadcast(Some(mid_server.addr())).unwrap();
@@ -208,15 +198,13 @@ async fn test_redirect_removes_sensitive_headers() {
#[tokio::test] #[tokio::test]
async fn test_redirect_policy_can_return_errors() { async fn test_redirect_policy_can_return_errors() {
let server = server::http(move |req| { let server = server::http(move |req| async move {
async move { assert_eq!(req.uri(), "/loop");
assert_eq!(req.uri(), "/loop"); http::Response::builder()
http::Response::builder() .status(302)
.status(302) .header("location", "/loop")
.header("location", "/loop") .body(Default::default())
.body(Default::default()) .unwrap()
.unwrap()
}
}); });
let url = format!("http://{}/loop", server.addr()); let url = format!("http://{}/loop", server.addr());
@@ -226,15 +214,13 @@ async fn test_redirect_policy_can_return_errors() {
#[tokio::test] #[tokio::test]
async fn test_redirect_policy_can_stop_redirects_without_an_error() { async fn test_redirect_policy_can_stop_redirects_without_an_error() {
let server = server::http(move |req| { let server = server::http(move |req| async move {
async move { assert_eq!(req.uri(), "/no-redirect");
assert_eq!(req.uri(), "/no-redirect"); http::Response::builder()
http::Response::builder() .status(302)
.status(302) .header("location", "/dont")
.header("location", "/dont") .body(Default::default())
.body(Default::default()) .unwrap()
.unwrap()
}
}); });
let url = format!("http://{}/no-redirect", server.addr()); let url = format!("http://{}/no-redirect", server.addr());
@@ -254,20 +240,18 @@ async fn test_redirect_policy_can_stop_redirects_without_an_error() {
#[tokio::test] #[tokio::test]
async fn test_referer_is_not_set_if_disabled() { async fn test_referer_is_not_set_if_disabled() {
let server = server::http(move |req| { let server = server::http(move |req| async move {
async move { if req.uri() == "/no-refer" {
if req.uri() == "/no-refer" { http::Response::builder()
http::Response::builder() .status(302)
.status(302) .header("location", "/dst")
.header("location", "/dst") .body(Default::default())
.body(Default::default()) .unwrap()
.unwrap() } else {
} else { assert_eq!(req.uri(), "/dst");
assert_eq!(req.uri(), "/dst"); assert_eq!(req.headers().get("referer"), None);
assert_eq!(req.headers().get("referer"), None);
http::Response::default() http::Response::default()
}
} }
}); });
@@ -283,14 +267,12 @@ async fn test_referer_is_not_set_if_disabled() {
#[tokio::test] #[tokio::test]
async fn test_invalid_location_stops_redirect_gh484() { async fn test_invalid_location_stops_redirect_gh484() {
let server = server::http(move |_req| { let server = server::http(move |_req| async move {
async move { http::Response::builder()
http::Response::builder() .status(302)
.status(302) .header("location", "http://www.yikes{KABOOM}")
.header("location", "http://www.yikes{KABOOM}") .body(Default::default())
.body(Default::default()) .unwrap()
.unwrap()
}
}); });
let url = format!("http://{}/yikes", server.addr()); let url = format!("http://{}/yikes", server.addr());
@@ -305,20 +287,18 @@ async fn test_invalid_location_stops_redirect_gh484() {
#[tokio::test] #[tokio::test]
async fn test_redirect_302_with_set_cookies() { async fn test_redirect_302_with_set_cookies() {
let code = 302; let code = 302;
let server = server::http(move |req| { let server = server::http(move |req| async move {
async move { if req.uri() == "/302" {
if req.uri() == "/302" { http::Response::builder()
http::Response::builder() .status(302)
.status(302) .header("location", "/dst")
.header("location", "/dst") .header("set-cookie", "key=value")
.header("set-cookie", "key=value") .body(Default::default())
.body(Default::default()) .unwrap()
.unwrap() } else {
} else { assert_eq!(req.uri(), "/dst");
assert_eq!(req.uri(), "/dst"); assert_eq!(req.headers()["cookie"], "key=value");
assert_eq!(req.headers()["cookie"], "key=value"); http::Response::default()
http::Response::default()
}
} }
}); });