NextGraph
/
wasm-pack
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

tests: Port all of our tests to use `assert_cmd`

Browse Source
master
Nick Fitzgerald 6 years ago committed by Ashley Williams
parent 741bb0107e
commit 5637b07577
5 changed files with 166 additions and 265 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 2
      src/manifest/mod.rs
  2. 123
      tests/all/build.rs
  3. 51
      tests/all/manifest.rs
  4. 238
      tests/all/test.rs
  5. 17
      tests/all/utils/fixture.rs

2
src/manifest/mod.rs
Unescape View File

@ -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
));
});

123
tests/all/build.rs
Unescape View File

@ -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();
}

51
tests/all/manifest.rs
Unescape View File

@ -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, license, manifest, readme, Cli};
use wasm_pack::{self, license, manifest, readme};
#[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,15 +406,17 @@ 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."
));
}
#[test]

238
tests/all/test.rs
Unescape View File

@ -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();
}));
}

17
tests/all/utils/fixture.rs
Unescape View File

@ -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 {

Write Preview
Loading…
Cancel
Save