From f0b462c73ba630ea5152d93bfcb7130c1eceefbb Mon Sep 17 00:00:00 2001
From: Nick Fitzgerald <fitzgen@gmail.com>
Date: Wed, 23 Jan 2019 16:19:45 -0800
Subject: [PATCH] tests: Port all of our tests to use `assert_cmd`

---
 src/manifest/mod.rs        |   2 +-
 tests/all/build.rs         | 123 +++++++------------
 tests/all/manifest.rs      |  51 ++++----
 tests/all/test.rs          | 238 +++++++++++++++----------------------
 tests/all/utils/fixture.rs |  17 ---
 5 files changed, 166 insertions(+), 265 deletions(-)

diff --git a/src/manifest/mod.rs b/src/manifest/mod.rs
index f61a5df7..f752201e 100644
--- a/src/manifest/mod.rs
+++ b/src/manifest/mod.rs
@@ -294,7 +294,7 @@ impl CrateData {
     pub fn warn_for_unused_keys(manifest_and_keys: &ManifestAndUnsedKeys) {
         manifest_and_keys.unused_keys.iter().for_each(|path| {
             PBAR.warn(&format!(
-                "\"{}\" is a unknown key and will be ignored. Please check your Cargo.toml.",
+                "\"{}\" is an unknown key and will be ignored. Please check your Cargo.toml.",
                 path
             ));
         });
diff --git a/tests/all/build.rs b/tests/all/build.rs
index d4f4debd..be6e1912 100644
--- a/tests/all/build.rs
+++ b/tests/all/build.rs
@@ -1,40 +1,24 @@
+use assert_cmd::prelude::*;
 use std::fs;
 use std::path::Path;
-use structopt::StructOpt;
 use utils;
-use wasm_pack::Cli;
 
 #[test]
 fn build_in_non_crate_directory_doesnt_panic() {
     let fixture = utils::fixture::not_a_crate();
-    let cli = Cli::from_iter_safe(vec![
-        "wasm-pack",
-        "build",
-        &fixture.path.display().to_string(),
-    ])
-    .unwrap();
-    let result = fixture.run(cli.cmd);
-    assert!(
-        result.is_err(),
-        "running wasm-pack in a non-crate directory should fail, but it should not panic"
-    );
-    let err = result.unwrap_err();
-    assert!(err
-        .iter_chain()
-        .any(|e| e.to_string().contains("missing a `Cargo.toml`")));
+    fixture
+        .wasm_pack()
+        .arg("build")
+        .assert()
+        .failure()
+        .stderr(predicates::str::contains("missing a `Cargo.toml`"));
 }
 
 #[test]
 fn it_should_build_js_hello_world_example() {
     let fixture = utils::fixture::js_hello_world();
     fixture.install_local_wasm_bindgen();
-    let cli = Cli::from_iter_safe(vec![
-        "wasm-pack",
-        "build",
-        &fixture.path.display().to_string(),
-    ])
-    .unwrap();
-    fixture.run(cli.cmd).unwrap();
+    fixture.wasm_pack().arg("build").assert().success();
 }
 
 #[test]
@@ -75,15 +59,14 @@ fn it_should_build_crates_in_a_workspace() {
                 #[wasm_bindgen]
                 pub fn hello() -> u32 { 42 }
             "#,
-        );
-    fixture.install_local_wasm_bindgen();
-    let cli = Cli::from_iter_safe(vec![
-        "wasm-pack",
-        "build",
-        &fixture.path.join("blah").display().to_string(),
-    ])
-    .unwrap();
-    fixture.run(cli.cmd).unwrap();
+        )
+        .install_local_wasm_bindgen();
+    fixture
+        .wasm_pack()
+        .current_dir(&fixture.path.join("blah"))
+        .arg("build")
+        .assert()
+        .success();
 }
 
 #[test]
