feat: Support OsStr, Path, etc for args

Fixes assert-rs#59

Author: epage

src/assert.rs

@@ -3,6 +3,7 @@ use error_chain::ChainedError;
 use errors::*;
 use output::{OutputAssertion, OutputKind};
 use std::default;
+use std::ffi::{OsStr, OsString};
 use std::io::Write;
 use std::path::PathBuf;
 use std::process::{Command, Stdio};
@@ -11,7 +12,7 @@ use std::vec::Vec;
 /// Assertions for a specific command.
 #[derive(Debug)]
 pub struct Assert {
-    cmd: Vec<String>,
+    cmd: Vec<OsString>,
     env: Environment,
     current_dir: Option<PathBuf>,
     expect_success: Option<bool>,
@@ -28,7 +29,7 @@ impl default::Default for Assert {
         Assert {
             cmd: vec!["cargo", "run", "--quiet", "--"]
                 .into_iter()
-                .map(String::from)
+                .map(OsString::from)
                 .collect(),
             env: Environment::inherit(),
             current_dir: None,
@@ -51,11 +52,17 @@ impl Assert {
     /// Run a specific binary of the current crate.
     ///
     /// Defaults to asserting _successful_ execution.
-    pub fn cargo_binary(name: &str) -> Self {
+    pub fn cargo_binary<S: AsRef<OsStr>>(name: S) -> Self {
         Assert {
-            cmd: vec!["cargo", "run", "--quiet", "--bin", name, "--"]
-                .into_iter()
-                .map(String::from)
+            cmd: vec![
+                OsStr::new("cargo"),
+                OsStr::new("run"),
+                OsStr::new("--quiet"),
+                OsStr::new("--bin"),
+                name.as_ref(),
+                OsStr::new("--"),
+            ].into_iter()
+                .map(OsString::from)
                 .collect(),
             ..Self::default()
         }
@@ -73,9 +80,9 @@ impl Assert {
     /// assert_cli::Assert::command(&["echo", "1337"])
     ///     .unwrap();
     /// ```
-    pub fn command(cmd: &[&str]) -> Self {
+    pub fn command<S: AsRef<OsStr>>(cmd: &[S]) -> Self {
         Assert {
-            cmd: cmd.into_iter().cloned().map(String::from).collect(),
+            cmd: cmd.into_iter().map(OsString::from).collect(),
             ..Self::default()
         }
     }
@@ -93,8 +100,8 @@ impl Assert {
     ///     .unwrap();
     ///
     /// ```
-    pub fn with_args(mut self, args: &[&str]) -> Self {
-        self.cmd.extend(args.into_iter().cloned().map(String::from));
+    pub fn with_args<S: AsRef<OsStr>>(mut self, args: &[S]) -> Self {
+        self.cmd.extend(args.into_iter().map(OsString::from));
         self
     }
 

src/errors.rs

@@ -1,33 +1,43 @@
+use output;
+use std::ffi::OsString;
+
 const ERROR_PREFIX: &'static str = "CLI assertion failed";
 
+fn format_cmd(cmd: &[OsString]) -> String {
+    let result: Vec<String> = cmd.iter()
+        .map(|s| s.to_string_lossy().into_owned())
+        .collect();
+    result.join(" ")
+}
+
 error_chain! {
     foreign_links {
         Io(::std::io::Error);
         Fmt(::std::fmt::Error);
     }
     errors {
-        SpawnFailed(cmd: Vec<String>) {
+        SpawnFailed(cmd: Vec<OsString>) {
             description("Spawn failed")
             display(
                 "{}: (command `{}` failed to run)",
                 ERROR_PREFIX,
-                cmd.join(" "),
+                format_cmd(cmd),
             )
         }
-        StatusMismatch(cmd: Vec<String>, expected: bool, out: String, err: String) {
+        StatusMismatch(cmd: Vec<OsString>, expected: bool, out: String, err: String) {
             description("Wrong status")
             display(
                 "{}: (command `{}` expected to {})\nstatus={}\nstdout=```{}```\nstderr=```{}```",
                 ERROR_PREFIX,
-                cmd.join(" "),
+                format_cmd(cmd),
                 expected = if *expected { "succeed" } else { "fail" },
                 got = if *expected { "failed" } else { "succeeded" },
                 out = out,
                 err = err,
             )
         }
         ExitCodeMismatch(
-            cmd: Vec<String>,
+            cmd: Vec<OsString>,
             expected: Option<i32>,
             got: Option<i32>,
             out: String,
@@ -40,18 +50,18 @@ error_chain! {
                 stdout=```{stdout}```\n\
                 stderr=```{stderr}```",
                 prefix=ERROR_PREFIX,
-                cmd=cmd.join(" "),
+                cmd=format_cmd(cmd),
                 expected=expected,
                 code=got,
                 stdout=out,
                 stderr=err,
             )
         }
-        OutputMismatch(cmd: Vec<String>, output_err: ::output::Error, kind: ::output::OutputKind) {
+        OutputMismatch(cmd: Vec<OsString>, output_err: output::Error, kind: output::OutputKind) {
             description("Output was not as expected")
             display(
                 "{}: `{}` {:?} mismatch: {}",
-                ERROR_PREFIX, cmd.join(" "), kind, output_err,
+                ERROR_PREFIX, format_cmd(cmd), kind, output_err,
             )
         }
 

src/output.rs

@@ -2,6 +2,7 @@ use self::errors::*;
 pub use self::errors::{Error, ErrorKind};
 use diff;
 use difference::Changeset;
+use std::ffi::OsString;
 use std::process::Output;
 
 #[derive(Debug, Clone)]
@@ -49,7 +50,7 @@ impl OutputAssertion {
         Ok(())
     }
 
-    pub fn execute(&self, output: &Output, cmd: &[String]) -> super::errors::Result<()> {
+    pub fn execute(&self, output: &Output, cmd: &[OsString]) -> super::errors::Result<()> {
         let observed = String::from_utf8_lossy(self.kind.select(output));
 
         let result = if self.fuzzy {