test(binaryinstall): Add initial tests

binary-install/Cargo.toml

@@ -18,3 +18,6 @@ is_executable = "0.1.2"
 siphasher = "0.2.3"
 tar = "0.4.16"
 zip = "0.5.0"
+
+[dev-dependencies]
+tempfile = "3.0.5"

binary-install/src/lib.rs

@@ -23,11 +23,13 @@ use std::path::{Path, PathBuf};
 
 /// Global cache for wasm-pack, currently containing binaries downloaded from
 /// urls like wasm-bindgen and such.
+#[derive(Debug)]
 pub struct Cache {
     destination: PathBuf,
 }
 
 /// Representation of a downloaded tarball/zip
+#[derive(Debug)]
 pub struct Download {
     root: PathBuf,
 }
@@ -81,22 +83,10 @@ impl Cache {
         binaries: &[&str],
         url: &str,
     ) -> Result<Option<Download>, Error> {
-        let mut hasher = SipHasher13::new();
+        let dirname = hashed_dirname(url, name);
-        url.hash(&mut hasher);
-        let result = hasher.finish();
-        let hex = hex::encode(&[
-            (result >> 0) as u8,
-            (result >> 8) as u8,
-            (result >> 16) as u8,
-            (result >> 24) as u8,
-            (result >> 32) as u8,
-            (result >> 40) as u8,
-            (result >> 48) as u8,
-            (result >> 56) as u8,
-        ]);
-        let dirname = format!("{}-{}", name, hex);
 
         let destination = self.destination.join(&dirname);
+
         if destination.exists() {
             return Ok(Some(Download { root: destination }));
         }
@@ -270,3 +260,82 @@ fn curl(url: &str) -> Result<Vec<u8>, Error> {
         )
     }
 }
+
+fn hashed_dirname(url: &str, name: &str) -> String {
+    let mut hasher = SipHasher13::new();
+    url.hash(&mut hasher);
+    let result = hasher.finish();
+    let hex = hex::encode(&[
+        (result >> 0) as u8,
+        (result >> 8) as u8,
+        (result >> 16) as u8,
+        (result >> 24) as u8,
+        (result >> 32) as u8,
+        (result >> 40) as u8,
+        (result >> 48) as u8,
+        (result >> 56) as u8,
+    ]);
+    format!("{}-{}", name, hex)
+}
+
+#[test]
+fn it_returns_same_hash_for_same_name_and_url() {
+    let name = "wasm-pack";
+    let url = "http://localhost:7878/wasm-pack-v0.6.0.tar.gz";
+
+    let first = hashed_dirname(url, name);
+    let second = hashed_dirname(url, name);
+
+    assert!(!first.is_empty());
+    assert!(!second.is_empty());
+    assert_eq!(first, second);
+}
+
+#[test]
+fn it_returns_different_hashes_for_different_urls() {
+    let name = "wasm-pack";
+    let url = "http://localhost:7878/wasm-pack-v0.5.1.tar.gz";
+    let second_url = "http://localhost:7878/wasm-pack-v0.6.0.tar.gz";
+
+    let first = hashed_dirname(url, name);
+    let second = hashed_dirname(second_url, name);
+
+    assert_ne!(first, second);
+}
+
+#[test]
+fn it_returns_cache_dir() {
+    let name = "wasm-pack";
+    let cache = Cache::new(name);
+
+    let expected = dirs::cache_dir()
+        .unwrap()
+        .join(PathBuf::from(".".to_owned() + name));
+
+    assert!(cache.is_ok());
+    assert_eq!(cache.unwrap().destination, expected);
+}
+
+#[test]
+fn it_returns_destination_if_binary_already_exists() {
+    use std::fs;
+
+    let binary_name = "wasm-pack";
+    let binaries = vec![binary_name];
+
+    let dir = tempfile::TempDir::new().unwrap();
+    let cache = Cache::at(dir.path());
+    let url = &format!("{}/{}.tar.gz", "http://localhost:7878", binary_name);
+
+    let dirname = hashed_dirname(&url, &binary_name);
+    let full_path = dir.path().join(dirname);
+
+    // Create temporary directory and binary to simulate that
+    // a cached binary already exists.
+    fs::create_dir_all(full_path).unwrap();
+
+    let dl = cache.download(true, binary_name, &binaries, url);
+
+    assert!(dl.is_ok());
+    assert!(dl.unwrap().is_some())
+}

binary-install/tests/all/cache.rs