@@ -116,28 +99,21 @@ fn renamed_crate_name_works() {
                 #[wasm_bindgen]
                 pub fn one() -> u32 { 1 }
             "#,
-        );
-    fixture.install_local_wasm_bindgen();
-    let cli = Cli::from_iter_safe(vec![
-        "wasm-pack",
-        "build",
-        &fixture.path.display().to_string(),
-    ])
-    .unwrap();
-    fixture.run(cli.cmd).unwrap();
+        )
+        .install_local_wasm_bindgen();
+    fixture.wasm_pack().arg("build").assert().success();
 }
 
 #[test]
 fn it_should_build_nested_project_with_transitive_dependencies() {
     let fixture = utils::fixture::transitive_dependencies();
     fixture.install_local_wasm_bindgen();
-    let cli = Cli::from_iter_safe(vec![
-        "wasm-pack",
-        "build",
-        &fixture.path.join("main").display().to_string(),
-    ])
-    .unwrap();
-    fixture.run(cli.cmd).unwrap();
+    fixture
+        .wasm_pack()
+        .current_dir(fixture.path.join("main"))
+        .arg("build")
+        .assert()
+        .success();
 }
 
 #[test]
@@ -149,14 +125,12 @@ fn build_different_profiles() {
         .iter()
         .cloned()
     {
-        let cli = Cli::from_iter_safe(vec![
-            "wasm-pack",
-            "build",
-            profile,
-            &fixture.path.display().to_string(),
-        ])
-        .unwrap();
-        fixture.run(cli.cmd).unwrap();
+        fixture
+            .wasm_pack()
+            .arg("build")
+            .arg(profile)
+            .assert()
+            .success();
     }
 }
 
@@ -208,17 +182,15 @@ fn build_with_and_without_wasm_bindgen_debug() {
                     pub fn take(self) {}
                 }
                 "#,
-            );
-
-        let cli = Cli::from_iter_safe(vec![
-            "wasm-pack",
-            "build",
-            "--dev",
-            &fixture.path.display().to_string(),
-        ])
-        .unwrap();
+            )
+            .install_local_wasm_bindgen();
 
