Merge pull request #446 from jbr/port-binding-in-tests

bind to an unused port in integration tests

Author: yoshuawuyts

tests/chunked-encode-large.rs

@@ -1,3 +1,4 @@
+mod test_utils;
 use async_std::io::Cursor;
 use async_std::prelude::*;
 use async_std::task;
@@ -67,22 +68,23 @@ const TEXT: &'static str = concat![
 
 #[async_std::test]
 async fn chunked_large() -> Result<(), http_types::Error> {
-    let server = task::spawn(async {
+    let bind = test_utils::find_port().await;
+    let server = task::spawn(async move {
         let mut app = tide::new();
-        app.at("/").get(|mut _req: tide::Request<()>| async move {
+        app.at("/").get(|mut _req: tide::Request<()>| async {
             let body = Cursor::new(TEXT.to_owned());
             let res = Response::new(StatusCode::Ok)
                 .body(body)
                 .set_header(headers::CONTENT_TYPE, "text/plain; charset=utf-8");
             Ok(res)
         });
-        app.listen("localhost:8080").await?;
+        app.listen(&bind).await?;
         Result::<(), http_types::Error>::Ok(())
     });
 
-    let client = task::spawn(async {
+    let client = task::spawn(async move {
         task::sleep(Duration::from_millis(100)).await;
-        let mut res = surf::get("http://localhost:8080").await?;
+        let mut res = surf::get(format!("http://{}", bind)).await?;
         assert_eq!(res.status(), 200);
         assert_eq!(
             res.header(&"transfer-encoding".parse().unwrap()),

tests/chunked-encode-small.rs

@@ -1,3 +1,4 @@
+mod test_utils;
 use async_std::io::Cursor;
 use async_std::prelude::*;
 use async_std::task;
@@ -16,7 +17,8 @@ const TEXT: &'static str = concat![
 
 #[async_std::test]
 async fn chunked_large() -> Result<(), http_types::Error> {
-    let server = task::spawn(async {
+    let port = test_utils::find_port().await;
+    let server = task::spawn(async move {
         let mut app = tide::new();
         app.at("/").get(|mut _req: tide::Request<()>| async move {
             let body = Cursor::new(TEXT.to_owned());
@@ -25,13 +27,13 @@ async fn chunked_large() -> Result<(), http_types::Error> {
                 .set_header(headers::CONTENT_TYPE, "text/plain; charset=utf-8");
             Ok(res)
         });
-        app.listen("localhost:8080").await?;
+        app.listen(&port).await?;
         Result::<(), http_types::Error>::Ok(())
     });
 
-    let client = task::spawn(async {
+    let client = task::spawn(async move {
         task::sleep(Duration::from_millis(100)).await;
-        let mut res = surf::get("http://localhost:8080").await?;
+        let mut res = surf::get(format!("http://{}", port)).await?;
         assert_eq!(res.status(), 200);
         assert_eq!(
             res.header(&"transfer-encoding".parse().unwrap()),

tests/server.rs

@@ -1,3 +1,4 @@
+mod test_utils;
 use async_std::prelude::*;
 use async_std::task;
 use std::time::Duration;
@@ -8,20 +9,21 @@ use tide::{Request, Response, StatusCode};
 #[test]
 fn hello_world() -> Result<(), http_types::Error> {
     task::block_on(async {
-        let server = task::spawn(async {
+        let port = test_utils::find_port().await;
+        let server = task::spawn(async move {
             let mut app = tide::new();
             app.at("/").get(|mut req: Request<()>| async move {
                 assert_eq!(req.body_string().await.unwrap(), "nori".to_string());
                 let res = Response::new(StatusCode::Ok).body_string("says hello".to_string());
                 Ok(res)
             });
-            app.listen("localhost:8080").await?;
+            app.listen(&port).await?;
             Result::<(), http_types::Error>::Ok(())
         });
 
-        let client = task::spawn(async {
+        let client = task::spawn(async move {
             task::sleep(Duration::from_millis(100)).await;
-            let string = surf::get("http://localhost:8080")
+            let string = surf::get(format!("http://{}", port))
                 .body_string("nori".to_string())
                 .recv_string()
                 .await?;
@@ -36,17 +38,18 @@ fn hello_world() -> Result<(), http_types::Error> {
 #[test]
 fn echo_server() -> Result<(), http_types::Error> {
     task::block_on(async {
-        let server = task::spawn(async {
+        let port = test_utils::find_port().await;
+        let server = task::spawn(async move {
             let mut app = tide::new();
             app.at("/").get(|req| async move { Ok(req) });
 
-            app.listen("localhost:8081").await?;
+            app.listen(&port).await?;
             Result::<(), http_types::Error>::Ok(())
         });
 
-        let client = task::spawn(async {
+        let client = task::spawn(async move {
             task::sleep(Duration::from_millis(100)).await;
-            let string = surf::get("http://localhost:8081")
+            let string = surf::get(format!("http://{}", port))
                 .body_string("chashu".to_string())
                 .recv_string()
                 .await?;
@@ -66,7 +69,8 @@ fn json() -> Result<(), http_types::Error> {
     }
 
     task::block_on(async {
-        let server = task::spawn(async {
+        let port = test_utils::find_port().await;
+        let server = task::spawn(async move {
             let mut app = tide::new();
             app.at("/").get(|mut req: Request<()>| async move {
                 let mut counter: Counter = req.body_json().await.unwrap();
@@ -75,13 +79,13 @@ fn json() -> Result<(), http_types::Error> {
                 let res = Response::new(StatusCode::Ok).body_json(&counter)?;
                 Ok(res)
             });
-            app.listen("localhost:8082").await?;
+            app.listen(&port).await?;
             Result::<(), http_types::Error>::Ok(())
         });
 
-        let client = task::spawn(async {
+        let client = task::spawn(async move {
             task::sleep(Duration::from_millis(100)).await;
-            let counter: Counter = surf::get("http://localhost:8082")
+            let counter: Counter = surf::get(format!("http://{}", &port))
                 .body_json(&Counter { count: 0 })?
                 .recv_json()
                 .await?;

tests/test_utils.rs

@@ -0,0 +1,7 @@
+pub async fn find_port() -> async_std::net::SocketAddr {
+    async_std::net::TcpListener::bind("localhost:0")
+        .await
+        .unwrap()
+        .local_addr()
+        .unwrap()
+}