@@ -0,0 +1,141 @@
+use binary_install::Cache;
+use std::path::Path;
+use utils;
+
+#[test]
+fn it_returns_none_if_install_is_not_permitted() {
+    let binary_name = "wasm-pack";
+    let binaries = vec![binary_name];
+
+    let dir = tempfile::TempDir::new().unwrap();
+    let cache = Cache::at(dir.path());
+
+    let dl = cache.download(
+        false,
+        binary_name,
+        &binaries,
+        &format!("{}/{}.tar.gz", "", binary_name),
+    );
+
+    assert!(dl.is_ok());
+    assert!(dl.unwrap().is_none())
+}
+
+#[test]
+fn it_downloads_tarball() {
+    let server_port = 7880;
+    let url = format!("http://{}:{}", utils::TEST_SERVER_HOST, server_port);
+    let binary_name = "wasm-pack";
+    let binaries = vec![binary_name];
+
+    // Create a temporary tarball.
+    let tarball = utils::create_tarball(binary_name).ok();
+
+    // Spin up a local TcpListener.
+    utils::start_server(server_port, tarball);
+
+    let dir = tempfile::TempDir::new().unwrap();
+    let cache = Cache::at(dir.path());
+
+    let dl = cache.download(
+        true,
+        binary_name,
+        &binaries,
+        &format!("{}/{}.tar.gz", &url, binary_name),
+    );
+
+    assert!(dl.is_ok());
+    assert!(dl.unwrap().is_some())
+}
+
+#[test]
+fn it_returns_error_when_it_failed_to_download() {
+    let server_port = 7881;
+    let url = format!("http://{}:{}", utils::TEST_SERVER_HOST, server_port);
+    let binary_name = "wasm-pack";
+    let binaries = vec![binary_name];
+
+    let dir = tempfile::TempDir::new().unwrap();
+    let cache = Cache::at(dir.path());
+    let full_url = &format!("{}/{}.tar.gz", &url, binary_name);
+
+    let dl = cache.download(true, binary_name, &binaries, full_url);
+
+    assert!(dl.is_err());
+    assert_eq!(
+        &format!("failed to download from {}", full_url),
+        &format!("{}", dl.unwrap_err())
+    );
+}
+
+#[test]
+fn it_returns_error_when_it_failed_to_extract_tarball() {
+    let server_port = 7882;
+    let url = format!("http://{}:{}", utils::TEST_SERVER_HOST, server_port);
+    let binary_name = "wasm-pack";
+    let binaries = vec![binary_name];
+
+    let dir = tempfile::TempDir::new().unwrap();
+    let cache = Cache::at(dir.path());
+    let full_url = &format!("{}/{}.tar.gz", &url, binary_name);
+
+    // Spin up a local TcpListener.
+    utils::start_server(server_port, None);
+
+    let dl = cache.download(true, binary_name, &binaries, full_url);
+
+    assert!(dl.is_err());
+    assert_eq!(
+        &format!("failed to extract tarball from {}", full_url),
+        &format!("{}", dl.unwrap_err())
+    );
+}
+
+#[test]
+fn it_returns_error_when_it_failed_to_extract_zip() {
+    let server_port = 7883;
+    let url = format!("http://{}:{}", utils::TEST_SERVER_HOST, server_port);
+    let binary_name = "wasm-pack";
+    let binaries = vec![binary_name];
+
+    let dir = tempfile::TempDir::new().unwrap();
+    let cache = Cache::at(dir.path());
+    let full_url = &format!("{}/{}.zip", &url, binary_name);
+
+    // Spin up a local TcpListener.
+    utils::start_server(server_port, None);
+
+    let dl = cache.download(true, binary_name, &binaries, full_url);
+
+    assert!(dl.is_err());
+    assert_eq!(
+        &format!("failed to extract zip from {}", full_url),
+        &format!("{}", dl.unwrap_err())
+    );
+}
+
+#[test]
+#[should_panic(expected = "don't know how to extract http://localhost:7884/wasm-pack.bin")]
+fn it_panics_if_not_tarball_or_zip() {
+    let server_port = 7884;
+    let url = format!("http://{}:{}", utils::TEST_SERVER_HOST, server_port);
+    let binary_name = "wasm-pack";
+    let binaries = vec![binary_name];
+
+    let dir = tempfile::TempDir::new().unwrap();
+    let cache = Cache::at(dir.path());
+    let full_url = &format!("{}/{}.bin", &url, binary_name);
+
+    // Spin up a local TcpListener.
+    utils::start_server(server_port, None);
+
+    let _ = cache.download(true, binary_name, &binaries, full_url);
+}
+
+#[test]
+fn it_joins_path_with_destination() {
+    let dir = tempfile::TempDir::new().unwrap();
+    let cache = Cache::at(dir.path());
+
+    assert_eq!(dir.path().join("hello"), cache.join(Path::new("hello")));
+}