-        fixture.run(cli.cmd).unwrap();
+        fixture
+            .wasm_pack()
+            .arg("build")
+            .arg("--dev")
+            .assert()
+            .success();
 
         let contents = fs::read_to_string(fixture.path.join("pkg/whatever.js")).unwrap();
         assert_eq!(
@@ -233,14 +205,11 @@ fn build_with_and_without_wasm_bindgen_debug() {
 fn build_with_arbitrary_cargo_options() {
     let fixture = utils::fixture::js_hello_world();
     fixture.install_local_wasm_bindgen();
-
-    let cli = Cli::from_iter_safe(vec![
-        "wasm-pack",
-        "build",
-        &fixture.path.display().to_string(),
-        "--",
-        "--no-default-features",
-    ])
-    .unwrap();
-    fixture.run(cli.cmd).unwrap();
+    fixture
+        .wasm_pack()
+        .arg("build")
+        .arg("--")
+        .arg("--no-default-features")
+        .assert()
+        .success();
 }
diff --git a/tests/all/manifest.rs b/tests/all/manifest.rs
index b47174b2..53e7ad81 100644
--- a/tests/all/manifest.rs
+++ b/tests/all/manifest.rs
@@ -1,11 +1,9 @@
+use assert_cmd::prelude::*;
 use std::collections::HashSet;
 use std::fs;
 use std::path::PathBuf;
-
-use structopt::StructOpt;
-
 use utils::{self, fixture};
-use wasm_pack::{self, manifest, Cli};
+use wasm_pack::{self, manifest};
 
 #[test]
 fn it_gets_the_crate_name_default_path() {
@@ -370,22 +368,15 @@ fn configure_wasm_bindgen_debug_incorrectly_is_error() {
             debug-js-glue = "not a boolean"
             "#,
     );
-
-    let cli = Cli::from_iter_safe(vec![
-        "wasm-pack",
-        "build",
-        "--dev",
-        &fixture.path.display().to_string(),
-    ])
-    .unwrap();
-
-    let result = fixture.run(cli.cmd);
-    assert!(result.is_err());
-
-    let err = result.unwrap_err();
-    assert!(err.iter_chain().any(|c| c
-        .to_string()
-        .contains("package.metadata.wasm-pack.profile.dev.wasm-bindgen.debug")));
+    fixture
+        .wasm_pack()
+        .arg("build")
+        .arg("--dev")
+        .assert()
+        .failure()
+        .stderr(predicates::str::contains(
+            "package.metadata.wasm-pack.profile.dev.wasm-bindgen.debug",
+        ));
 }
 
 #[test]
@@ -415,13 +406,15 @@ fn parse_crate_data_returns_unused_keys_in_cargo_toml() {
             debug-js-glue = true
             "#,
         )
-        .hello_world_src_lib();
-
-    let result = manifest::CrateData::parse_crate_data(&fixture.path.join("Cargo.toml"));
-
-    assert!(result.is_ok());
-
-    let manifest::ManifestAndUnsedKeys { unused_keys, .. } = result.unwrap();
-
-    assert!(unused_keys.contains("package.metadata.wasm-pack.profile.production"));
+        .hello_world_src_lib()
+        .install_local_wasm_bindgen();
+    fixture
+        .wasm_pack()
+        .arg("build")
+        .assert()
+        .success()
+        .stdout(predicates::str::contains(
+            "[WARN]: \"package.metadata.wasm-pack.profile.production\" is an unknown key and will \
+             be ignored. Please check your Cargo.toml."
+        ));
 }
diff --git a/tests/all/test.rs b/tests/all/test.rs
index b438fcdf..dbe9532e 100644
--- a/tests/all/test.rs
+++ b/tests/all/test.rs
@@ -1,43 +1,32 @@
 use assert_cmd::prelude::*;
-use failure::Error;
 use predicates::prelude::*;
 use std::env;
 use utils::fixture;
-use wasm_pack::command::{build, test, Command};
-
-fn assert_err<T>(result: Result<T, Error>, msg: &str) -> Error {
-    let error = result.err().expect("should have failed");
-    for e in error.iter_chain() {
-        println!("err: {}", e);
-    }
-    assert!(error.iter_chain().any(|e| e.to_string().contains(msg)));
-    error
-}
 
 #[test]
 fn it_can_run_node_tests() {
     let fixture = fixture::wbg_test_node();
     fixture.install_local_wasm_bindgen();
-    let cmd = Command::Test(test::TestOptions {
-        path: Some(fixture.path.clone()),
-        node: true,
-        mode: build::BuildMode::Noinstall,
-        ..Default::default()
-    });
-    fixture.run(cmd).unwrap();
+    let _lock = fixture.lock();
+    fixture
+        .wasm_pack()
+        .arg("test")
+        .arg("--node")
+        .assert()
+        .success();
 }
 
 #[test]
 fn it_can_run_tests_with_different_wbg_test_and_wbg_versions() {
     let fixture = fixture::wbg_test_diff_versions();
     fixture.install_local_wasm_bindgen();
-    let cmd = Command::Test(test::TestOptions {
-        path: Some(fixture.path.clone()),
-        node: true,
-        mode: build::BuildMode::Noinstall,
-        ..Default::default()
-    });
-    fixture.run(cmd).unwrap();
+    let _lock = fixture.lock();
+    fixture
+        .wasm_pack()
+        .arg("test")
+        .arg("--node")
+        .assert()
+        .success();
 }
 
 #[test]
@@ -77,33 +66,37 @@ fn it_can_run_browser_tests() {
         return;
     }
 
-    let cmd = Command::Test(test::TestOptions {
-        path: Some(fixture.path.clone()),
-        firefox,
-        chrome,
-        safari,
-        headless: true,
-        mode: build::BuildMode::Noinstall,
-        ..Default::default()
-    });
-
-    fixture.run(cmd).unwrap();
+    let mut cmd = fixture.wasm_pack();
+    cmd.arg("test").arg("--headless");
+
+    if firefox {
+        cmd.arg("--firefox");
+    }
+    if chrome {
+        cmd.arg("--chrome");
+    }
+    if safari {
+        cmd.arg("--safari");
+    }
+
+    let _lock = fixture.lock();
+    cmd.assert().success();
 }
 
 #[test]
 fn it_can_run_failing_tests() {
     let fixture = fixture::wbg_test_fail();
     fixture.install_local_wasm_bindgen();
-    let cmd = Command::Test(test::TestOptions {
-        path: Some(fixture.path.clone()),
-        node: true,
-        mode: build::BuildMode::Noinstall,
-        ..Default::default()
-    });
-    assert_err(
-        fixture.run(cmd),
-        "Running Wasm tests with wasm-bindgen-test failed",
-    );
+    let _lock = fixture.lock();
+    fixture
+        .wasm_pack()
+        .arg("test")
+        .arg("--node")
+        .assert()
+        .failure()
+        .stderr(predicates::str::contains(
+            "Running Wasm tests with wasm-bindgen-test failed",
+        ));
 }
 
 #[test]
