Merge pull request #1 from killercup/feature/err-and-macro

Assert CLI Error

Author: killercup

Cargo.toml

@@ -16,4 +16,4 @@ dev = ["clippy"]
 [dependencies]
 ansi_term = "0.6.3"
 difference = "0.4.0"
-clippy = {version = "0.0.19", optional = true}
+clippy = {version = "0.0.21", optional = true}

Readme.md

@@ -25,6 +25,14 @@ extern crate assert_cli;
 assert_cli::assert_cli_output("echo", &["42"], "42").unwrap();
 ```
 
+Or if you'd rather use the macro:
+
+```rust,ignore
+#[macro_use] extern crate assert_cli;
+assert_cli!("echo", &["42"] => Success, "42").unwrap();
+assert_cli!("black-box", &["--special"] => Error 42, "error no 42\n").unwrap()
+```
+
 And here is one that will fail:
 
 ```rust,should_panic

src/cli_error.rs

@@ -6,7 +6,7 @@ use std::process::Output;
 use difference::Difference;
 
 pub enum CliError {
-    NoSuccess(Output),
+    WrongExitCode(Output),
     OutputMissmatch(Vec<Difference>),
 }
 
@@ -19,8 +19,8 @@ impl fmt::Display for CliError {
 impl fmt::Debug for CliError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
-            CliError::NoSuccess(ref output) => write!(f,
-                       "Non-success error code {code:?} with this stderr:\n{stderr}",
+            CliError::WrongExitCode(ref output) => write!(f,
+                       "Unexpected error code {code:?} with this stderr:\n{stderr}",
                        code = output.status.code(),
                        stderr = String::from_utf8_lossy(&output.stderr)),
             CliError::OutputMissmatch(ref diff) => {
@@ -37,7 +37,7 @@ impl fmt::Debug for CliError {
 impl Error for CliError {
     fn description(&self) -> &str {
         match *self {
-            CliError::NoSuccess(_) => "Command return non-success error code.",
+            CliError::WrongExitCode(_) => "Command return unexpected error code.",
             CliError::OutputMissmatch(_) => "Command output was not as expected.",
         }
     }

src/lib.rs

@@ -8,14 +8,14 @@
 //! Here's a trivial example:
 //!
 //! ```rust
-//! extern crate assert_cli;
+//! # extern crate assert_cli;
+//!
 //! assert_cli::assert_cli_output("echo", &["42"], "42").unwrap();
 //! ```
 //!
 //! And here is one that will fail:
 //!
 //! ```rust,should_panic
-//! extern crate assert_cli;
 //! assert_cli::assert_cli_output("echo", &["42"], "1337").unwrap();
 //! ```
 //!
@@ -25,6 +25,15 @@
 //! -1337
 //! +42
 //! ```
+//!
+//! Alternatively, you can use the `assert_cli!` macro:
+//!
+//! ```rust,ignore
+//! assert_cli!("echo 42" => Success, "42").unwrap();
+//! ```
+//!
+//! Make sure to include the crate as `#[macro_use] extern crate assert_cli;`.
+
 
 #![cfg_attr(feature = "dev", feature(plugin))]
 #![cfg_attr(feature = "dev", plugin(clippy))]
@@ -48,22 +57,22 @@ use cli_error::CliError;
 /// To test that
 ///
 /// ```sh
-/// ls -n1 src/
+/// bash -c $BLACK_BOX
 /// ```
 ///
 /// returns
 ///
 /// ```plain
-/// cli_error.rs
-/// diff.rs
-/// lib.rs
+/// Launch sequence initiated.
 /// ```
 ///
 /// you would call it like this:
 ///
-/// ```rust,no_run
+/// ```rust
 /// # extern crate assert_cli;
-/// assert_cli::assert_cli_output("ls", &["-n1", "src/"], "cli_error.rs\ndiff.rs\nlib.rs");
+/// # const BLACK_BOX: &'static str = r#"function test_helper() {\
+/// # echo "Launch sequence initiated."; return 0; }; test_helper"#;
+/// assert_cli::assert_cli_output("bash", &["-c", BLACK_BOX], "Launch sequence initiated.");
 /// ```
 pub fn assert_cli_output<S>(cmd: &str, args: &[S], expected_output: &str) -> Result<(), Box<Error>>
     where S: AsRef<OsStr>
@@ -75,7 +84,7 @@ pub fn assert_cli_output<S>(cmd: &str, args: &[S], expected_output: &str) -> Res
 
     call.and_then(|output| {
             if !output.status.success() {
-                return Err(From::from(CliError::NoSuccess(output)));
+                return Err(From::from(CliError::WrongExitCode(output)));
             }
 
             let stdout = String::from_utf8_lossy(&output.stdout);
@@ -90,3 +99,83 @@ pub fn assert_cli_output<S>(cmd: &str, args: &[S], expected_output: &str) -> Res
         })
         .map_err(From::from)
 }
+
+/// Assert a CLI call that fails the expected `stderr` output and error code.
+///
+/// To test that
+///
+/// ```sh
+/// bash -c $BLACK_BOX
+/// ```
+///
+/// fails with an exit code of `42` after printing this to `stderr`
+///
+/// ```plain
+/// error no 42!
+/// ```
+///
+/// you would call it like this:
+///
+/// ```rust
+/// # extern crate assert_cli;
+/// # const BLACK_BOX: &'static str = r#"function test_helper() {\
+/// # >&2 echo "error no 42!"; return 42; }; test_helper"#;
+/// assert_cli::assert_cli_output_error("bash", &["-c", BLACK_BOX], Some(42), "error no 42!");
+/// ```
+pub fn assert_cli_output_error<S>(cmd: &str,
+                                  args: &[S],
+                                  error_code: Option<i32>,
+                                  expected_output: &str)
+                                  -> Result<(), Box<Error>>
+    where S: AsRef<OsStr>
+{
+    let call: Result<Output, Box<Error>> = Command::new(cmd)
+                                               .args(args)
+                                               .output()
+                                               .map_err(From::from);
+
+    call.and_then(|output| {
+            if output.status.success() {
+                return Err(From::from(CliError::WrongExitCode(output)));
+            }
+
+            match (error_code, output.status.code()) {
+                (Some(a), Some(b)) if a != b =>
+                    return Err(From::from(CliError::WrongExitCode(output))),
+                _ => {}
+            }
+
+            let stdout = String::from_utf8_lossy(&output.stderr);
+            let (distance, changes) = difference::diff(expected_output.trim(),
+                                                       &stdout.trim(),
+                                                       "\n");
+            if distance > 0 {
+                return Err(From::from(CliError::OutputMissmatch(changes)));
+            }
+
+            Ok(())
+        })
+        .map_err(From::from)
+}
+
+/// The `assert_cli!` macro combines the functionality of the other functions in this crate in one
+/// short macro.
+///
+/// ```rust,ignore
+/// assert_cli!("echo 42" => Success, "42").unwrap();
+/// assert_cli!("exit 11" => Error 11, "").unwrap();
+/// ```
+///
+/// Make sure to include the crate as `#[macro_use] extern crate assert_cli;`.
+#[macro_export]
+macro_rules! assert_cli {
+    ($cmd:expr, $args:expr => Success, $output:expr) => {{
+        $crate::assert_cli_output($cmd, $args, $output)
+    }};
+    ($cmd:expr, $args:expr => Error, $output:expr) => {{
+        $crate::assert_cli_output_error($cmd, $args, None, $output)
+    }};
+    ($cmd:expr, $args:expr => Error $err:expr, $output:expr) => {{
+        $crate::assert_cli_output_error($cmd, $args, Some($err), $output)
+    }};
+}

tests/macro.rs

@@ -0,0 +1,24 @@
+#[macro_use]
+extern crate assert_cli;
+
+fn test_helper(exit_code: i32, output: &str) -> Vec<String> {
+    vec!["-c".into(),
+         format!(r#"function test_helper() {{ >&2 echo $1; return {}; }}; test_helper "{}""#,
+                 exit_code,
+                 output)]
+}
+
+#[test]
+fn assert_success() {
+    assert_cli!("echo", &["42"] => Success, "42").unwrap();
+    assert!(assert_cli!("echo", &["1"] => Success, "42").is_err());
+}
+
+#[test]
+fn assert_failure() {
+    assert_cli!("bash", &test_helper(66, "sorry, my bad") => Error, "sorry, my bad").unwrap();
+    assert_cli!("bash", &test_helper(42, "error no 42") => Error 42, "error no 42").unwrap();
+
+    assert!(assert_cli!("echo", &["good"] => Error, "").is_err());
+    assert!(assert_cli!("echo", &["good"] => Error 11, "").is_err());
+}