Error Check Fn, NonSuccess → WrongExitCode

Author: killercup

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

@@ -75,7 +75,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 +90,40 @@ pub fn assert_cli_output<S>(cmd: &str, args: &[S], expected_output: &str) -> Res
         })
         .map_err(From::from)
 }
+
+/// Assert a CLI call fails with the expected error code and output.
+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)
+}