binary-install/tests/all/download.rs

@@ -0,0 +1,74 @@
+use binary_install::Download;
+use std::fs::OpenOptions;
+use std::os::unix::fs::OpenOptionsExt;
+
+#[test]
+#[cfg(unix)]
+fn it_returns_binary_name() {
+    let binary_name = "wasm-pack";
+
+    let dir = tempfile::TempDir::new().unwrap();
+    let download = Download::at(dir.path());
+
+    let full_path = dir.path().join(binary_name);
+
+    let mut options = OpenOptions::new();
+    options.create(true);
+    options.write(true);
+
+    // Make the "binary" an executable.
+    options.mode(0o755);
+
+    options.open(&full_path).unwrap();
+
+    let binary = download.binary(binary_name);
+
+    assert!(binary.is_ok());
+    assert_eq!(full_path, binary.unwrap());
+}
+
+#[test]
+fn it_bails_if_not_file() {
+    let binary_name = "wasm-pack";
+
+    let dir = tempfile::TempDir::new().unwrap();
+    let download = Download::at(dir.path());
+
+    let full_path = dir.path().join(binary_name);
+
+    let mut options = OpenOptions::new();
+    options.create(true);
+    options.write(true);
+
+    let binary = download.binary(binary_name);
+
+    assert!(binary.is_err());
+    assert_eq!(
+        format!("{} binary does not exist", full_path.to_str().unwrap()),
+        binary.unwrap_err().to_string()
+    );
+}
+
+#[test]
+fn it_bails_if_not_executable() {
+    let binary_name = "wasm-pack";
+
+    let dir = tempfile::TempDir::new().unwrap();
+    let download = Download::at(dir.path());
+
+    let full_path = dir.path().join(binary_name);
+
+    let mut options = OpenOptions::new();
+    options.create(true);
+    options.write(true);
+
+    options.open(&full_path).unwrap();
+
+    let binary = download.binary(binary_name);
+
+    assert!(binary.is_err());
+    assert_eq!(
+        format!("{} is not executable", full_path.to_str().unwrap()),
+        binary.unwrap_err().to_string()
+    );
+}

binary-install/tests/all/main.rs

@@ -0,0 +1,7 @@
+extern crate binary_install;
+extern crate flate2;
+extern crate tar;
+
+mod cache;
+mod download;
+mod utils;

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

@@ -0,0 +1,73 @@
+use flate2::write::GzEncoder;
+use flate2::Compression;
+use std::fs::{File, OpenOptions};
+use std::io::{self, Read, Write};
+use std::net::TcpListener;
+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> {
+    let handle = thread::spawn(move || {
+        let listener = TcpListener::bind(format!("{}:{}", TEST_SERVER_HOST, port)).unwrap();
+
+        for stream in listener.incoming() {
+            let mut stream = stream.unwrap();
+
+            let mut buffer = [0; 512];
+
+            stream.read(&mut buffer).unwrap();
+
+            let response = "HTTP/1.1 200 OK\r\n\r\n";
+
+            stream.write(response.as_bytes()).unwrap();
+
+            match tarball.to_owned() {
+                Some(tar) => {
+                    stream.write(tar.as_ref()).unwrap();
+                }
+                None => {}
+            }
+
+            stream.flush().unwrap();
+        }
+        listener
+    });
+
+    // Wait for server to start...
+    thread::sleep(Duration::from_secs(1));
+
+    handle
+}
+
+pub fn create_tarball(binary_name: &str) -> Result<Vec<u8>, io::Error> {
+    let temp_dir = tempfile::TempDir::new().unwrap();
+    let full_path = temp_dir.path().join(binary_name.to_owned() + ".tar.gz");
+
+    let tar = OpenOptions::new()
+        .create(true)
+        .read(true)
+        .write(true)
+        .open(&full_path)?;
+
+    let mut file = OpenOptions::new()
+        .create(true)
+        .read(true)
+        .write(true)
+        .open(temp_dir.path().join(binary_name))?;
+
+    let mut encoder = GzEncoder::new(tar, Compression::default());
+    {
+        let mut archive = tar::Builder::new(&mut encoder);
+        archive.append_file(binary_name, &mut file)?;
+    }
+
+    let mut contents = vec![];
+
+    encoder.finish()?;
+
+    File::open(temp_dir.path().join(&full_path))?.read_to_end(&mut contents)?;
+
+    Ok(contents)
+}