error formatting

- try to mimic `assert_eq!`
- close #14: try to avoid multiline panics

Author: colin-kiegel

src/errors.rs

@@ -1,3 +1,5 @@
+static ERROR_PREFIX: &'static str = "CLI assertion failed";
+
 error_chain! {
     foreign_links {
         Io(::std::io::Error);
@@ -7,42 +9,60 @@ error_chain! {
         StatusMismatch(cmd: Vec<String>, expected: bool) {
             description("Wrong status")
             display(
-                "Command {:?} {got} but expected it to {expected}",
+                "{}: `(command `{}` expected to {})` (command {})",
+                ERROR_PREFIX,
                 cmd.join(" "),
-                got = if *expected { "failed" } else { "succeed" },
-                expected = if *expected { "succeed" } else { "failed" },
+                expected = if *expected { "succeed" } else { "fail" },
+                got = if *expected { "failed" } else { "succeeded" },
             )
         }
         ExitCodeMismatch(cmd: Vec<String>, expected: Option<i32>, got: Option<i32>) {
             description("Wrong exit code")
             display(
-                "Command {:?} exited with code {:?} but expected it to be {:?}",
-                cmd.join(" "), got, expected,
+                "{}: `(exit code of `{}` expected to be `{:?}`)` (exit code was: `{:?}`)",
+                ERROR_PREFIX,
+                cmd.join(" "),
+                expected,
+                got,
             )
         }
-        OutputMismatch(expected: String, got: String) {
+        OutputMismatch(cmd: Vec<String>, expected: String, got: String) {
             description("Output was not as expected")
             display(
-                "Expected output to contain\n{}\nbut could not find it in\n{}",
+                "{}: `(output of `{}` expected to contain `{:?}`)` (output was: `{:?}`)",
+                ERROR_PREFIX,
+                cmd.join(" "),
                 expected,
                 got,
             )
         }
-        ExactOutputMismatch(diff: String) {
+        ExactOutputMismatch(cmd: Vec<String>, diff: String) {
             description("Output was not as expected")
-            display("{}", diff)
+            display(
+                "{}: `(output of `{}` was not as expected)`\n{}\n",
+                ERROR_PREFIX,
+                cmd.join(" "),
+                diff.trim()
+            )
         }
-        ErrorOutputMismatch(expected: String, got: String) {
+        ErrorOutputMismatch(cmd: Vec<String>, expected: String, got: String) {
             description("Stderr output was not as expected")
             display(
-                "Expected stderr output to contain\n{}\nbut could not find it in\n{}",
+                "{}: `(stderr output of `{}` expected to contain `{:?}`)` (stderr was: `{:?}`)",
+                ERROR_PREFIX,
+                cmd.join(" "),
                 expected,
                 got,
             )
         }
-        ExactErrorOutputMismatch(diff: String) {
+        ExactErrorOutputMismatch(cmd: Vec<String>, diff: String) {
             description("Stderr output was not as expected")
-            display("{}", diff)
+            display(
+                "{}: `(stderr output of `{}` was not as expected)`\n{}\n",
+                ERROR_PREFIX,
+                cmd.join(" "),
+                diff.trim()
+            )
         }
     }
 }

src/lib.rs

@@ -351,6 +351,7 @@ impl Assert {
         match (self.expect_output, self.fuzzy_output) {
             (Some(ref expected_output), true) if !stdout.contains(expected_output) => {
                 bail!(ErrorKind::OutputMismatch(
+                    self.cmd.clone(),
                     expected_output.clone(),
                     stdout.into(),
                 ));
@@ -359,7 +360,7 @@ impl Assert {
                 let differences = Changeset::new(expected_output.trim(), stdout.trim(), "\n");
                 if differences.distance > 0 {
                     let nice_diff = diff::render(&differences)?;
-                    bail!(ErrorKind::ExactOutputMismatch(nice_diff));
+                    bail!(ErrorKind::ExactOutputMismatch(self.cmd.clone(), nice_diff));
                 }
             },
             _ => {},
@@ -369,6 +370,7 @@ impl Assert {
         match (self.expect_error_output, self.fuzzy_error_output) {
             (Some(ref expected_output), true) if !stderr.contains(expected_output) => {
                 bail!(ErrorKind::ErrorOutputMismatch(
+                    self.cmd.clone(),
                     expected_output.clone(),
                     stderr.into(),
                 ));
@@ -377,7 +379,7 @@ impl Assert {
                 let differences = Changeset::new(expected_output.trim(), stderr.trim(), "\n");
                 if differences.distance > 0 {
                     let nice_diff = diff::render(&differences)?;
-                    bail!(ErrorKind::ExactErrorOutputMismatch(nice_diff));
+                    bail!(ErrorKind::ExactErrorOutputMismatch(self.cmd.clone(),nice_diff));
                 }
             },
             _ => {},
@@ -399,7 +401,7 @@ impl Assert {
     /// ```
     pub fn unwrap(self) {
         if let Err(err) = self.execute() {
-            panic!("Assert CLI failure:\n{}", err);
+            panic!("{}", err);
         }
     }
 }