fix tests on master

Author: jbr

Cargo.toml

@@ -32,7 +32,7 @@ unstable = []
 __internal__bench = []
 
 [dependencies]
-async-h1 = { version = "2.0.0", optional = true }
+async-h1 = { version = "2.0.1", optional = true }
 async-sse = "3.0.0"
 async-std = { version = "1.6.0", features = ["unstable"] }
 femme = "2.0.1"
@@ -47,9 +47,9 @@ serde_qs = "0.5.0"
 async-std = { version = "1.6.0", features = ["unstable", "attributes"] }
 juniper = "0.14.1"
 portpicker = "0.1.0"
+surf = { version = "2.0.0-alpha.3", default-features = false, features = ["h1-client"] }
 serde = { version = "1.0.102", features = ["derive"] }
 criterion = "0.3.1"
-surf = { version = "2.0.0-alpha.2", default-features = false, features = ["h1-client"] }
 tempdir = "0.3.7"
 
 [[test]]

tests/chunked-encode-large.rs

@@ -88,16 +88,8 @@ async fn chunked_large() -> Result<(), http_types::Error> {
             .await
             .unwrap();
         assert_eq!(res.status(), 200);
-        assert_eq!(
-            // this is awkward and should be revisited when surf is on newer http-types
-            res.header(&"transfer-encoding".parse().unwrap())
-                .unwrap()
-                .last()
-                .unwrap()
-                .as_str(),
-            "chunked"
-        );
-        assert_eq!(res.header(&"content-length".parse().unwrap()), None);
+        assert_eq!(res.header("transfer-encoding").unwrap(), "chunked");
+        assert!(res.header("content-length").is_none());
         let string = res.body_string().await.unwrap();
         assert_eq!(string, TEXT.to_string());
         Ok(())

tests/chunked-encode-small.rs

@@ -38,16 +38,8 @@ async fn chunked_large() -> Result<(), http_types::Error> {
             .await
             .unwrap();
         assert_eq!(res.status(), 200);
-        assert_eq!(
-            // this is awkward and should be revisited when surf is on newer http-types
-            res.header(&"transfer-encoding".parse().unwrap())
-                .unwrap()
-                .last()
-                .unwrap()
-                .as_str(),
-            "chunked"
-        );
-        assert_eq!(res.header(&"content-length".parse().unwrap()), None);
+        assert_eq!(res.header("transfer-encoding").unwrap(), "chunked");
+        assert!(res.header("content-length").is_none());
         let string = res.body_string().await.unwrap();
         assert_eq!(string, TEXT.to_string());
         Ok(())

tests/wildcard.rs

@@ -41,15 +41,15 @@ async fn wildcard() {
         Method::Get,
         Url::parse("http://localhost/add_one/3").unwrap(),
     );
-    let res: http::Response = app.respond(req).await.unwrap();
+    let mut res: http::Response = app.respond(req).await.unwrap();
     assert_eq!(res.status(), StatusCode::Ok);
     assert_eq!(&res.body_string().await.unwrap(), "4");
 
     let req = http::Request::new(
         Method::Get,
         Url::parse("http://localhost/add_one/-7").unwrap(),
     );
-    let res: http::Response = app.respond(req).await.unwrap();
+    let mut res: http::Response = app.respond(req).await.unwrap();
     assert_eq!(res.status(), StatusCode::Ok);
     assert_eq!(&res.body_string().await.unwrap(), "-6");
 }
@@ -89,20 +89,20 @@ async fn wild_path() {
         Method::Get,
         Url::parse("http://localhost/echo/some_path").unwrap(),
     );
-    let res: http::Response = app.respond(req).await.unwrap();
+    let mut res: http::Response = app.respond(req).await.unwrap();
     assert_eq!(res.status(), StatusCode::Ok);
     assert_eq!(&res.body_string().await.unwrap(), "some_path");
 
     let req = http::Request::new(
         Method::Get,
         Url::parse("http://localhost/echo/multi/segment/path").unwrap(),
     );
-    let res: http::Response = app.respond(req).await.unwrap();
+    let mut res: http::Response = app.respond(req).await.unwrap();
     assert_eq!(res.status(), StatusCode::Ok);
     assert_eq!(&res.body_string().await.unwrap(), "multi/segment/path");
 
     let req = http::Request::new(Method::Get, Url::parse("http://localhost/echo/").unwrap());
-    let res: http::Response = app.respond(req).await.unwrap();
+    let mut res: http::Response = app.respond(req).await.unwrap();
     assert_eq!(res.status(), StatusCode::NotFound);
     assert_eq!(&res.body_string().await.unwrap(), "");
 }
@@ -116,15 +116,15 @@ async fn multi_wildcard() {
         Method::Get,
         Url::parse("http://localhost/add_two/1/2/").unwrap(),
     );
-    let res: http::Response = app.respond(req).await.unwrap();
+    let mut res: http::Response = app.respond(req).await.unwrap();
     assert_eq!(res.status(), StatusCode::Ok);
     assert_eq!(&res.body_string().await.unwrap(), "3");
 
     let req = http::Request::new(
         Method::Get,
         Url::parse("http://localhost/add_two/-1/2/").unwrap(),
     );
-    let res: http::Response = app.respond(req).await.unwrap();
+    let mut res: http::Response = app.respond(req).await.unwrap();
     assert_eq!(res.status(), 200);
     assert_eq!(&res.body_string().await.unwrap(), "1");
 
@@ -145,15 +145,15 @@ async fn wild_last_segment() {
         Method::Get,
         Url::parse("http://localhost/echo/one/two").unwrap(),
     );
-    let res: http::Response = app.respond(req).await.unwrap();
+    let mut res: http::Response = app.respond(req).await.unwrap();
     assert_eq!(res.status(), StatusCode::Ok);
     assert_eq!(&res.body_string().await.unwrap(), "one");
 
     let req = http::Request::new(
         Method::Get,
         Url::parse("http://localhost/echo/one/two/three/four").unwrap(),
     );
-    let res: http::Response = app.respond(req).await.unwrap();
+    let mut res: http::Response = app.respond(req).await.unwrap();
     assert_eq!(res.status(), StatusCode::Ok);
     assert_eq!(&res.body_string().await.unwrap(), "one");
 }
@@ -207,15 +207,15 @@ async fn nameless_internal_wildcard() {
         Method::Get,
         Url::parse("http://localhost/echo/one/two").unwrap(),
     );
-    let res: http::Response = app.respond(req).await.unwrap();
+    let mut res: http::Response = app.respond(req).await.unwrap();
     assert_eq!(res.status(), StatusCode::Ok);
     assert_eq!(&res.body_string().await.unwrap(), "two");
 
     let req = http::Request::new(
         Method::Get,
         Url::parse("http://localhost/echo/one/two").unwrap(),
     );
-    let res: http::Response = app.respond(req).await.unwrap();
+    let mut res: http::Response = app.respond(req).await.unwrap();
     assert_eq!(res.status(), StatusCode::Ok);
     assert_eq!(&res.body_string().await.unwrap(), "two");
 }
@@ -229,7 +229,7 @@ async fn nameless_internal_wildcard2() {
         Method::Get,
         Url::parse("http://localhost/echo/one/two").unwrap(),
     );
-    let res: http::Response = app.respond(req).await.unwrap();
+    let mut res: http::Response = app.respond(req).await.unwrap();
     assert_eq!(res.status(), StatusCode::Ok);
     assert_eq!(&res.body_string().await.unwrap(), "one");
 }