Add --cargo-args

src/cargo.rs

@@ -43,7 +43,7 @@ impl CargoResult {
 
 /// Run one `cargo` subprocess, with a timeout, and with appropriate handling of interrupts.
 pub fn run_cargo(
-    cargo_args: &[&str],
+    cargo_args: &[String],
     in_dir: &Utf8Path,
     log_file: &mut LogFile,
     timeout: Duration,
@@ -61,8 +61,8 @@ pub fn run_cargo(
     // TODO: Maybe this should append instead of overwriting it...?
     env.push(("RUSTFLAGS".into(), "--cap-lints=allow".into()));
 
-    let mut argv: Vec<&str> = vec![&cargo_bin];
-    argv.extend(cargo_args.iter());
+    let mut argv: Vec<String> = vec![cargo_bin];
+    argv.extend(cargo_args.iter().cloned());
     log_file.message(&format!("run {}", argv.join(" "),));
     let mut child = Popen::create(
         &argv,
@@ -112,6 +112,21 @@ fn cargo_bin() -> String {
     env::var("CARGO").unwrap_or_else(|_| "cargo".to_owned())
 }
 
+/// Make up the argv for a cargo check/build/test invocation, not including
+/// the cargo binary itself.
+pub fn cargo_args(phase: Phase, options: &Options) -> Vec<String> {
+    let mut cargo_args = Vec::new();
+    cargo_args.push(phase.name().to_string());
+    if phase == Phase::Check || phase == Phase::Build {
+        cargo_args.push("--tests".to_string());
+    }
+    cargo_args.extend(options.additional_cargo_args.iter().cloned());
+    if phase == Phase::Test {
+        cargo_args.extend(options.additional_cargo_test_args.iter().cloned());
+    }
+    cargo_args
+}
+
 #[cfg(unix)]
 fn terminate_child(mut child: Popen, log_file: &mut LogFile) -> Result<()> {
     use nix::errno::Errno;
@@ -196,3 +211,57 @@ pub fn locate_project(path: &Utf8Path) -> Result<Utf8PathBuf> {
         .parse()
         .context("parse cargo locate-project output root to path")
 }
+
+#[cfg(test)]
+mod test {
+    use pretty_assertions::assert_eq;
+
+    use super::cargo_args;
+    use crate::options::Options;
+    use crate::Phase;
+
+    #[test]
+    fn generate_cargo_args_for_default_options() {
+        let options = Options::default();
+        assert_eq!(cargo_args(Phase::Check, &options), vec!["check", "--tests"]);
+        assert_eq!(cargo_args(Phase::Build, &options), vec!["build", "--tests"]);
+        assert_eq!(cargo_args(Phase::Test, &options), vec!["test"]);
+    }
+
+    #[test]
+    fn generate_cargo_args_with_additional_cargo_test_args() {
+        let mut options = Options::default();
+        options
+            .additional_cargo_test_args
+            .extend(["--lib", "--no-fail-fast"].iter().map(|s| s.to_string()));
+        assert_eq!(cargo_args(Phase::Check, &options), vec!["check", "--tests"]);
+        assert_eq!(cargo_args(Phase::Build, &options), vec!["build", "--tests"]);
+        assert_eq!(
+            cargo_args(Phase::Test, &options),
+            vec!["test", "--lib", "--no-fail-fast"]
+        );
+    }
+
+    #[test]
+    fn generate_cargo_args_with_additional_cargo_args_and_test_args() {
+        let mut options = Options::default();
+        options
+            .additional_cargo_test_args
+            .extend(["--lib", "--no-fail-fast"].iter().map(|s| s.to_string()));
+        options
+            .additional_cargo_args
+            .extend(["--release".to_owned()]);
+        assert_eq!(
+            cargo_args(Phase::Check, &options),
+            vec!["check", "--tests", "--release"]
+        );
+        assert_eq!(
+            cargo_args(Phase::Build, &options),
+            vec!["build", "--tests", "--release"]
+        );
+        assert_eq!(
+            cargo_args(Phase::Test, &options),
+            vec!["test", "--release", "--lib", "--no-fail-fast"]
+        );
+    }
+}

src/lab.rs

@@ -13,7 +13,7 @@ use camino::Utf8Path;
 use rand::prelude::*;
 use serde::Serialize;
 
-use crate::cargo::run_cargo;
+use crate::cargo::{cargo_args, run_cargo};
 use crate::console::{self, plural, Console};
 use crate::mutate::Mutant;
 use crate::outcome::{LabOutcome, Outcome, Phase};
@@ -196,18 +196,7 @@ fn run_cargo_phases(
     for &phase in phases {
         let phase_start = Instant::now();
         console.set_cargo_phase(&phase);
-        let cargo_args = match phase {
-            Phase::Check => vec!["check", "--tests"],
-            Phase::Build => vec!["build", "--tests"],
-            Phase::Test => std::iter::once("test")
-                .chain(
-                    options
-                        .additional_cargo_test_args
-                        .iter()
-                        .map(String::as_str),
-                )
-                .collect(),
-        };
+        let cargo_args = cargo_args(phase, options);
         let timeout = match phase {
             Phase::Test => options.test_timeout(),
             _ => Duration::MAX,

src/main.rs

@@ -122,6 +122,10 @@ struct Args {
     #[argh(switch)]
     version: bool,
 
+    /// additional args for all cargo invocations.
+    #[argh(option)]
+    cargo_arg: Vec<String>,
+
     // The following option captures all the remaining non-option args, to
     // send to cargo.
     /// pass remaining arguments to cargo test after all options and after `--`.

src/options.rs

@@ -34,6 +34,9 @@ pub struct Options {
     /// interesting results.
     pub shuffle: bool,
 
+    /// Additional arguments for every cargo invocation.
+    pub additional_cargo_args: Vec<String>,
+
     /// Additional arguments to `cargo test`.
     pub additional_cargo_test_args: Vec<String>,
 
@@ -86,6 +89,8 @@ impl TryFrom<&Args> for Options {
         };
 
         Ok(Options {
+            additional_cargo_args: args.cargo_arg.clone(),
+            additional_cargo_test_args: args.cargo_test_args.clone(),
             build_source: !args.no_copy_target,
             check_only: args.check,
             copy_target: !args.no_copy_target,
@@ -100,7 +105,6 @@ impl TryFrom<&Args> for Options {
                 .timeout
                 .map(Duration::from_secs_f64)
                 .unwrap_or(Duration::MAX),
-            additional_cargo_test_args: args.cargo_test_args.clone(),
         })
     }
 }

tests/snapshots/cli__small_well_tested_mutants_with_cargo_arg_release.snap

@@ -0,0 +1,10 @@
+---
+source: tests/cli.rs
+expression: stdout
+---
+Freshen source tree ... ok
+Copy source and build products to scratch directory ... done
+Unmutated baseline ... ok
+Found 1 mutant to test
+1 mutant tested: 1 caught
+