Merge pull request #517 from drager/binary-install-tests

test(binaryinstall): Add initial tests

.appveyor.yml

@@ -17,6 +17,9 @@ build: false
 test_script:
   - cargo test --release --tests --locked
   - cargo test --release --doc
+  - cd binary-install
+  - cargo test
+  - cd ..
 
 before_deploy:
   - ps: |

.travis.yml

@@ -47,7 +47,7 @@ matrix:
     install:
       - *INSTALL_NODE_VIA_NVM
     script:
-    - cargo test --locked
+    - cargo test --all --locked
     - rustup component add rustfmt-preview
     - cargo fmt --version
     - cargo fmt --all -- --check

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();
-        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 dirname = hashed_dirname(url, name);
 
         let destination = self.destination.join(&dirname);
+
         if destination.exists() {
             return Ok(Some(Download { root: destination }));
         }
@@ -270,3 +260,87 @@ 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)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[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,142 @@
+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 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.
+    let server_port = utils::start_server(tarball, None).recv().unwrap();
+
+    let url = format!("http://{}:{}", utils::TEST_SERVER_HOST, server_port);
+
+    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 binary_name = "wasm-pack";
+    let binaries = vec![binary_name];
+
+    let dir = tempfile::TempDir::new().unwrap();
+    let cache = Cache::at(dir.path());
+
+    // Spin up a local TcpListener.
+    let server_port = utils::start_server(None, None).recv().unwrap();
+
+    let url = format!("http://{}:{}", utils::TEST_SERVER_HOST, server_port);
+    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 extract tarball from {}", full_url),
+        &format!("{}", dl.unwrap_err())
+    );
+}
+
+#[test]
+fn it_returns_error_when_it_failed_to_extract_zip() {
+    let binary_name = "wasm-pack";
+    let binaries = vec![binary_name];
+
+    let dir = tempfile::TempDir::new().unwrap();
+    let cache = Cache::at(dir.path());
+
+    // Spin up a local TcpListener.
+    let server_port = utils::start_server(None, None).recv().unwrap();
+
+    let url = format!("http://{}:{}", utils::TEST_SERVER_HOST, server_port);
+    let full_url = &format!("{}/{}.zip", &url, binary_name);
+
+    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 binary_name = "wasm-pack";
+    let binaries = vec![binary_name];
+
+    let dir = tempfile::TempDir::new().unwrap();
+    let cache = Cache::at(dir.path());
+
+    // Spin up a local TcpListener.
+    utils::start_server(None, Some(server_port)).recv().unwrap();
+
+    let url = format!("http://{}:{}", utils::TEST_SERVER_HOST, server_port);
+    let full_url = &format!("{}/{}.bin", &url, binary_name);
+
+    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,125 @@
+use binary_install::Download;
+use std::fs::OpenOptions;
+
+#[test]
+#[cfg(unix)]
+fn it_returns_binary_name_for_unix() {
+    use std::os::unix::fs::OpenOptionsExt;
+
+    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]
+#[cfg(not(windows))]
+fn it_bails_if_not_file_for_unix() {
+    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]
+#[cfg(windows)]
+fn it_bails_if_not_file_for_windows() {
+    let binary_name = "wasm-pack.exe";
+
+    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]
+#[cfg(not(windows))]
+fn it_bails_if_not_executable_for_unix() {
+    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()
+    );
+}
+
+#[test]
+#[cfg(windows)]
+fn it_bails_if_not_executable_for_windows() {
+    let binary_name = "wasm-pack.exe";
+
+    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,79 @@
+use flate2::write::GzEncoder;
+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;
+
+pub const TEST_SERVER_HOST: &'static str = "localhost";
+
+pub fn start_server(tarball: Option<Vec<u8>>, server_port: Option<u16>) -> Receiver<u16> {
+    let (sender, receiver) = channel();
+
+    thread::spawn(move || {
+        TcpListener::bind(format!(
+            "{}:{}",
+            TEST_SERVER_HOST,
+            server_port.unwrap_or_else(|| 0)
+        ))
+        .map(|listener| {
+            sender.send(listener.local_addr().unwrap().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();
+            }
+        })
+        .unwrap();
+    });
+
+    receiver
+}
+
+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)
+}