refactor: Migrate from Context to Fail

This replaces adding a `Context` per piece of information to bundling
the information up into `Fail`s.  The individual `Fail`s are chained
using `Context` / `Error` rather than writing my own chaining logic.

The information is now reported in a more sane order.

Example:
```
Assertion failed for 'wc README.md'
with: Unexpected failure return status
stdout=''''''
stderr='''wc: README.md: No such file or directory
'''
```

Author: epage

src/assert.rs

@@ -7,6 +7,7 @@ use std::vec::Vec;
 
 use environment::Environment;
 use failure;
+use failure::Fail;
 use failure::ResultExt;
 
 use errors::*;
@@ -345,7 +346,9 @@ impl Assert {
             None => command,
         };
 
-        let mut spawned = command.spawn().context(AssertionKind::Spawn)?;
+        let mut spawned = command
+            .spawn()
+            .with_context(|_| SpawnError::new(self.cmd.clone()))?;
 
         if let Some(ref contents) = self.stdin_contents {
             spawned
@@ -357,43 +360,30 @@ impl Assert {
         let output = spawned.wait_with_output()?;
 
         if let Some(expect_success) = self.expect_success {
-            if expect_success != output.status.success() {
-                let out = String::from_utf8_lossy(&output.stdout).to_string();
-                let err = String::from_utf8_lossy(&output.stderr).to_string();
-                Err(AssertionError::new(AssertionKind::StatusMismatch))
-                    .context(if expect_success {
-                        "expected to succeed"
-                    } else {
-                        "expected to fail"
-                    })
-                    .context(KeyValueDisplay::new("stdout", QuotedDisplay::new(out)))
-                    .context(KeyValueDisplay::new("stderr", QuotedDisplay::new(err)))
-                    .with_context(|_| KeyValueDisplay::new("command", format!("{:?}", command)))?;
+            let actual_success = output.status.success();
+            if expect_success != actual_success {
+                Err(failure::Context::new(StatusError::new(
+                    actual_success,
+                    output.stdout.clone(),
+                    output.stderr.clone(),
+                )).context(AssertionError::new(self.cmd.clone())))?;
             }
         }
 
         if self.expect_exit_code.is_some() && self.expect_exit_code != output.status.code() {
-            let out = String::from_utf8_lossy(&output.stdout).to_string();
-            let err = String::from_utf8_lossy(&output.stderr).to_string();
-            Err(AssertionError::new(AssertionKind::ExitCodeMismatch))
-                .context(KeyValueDisplay::new(
-                    "expected",
-                    self.expect_exit_code.expect("is_some already called"),
-                ))
-                .context(KeyValueDisplay::new(
-                    "got",
-                    output.status.code().unwrap_or_default(),
-                ))
-                .context(KeyValueDisplay::new("stdout", QuotedDisplay::new(out)))
-                .context(KeyValueDisplay::new("stderr", QuotedDisplay::new(err)))
-                .with_context(|_| KeyValueDisplay::new("command", format!("{:?}", command)))?;
+            Err(failure::Context::new(ExitCodeError::new(
+                self.expect_exit_code,
+                output.status.code(),
+                output.stdout.clone(),
+                output.stderr.clone(),
+            )).context(AssertionError::new(self.cmd.clone())))?;
         }
 
         self.expect_output
             .iter()
             .map(|a| {
                 a.verify(&output)
-                    .with_context(|_| KeyValueDisplay::new("command", format!("{:?}", command)))
+                    .with_context(|_| AssertionError::new(self.cmd.clone()))
                     .map_err(|e| failure::Error::from(e))
             })
             .collect::<Result<Vec<()>>>()?;

src/errors.rs

@@ -1,154 +1,113 @@
+use std::ffi;
 use std::fmt;
 use std::result;
 
 use failure;
 
 pub type Result<T> = result::Result<T, failure::Error>;
 
-#[derive(Copy, Clone, Eq, PartialEq, Debug, Fail)]
-pub enum AssertionKind {
-    #[fail(display = "Spawn failed.")] Spawn,
-    #[fail(display = "Status mismatch.")] StatusMismatch,
-    #[fail(display = "Exit code mismatch.")] ExitCodeMismatch,
-    #[fail(display = "Output mismatch.")] OutputMismatch,
+fn format_cmd(cmd: &[ffi::OsString]) -> String {
+    let result: Vec<String> = cmd.iter()
+        .map(|s| s.to_string_lossy().into_owned())
+        .collect();
+    result.join(" ")
 }
 
-#[derive(Debug)]
-pub struct AssertionError {
-    inner: failure::Context<AssertionKind>,
+#[derive(Fail, Debug)]
+pub struct SpawnError {
+    cmd: Vec<ffi::OsString>,
 }
 
-impl AssertionError {
-    pub fn new(kind: AssertionKind) -> Self {
-        Self { inner: kind.into() }
-    }
-
-    pub fn kind(&self) -> AssertionKind {
-        *self.inner.get_context()
-    }
-}
-
-impl failure::Fail for AssertionError {
-    fn cause(&self) -> Option<&failure::Fail> {
-        self.inner.cause()
-    }
-
-    fn backtrace(&self) -> Option<&failure::Backtrace> {
-        self.inner.backtrace()
+impl SpawnError {
+    pub fn new(cmd: Vec<ffi::OsString>) -> Self {
+        Self { cmd }
     }
 }
 
-impl fmt::Display for AssertionError {
+impl fmt::Display for SpawnError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        writeln!(f, "CLI Assertion Error: {}", self.inner)
-    }
-}
-
-impl From<AssertionKind> for AssertionError {
-    fn from(kind: AssertionKind) -> AssertionError {
-        AssertionError {
-            inner: failure::Context::new(kind),
-        }
+        write!(f, "Failed to run `{}`", format_cmd(&self.cmd))
     }
 }
 
-impl From<failure::Context<AssertionKind>> for AssertionError {
-    fn from(inner: failure::Context<AssertionKind>) -> AssertionError {
-        AssertionError { inner: inner }
-    }
-}
-
-#[derive(Debug)]
-pub struct KeyValueDisplay<D>
-where
-    D: fmt::Display + Send + Sync + 'static,
-{
-    key: &'static str,
-    context: D,
+#[derive(Fail, Debug)]
+pub struct AssertionError {
+    cmd: Vec<ffi::OsString>,
 }
 
-impl<D> KeyValueDisplay<D>
-where
-    D: fmt::Display + Send + Sync + 'static,
-{
-    pub fn new(key: &'static str, context: D) -> Self {
-        Self { key, context }
-    }
-
-    pub fn key(&self) -> &str {
-        self.key
-    }
-
-    pub fn context(&self) -> &D {
-        &self.context
+impl AssertionError {
+    pub fn new(cmd: Vec<ffi::OsString>) -> Self {
+        Self { cmd }
     }
 }
 
-impl<D> fmt::Display for KeyValueDisplay<D>
-where
-    D: fmt::Display + Send + Sync + 'static,
-{
+impl fmt::Display for AssertionError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}={}", self.key, self.context)
+        write!(f, "Assertion failed for `{}`", format_cmd(&self.cmd))
     }
 }
 
-#[derive(Debug)]
-pub struct DebugDisplay<D>
-where
-    D: fmt::Debug + Send + Sync + 'static,
-{
-    context: D,
+#[derive(Fail, Debug)]
+pub struct StatusError {
+    unexpected: bool,
+    stdout: Vec<u8>,
+    stderr: Vec<u8>,
 }
 
-impl<D> DebugDisplay<D>
-where
-    D: fmt::Debug + Send + Sync + 'static,
-{
-    pub fn new(context: D) -> Self {
-        Self { context }
-    }
-
-    pub fn context(&self) -> &D {
-        &self.context
+impl StatusError {
+    pub fn new(unexpected: bool, stdout: Vec<u8>, stderr: Vec<u8>) -> Self {
+        Self {
+            unexpected,
+            stdout,
+            stderr,
+        }
     }
 }
 
-impl<D> fmt::Display for DebugDisplay<D>
-where
-    D: fmt::Debug + Send + Sync + 'static,
-{
+impl fmt::Display for StatusError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{:?}", self.context)
-    }
-}
-
-#[derive(Debug)]
-pub struct QuotedDisplay<D>
-where
-    D: fmt::Display + Send + Sync + 'static,
-{
-    context: D,
-}
-
-impl<D> QuotedDisplay<D>
-where
-    D: fmt::Display + Send + Sync + 'static,
-{
-    pub fn new(context: D) -> Self {
-        Self { context }
-    }
-
-    pub fn context(&self) -> &D {
-        &self.context
+        let out = String::from_utf8_lossy(&self.stdout);
+        let err = String::from_utf8_lossy(&self.stderr);
+        writeln!(
+            f,
+            "Unexpected {} return status",
+            if self.unexpected {
+                "success"
+            } else {
+                "failure"
+            }
+        )?;
+        writeln!(f, "stdout=```{}```", out)?;
+        write!(f, "stderr=```{}```", err)
+    }
+}
+
+#[derive(Fail, Debug)]
+pub struct ExitCodeError {
+    expected: Option<i32>,
+    got: Option<i32>,
+    stdout: Vec<u8>,
+    stderr: Vec<u8>,
+}
+
+impl ExitCodeError {
+    pub fn new(expected: Option<i32>, got: Option<i32>, stdout: Vec<u8>, stderr: Vec<u8>) -> Self {
+        Self {
+            expected,
+            got,
+            stdout,
+            stderr,
+        }
     }
 }
 
-impl<D> fmt::Display for QuotedDisplay<D>
-where
-    D: fmt::Display + Send + Sync + 'static,
-{
+impl fmt::Display for ExitCodeError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "```{}```", self.context)
+        let out = String::from_utf8_lossy(&self.stdout);
+        let err = String::from_utf8_lossy(&self.stderr);
+        writeln!(f, "expected={:?}", self.expected)?;
+        writeln!(f, "got={:?}", self.got)?;
+        writeln!(f, "stdout=```{}```", out)?;
+        write!(f, "stderr=```{}```", err)
     }
 }

src/lib.rs

@@ -120,6 +120,7 @@
 extern crate colored;
 extern crate difference;
 extern crate environment;
+#[macro_use]
 extern crate failure;
 #[macro_use]
 extern crate failure_derive;