Newest rustfmt changes

tests/blocking.rs

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

tests/client.rs

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

tests/cookie.rs

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

tests/gzip.rs

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

tests/redirect.rs

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