@@ -115,8 +108,6 @@ fn it_can_run_failing_tests() {
     all(target_os = "windows", target_arch = "x86_64")
 ))]
 fn it_can_find_a_webdriver_on_path() {
-    use std::process::Command;
-
     let fixture = fixture::wbg_test_browser();
     let local_geckodriver = fixture.install_local_geckodriver();
     let local_wasm_bindgen = fixture.install_local_wasm_bindgen();
@@ -127,54 +118,44 @@ fn it_can_find_a_webdriver_on_path() {
     let path = env::join_paths(paths).unwrap();
 
     let _lock = fixture.lock();
-
-    let mut me = env::current_exe().unwrap();
-    me.pop();
-    me.pop();
-    me.push("wasm-pack");
-    let output = Command::new(&me)
+    fixture
+        .wasm_pack()
+        .env("PATH", &path)
         .arg("test")
         .arg("--firefox")
         .arg("--headless")
         .arg("--mode")
         .arg("no-install")
-        .env("PATH", &path)
-        .arg(&fixture.path)
-        .output()
-        .unwrap();
-    println!("stdout: {}", String::from_utf8_lossy(&output.stdout));
-    println!("stderr: {}", String::from_utf8_lossy(&output.stderr));
-    println!("status: {}", output.status);
-    assert!(output.status.success());
+        .assert()
+        .success();
 }
 
 #[test]
 fn it_requires_node_or_a_browser() {
     let fixture = fixture::wbg_test_node();
     fixture.install_local_wasm_bindgen();
-
-    let cmd = Command::Test(test::TestOptions {
-        path: Some(fixture.path.clone()),
-        mode: build::BuildMode::Noinstall,
-        // Note: not setting node or any browser to true here.
-        ..Default::default()
-    });
-    assert_err(fixture.run(cmd), "Must specify at least one of");
+    let _lock = fixture.lock();
+    fixture
+        .wasm_pack()
+        .arg("test")
+        .assert()
+        .failure()
+        .stderr(predicates::str::contains("Must specify at least one of"));
 }
 
 #[test]
 fn the_headless_flag_requires_a_browser() {
     let fixture = fixture::wbg_test_node();
     fixture.install_local_wasm_bindgen();
-
-    let cmd = Command::Test(test::TestOptions {
-        path: Some(fixture.path.clone()),
-        node: true,
-        mode: build::BuildMode::Noinstall,
-        headless: true,
-        ..Default::default()
-    });
-    assert_err(fixture.run(cmd), "only applies to browser tests");
+    let _lock = fixture.lock();
+    fixture
+        .wasm_pack()
+        .arg("test")
+        .arg("--node")
+        .arg("--headless")
+        .assert()
+        .failure()
+        .stderr(predicates::str::contains("only applies to browser tests"));
 }
 
 #[test]
@@ -205,44 +186,18 @@ fn complains_about_missing_wasm_bindgen_test_dependency() {
         )
         .hello_world_src_lib()
         .install_local_wasm_bindgen();
-
-    let cmd = Command::Test(test::TestOptions {
-        path: Some(fixture.path.clone()),
-        node: true,
-        mode: build::BuildMode::Noinstall,
-        ..Default::default()
-    });
-    let error = assert_err(fixture.run(cmd), "Ensure that you have");
-
-    // Test that the error message has two occurrences of "wasm-bindgen-test" in
-    // it. I am surprised to learn there is no `str` method to count
-    // occurrences, so we find the first and the last and assert that they
-    // aren't the same occurrence.
-    //
-    // This should protect against regresstions where we said:
-    //
-    //     Ensure that you have "wasm-bindgen" as a dependency in your Cargo.toml file:
-    //     [dev-dependencies]
-    //     wasm-bindgen-test = "0.2"
-    //
-    // instead of
-    //
-    //     Ensure that you have "wasm-bindgen-test" as a dependency in your Cargo.toml file:
-    //     [dev-dependencies]
-    //     wasm-bindgen-test = "0.2"
-    //
-    // Note that the whole reason we are doing this string manipulation instead
-    // of just doing `assert_eq!` is because the first occurrence of the
-    // dependency name is bolded with terminal escape codes and if I try to pipe
-    // the output to a text file, then the escape codes go away, so I can't
-    // figure out which exact escape codes are even used here.
-
-    let err_msg = error.to_string();
-    let first = err_msg.find("wasm-bindgen-test");
-    assert!(first.is_some());
-    let second = err_msg.rfind("wasm-bindgen-test");
-    assert!(second.is_some());
-    assert_ne!(first, second, "should have found two occurrences");
+    let _lock = fixture.lock();
+    fixture
+        .wasm_pack()
+        .arg("test")
+        .arg("--node")
+        .assert()
+        .failure()
+        .stderr(predicates::str::contains(
+            "Ensure that you have \"wasm-bindgen-test\" as a dependency in your Cargo.toml file",
+        ))
+        .stderr(predicates::str::contains("[dev-dependencies]"))
+        .stderr(predicates::str::contains("wasm-bindgen-test = \"0.2\""));
 }
 
 #[test]
