refactor(test): Use sync channel over sleeping to be less racy

binary-install/tests/all/cache.rs

@@ -32,7 +32,7 @@ fn it_downloads_tarball() {
     let tarball = utils::create_tarball(binary_name).ok();
 
     // Spin up a local TcpListener.
-    utils::start_server(server_port, tarball);
+    utils::start_server(server_port, tarball).recv().unwrap();
 
     let dir = tempfile::TempDir::new().unwrap();
     let cache = Cache::at(dir.path());
@@ -80,7 +80,7 @@ fn it_returns_error_when_it_failed_to_extract_tarball() {
     let full_url = &format!("{}/{}.tar.gz", &url, binary_name);
 
     // Spin up a local TcpListener.
-    utils::start_server(server_port, None);
+    utils::start_server(server_port, None).recv().unwrap();
 
     let dl = cache.download(true, binary_name, &binaries, full_url);
 
@@ -103,7 +103,7 @@ fn it_returns_error_when_it_failed_to_extract_zip() {
     let full_url = &format!("{}/{}.zip", &url, binary_name);
 
     // Spin up a local TcpListener.
-    utils::start_server(server_port, None);
+    utils::start_server(server_port, None).recv().unwrap();
 
     let dl = cache.download(true, binary_name, &binaries, full_url);
 
@@ -127,7 +127,7 @@ fn it_panics_if_not_tarball_or_zip() {
     let full_url = &format!("{}/{}.bin", &url, binary_name);
 
     // Spin up a local TcpListener.
-    utils::start_server(server_port, None);
+    utils::start_server(server_port, None).recv().unwrap();
 
     let _ = cache.download(true, binary_name, &binaries, full_url);
 }

binary-install/tests/all/utils/mod.rs

@@ -3,42 +3,44 @@ use flate2::Compression;
 use std::fs::{File, OpenOptions};
 use std::io::{self, Read, Write};
 use std::net::TcpListener;
+use std::sync::mpsc::{channel, Receiver};
 use std::thread;
-use std::time::Duration;
 
 pub const TEST_SERVER_HOST: &'static str = "localhost";
 
-pub fn start_server(port: u32, tarball: Option<Vec<u8>>) -> thread::JoinHandle<TcpListener> {
+pub fn start_server(port: u32, tarball: Option<Vec<u8>>) -> Receiver<()> {
-    let handle = thread::spawn(move || {
+    let (sender, receiver) = channel();
-        let listener = TcpListener::bind(format!("{}:{}", TEST_SERVER_HOST, port)).unwrap();
 
-        for stream in listener.incoming() {
+    thread::spawn(move || {
-            let mut stream = stream.unwrap();
+        TcpListener::bind(format!("{}:{}", TEST_SERVER_HOST, port))
+            .map(|listener| {
+                sender.send(()).unwrap();
 
-            let mut buffer = [0; 512];
+                for stream in listener.incoming() {
+                    let mut stream = stream.unwrap();
 
-            stream.read(&mut buffer).unwrap();
+                    let mut buffer = [0; 512];
 
-            let response = "HTTP/1.1 200 OK\r\n\r\n";
+                    stream.read(&mut buffer).unwrap();
 
-            stream.write(response.as_bytes()).unwrap();
+                    let response = "HTTP/1.1 200 OK\r\n\r\n";
 
-            match tarball.to_owned() {
+                    stream.write(response.as_bytes()).unwrap();
-                Some(tar) => {
-                    stream.write(tar.as_ref()).unwrap();
-                }
-                None => {}
-            }
 
-            stream.flush().unwrap();
+                    match tarball.to_owned() {
-        }
+                        Some(tar) => {
-        listener
+                            stream.write(tar.as_ref()).unwrap();
-    });
+                        }
+                        None => {}
+                    }
 
-    // Wait for server to start...
+                    stream.flush().unwrap();
-    thread::sleep(Duration::from_secs(1));
+                }
+            })
+            .unwrap();
+    });
 
-    handle
+    receiver
 }
 
 pub fn create_tarball(binary_name: &str) -> Result<Vec<u8>, io::Error> {