@@ -278,15 +233,15 @@ fn renamed_crate_name_works() {
                 #[wasm_bindgen]
                 pub fn one() -> u32 { 1 }
             "#,
-        );
-    fixture.install_local_wasm_bindgen();
-    let cmd = Command::Test(test::TestOptions {
-        path: Some(fixture.path.clone()),
-        node: true,
-        mode: build::BuildMode::Noinstall,
-        ..Default::default()
-    });
-    fixture.run(cmd).unwrap();
+        )
+        .install_local_wasm_bindgen();
+    let _lock = fixture.lock();
+    fixture
+        .wasm_pack()
+        .arg("test")
+        .arg("--node")
+        .assert()
+        .success();
 }
 
 #[test]
@@ -326,15 +281,15 @@ fn cdylib_not_required() {
                     foo::foo();
                 }
             "#,
-        );
-    fixture.install_local_wasm_bindgen();
-    let cmd = Command::Test(test::TestOptions {
-        path: Some(fixture.path.clone()),
-        node: true,
-        mode: build::BuildMode::Noinstall,
-        ..Default::default()
-    });
-    fixture.run(cmd).unwrap();
+        )
+        .install_local_wasm_bindgen();
+    let _lock = fixture.lock();
+    fixture
+        .wasm_pack()
+        .arg("test")
+        .arg("--node")
+        .assert()
+        .success();
 }
 
 #[test]
@@ -342,7 +297,7 @@ fn test_output_is_printed_once() {
     let fixture = fixture::Fixture::new();
     fixture
         .readme()
-        .cargo_toml("wbg-test-node")
+        .cargo_toml("test-output-printed-once")
         .hello_world_src_lib()
         .file(
             "tests/node.rs",
@@ -359,20 +314,21 @@ fn test_output_is_printed_once() {
                 }
 
                 #[wasm_bindgen_test]
-                fn pass() {
+                fn yabba() {
                     log("YABBA DABBA DOO");
                     assert_eq!(1, 2);
                 }
             "#,
-        );
-
+        )
+        .install_local_wasm_bindgen();
+    let _lock = fixture.lock();
     fixture
         .wasm_pack()
         .arg("test")
         .arg("--node")
         .assert()
+        .failure()
         .stderr(predicate::function(|err: &str| {
             err.matches("YABBA DABBA DOO").count() == 1
-        }))
-        .failure();
+        }));
 }
diff --git a/tests/all/utils/fixture.rs b/tests/all/utils/fixture.rs
index f157b9bf..856fd21e 100644
--- a/tests/all/utils/fixture.rs
+++ b/tests/all/utils/fixture.rs
@@ -278,23 +278,6 @@ impl Fixture {
         self
     }
 
-    pub fn run(&self, cmd: wasm_pack::command::Command) -> Result<(), failure::Error> {
-        match cmd {
-            wasm_pack::command::Command::Test(cmd) => {
-                let _lock = self.lock();
-                let mut test = wasm_pack::command::test::Test::try_from_opts(cmd)?;
-                test.set_cache(self.cache());
-                test.run()
-            }
-            wasm_pack::command::Command::Build(cmd) => {
-                let mut build = wasm_pack::command::build::Build::try_from_opts(cmd)?;
-                build.set_cache(self.cache());
-                build.run()
-            }
-            _ => unreachable!(),
-        }
-    }
-
     /// Get a `wasm-pack` command configured to run in this fixure's temp
     /// directory and using the test cache.
     pub fn wasm_pack(&self) -> Command {