refactor: Migrate to AssertionError

In doing so, this caught a couple places we weren't providing additional
context to an error.

This does not address the errors returned by the internal string predicates.

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

BREAKING CHANGE: The error type has changed from `failure::Error` to
`assert_cli::AssertionError`.

Author: epage

src/assert.rs

@@ -8,7 +8,6 @@ use std::vec::Vec;
 use environment::Environment;
 use failure;
 use failure::Fail;
-use failure::ResultExt;
 
 use errors::*;
 use output::{Content, Output, OutputKind, OutputPredicate};
@@ -328,7 +327,7 @@ impl Assert {
     ///     .execute();
     /// assert!(test.is_ok());
     /// ```
-    pub fn execute(self) -> Result<()> {
+    pub fn execute(self) -> Result<(), AssertionError> {
         let bin = &self.cmd[0];
 
         let args: Vec<_> = self.cmd.iter().skip(1).collect();
@@ -348,45 +347,51 @@ impl Assert {
 
         let mut spawned = command
             .spawn()
-            .with_context(|_| SpawnError::new(self.cmd.clone()))?;
+            .chain_with(|| AssertionError::new(self.cmd.clone()))?;
 
         if let Some(ref contents) = self.stdin_contents {
             spawned
                 .stdin
                 .as_mut()
                 .expect("Couldn't get mut ref to command stdin")
-                .write_all(contents)?;
+                .write_all(contents)
+                .chain_with(|| AssertionError::new(self.cmd.clone()))?;
         }
-        let output = spawned.wait_with_output()?;
+        let output = spawned
+            .wait_with_output()
+            .chain_with(|| AssertionError::new(self.cmd.clone()))?;
 
         if let Some(expect_success) = self.expect_success {
             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())))?;
+                return Err(
+                    AssertionError::new(self.cmd.clone()).chain(StatusError::new(
+                        actual_success,
+                        output.stdout.clone(),
+                        output.stderr.clone(),
+                    )),
+                )?;
             }
         }
 
         if self.expect_exit_code.is_some() && self.expect_exit_code != output.status.code() {
-            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())))?;
+            return Err(
+                AssertionError::new(self.cmd.clone()).chain(ExitCodeError::new(
+                    self.expect_exit_code,
+                    output.status.code(),
+                    output.stdout.clone(),
+                    output.stderr.clone(),
+                )),
+            );
         }
 
         self.expect_output
             .iter()
             .map(|a| {
                 a.verify(&output)
-                    .with_context(|_| AssertionError::new(self.cmd.clone()))
-                    .map_err(|e| failure::Error::from(e))
+                    .chain_with(|| AssertionError::new(self.cmd.clone()))
             })
-            .collect::<Result<Vec<()>>>()?;
+            .collect::<Result<Vec<()>, AssertionError>>()?;
 
         Ok(())
     }

src/errors.rs

@@ -1,43 +1,97 @@
 use std::ffi;
 use std::fmt;
-use std::result;
+use std::io;
 
 use failure;
 
-pub type Result<T> = result::Result<T, failure::Error>;
-
 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(Fail, Debug)]
-pub struct SpawnError {
-    cmd: Vec<ffi::OsString>,
+pub trait ChainFail {
+    fn chain<E>(self, cause: E) -> Self
+    where
+        E: Into<failure::Error>;
+}
+
+pub trait ResultChainExt<T> {
+    fn chain<C>(self, chainable: C) -> Result<T, C>
+    where
+        C: ChainFail;
+
+    fn chain_with<F, C>(self, chainable: F) -> Result<T, C>
+    where
+        F: FnOnce() -> C,
+        C: ChainFail;
 }
 
-impl SpawnError {
-    pub fn new(cmd: Vec<ffi::OsString>) -> Self {
-        Self { cmd }
+impl<T> ResultChainExt<T> for Result<T, failure::Error> {
+    fn chain<C>(self, chainable: C) -> Result<T, C>
+    where
+        C: ChainFail,
+    {
+        self.map_err(|e| chainable.chain(e))
+    }
+
+    fn chain_with<F, C>(self, chainable: F) -> Result<T, C>
+    where
+        F: FnOnce() -> C,
+        C: ChainFail,
+    {
+        self.map_err(|e| chainable().chain(e))
     }
 }
 
-impl fmt::Display for SpawnError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "Failed to run `{}`", format_cmd(&self.cmd))
+impl<T> ResultChainExt<T> for Result<T, io::Error> {
+    fn chain<C>(self, chainable: C) -> Result<T, C>
+    where
+        C: ChainFail,
+    {
+        self.map_err(|e| chainable.chain(e))
+    }
+
+    fn chain_with<F, C>(self, chainable: F) -> Result<T, C>
+    where
+        F: FnOnce() -> C,
+        C: ChainFail,
+    {
+        self.map_err(|e| chainable().chain(e))
     }
 }
 
-#[derive(Fail, Debug)]
+/// Failure when processing assertions.
+#[derive(Debug)]
 pub struct AssertionError {
     cmd: Vec<ffi::OsString>,
+    cause: Option<failure::Error>,
 }
 
 impl AssertionError {
-    pub fn new(cmd: Vec<ffi::OsString>) -> Self {
-        Self { cmd }
+    pub(crate) fn new(cmd: Vec<ffi::OsString>) -> Self {
+        Self { cmd, cause: None }
+    }
+}
+
+impl failure::Fail for AssertionError {
+    fn cause(&self) -> Option<&failure::Fail> {
+        self.cause.as_ref().map(failure::Error::cause)
+    }
+
+    fn backtrace(&self) -> Option<&failure::Backtrace> {
+        None
+    }
+}
+
+impl ChainFail for AssertionError {
+    fn chain<E>(mut self, error: E) -> Self
+    where
+        E: Into<failure::Error>,
+    {
+        self.cause = Some(error.into());
+        self
     }
 }
 
@@ -47,11 +101,12 @@ impl fmt::Display for AssertionError {
     }
 }
 
-#[derive(Fail, Debug)]
+#[derive(Debug)]
 pub struct StatusError {
     unexpected: bool,
     stdout: Vec<u8>,
     stderr: Vec<u8>,
+    cause: Option<failure::Error>,
 }
 
 impl StatusError {
@@ -60,17 +115,38 @@ impl StatusError {
             unexpected,
             stdout,
             stderr,
+            cause: None,
         }
     }
 }
 
+impl failure::Fail for StatusError {
+    fn cause(&self) -> Option<&failure::Fail> {
+        self.cause.as_ref().map(failure::Error::cause)
+    }
+
+    fn backtrace(&self) -> Option<&failure::Backtrace> {
+        None
+    }
+}
+
+impl ChainFail for StatusError {
+    fn chain<E>(mut self, error: E) -> Self
+    where
+        E: Into<failure::Error>,
+    {
+        self.cause = Some(error.into());
+        self
+    }
+}
+
 impl fmt::Display for StatusError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let out = String::from_utf8_lossy(&self.stdout);
         let err = String::from_utf8_lossy(&self.stderr);
         writeln!(
             f,
-            "Unexpected {} return status",
+            "Unexpected return status: {}",
             if self.unexpected {
                 "success"
             } else {
@@ -82,12 +158,13 @@ impl fmt::Display for StatusError {
     }
 }
 
-#[derive(Fail, Debug)]
+#[derive(Debug)]
 pub struct ExitCodeError {
     expected: Option<i32>,
     got: Option<i32>,
     stdout: Vec<u8>,
     stderr: Vec<u8>,
+    cause: Option<failure::Error>,
 }
 
 impl ExitCodeError {
@@ -97,10 +174,31 @@ impl ExitCodeError {
             got,
             stdout,
             stderr,
+            cause: None,
         }
     }
 }
 
+impl failure::Fail for ExitCodeError {
+    fn cause(&self) -> Option<&failure::Fail> {
+        self.cause.as_ref().map(failure::Error::cause)
+    }
+
+    fn backtrace(&self) -> Option<&failure::Backtrace> {
+        None
+    }
+}
+
+impl ChainFail for ExitCodeError {
+    fn chain<E>(mut self, error: E) -> Self
+    where
+        E: Into<failure::Error>,
+    {
+        self.cause = Some(error.into());
+        self
+    }
+}
+
 impl fmt::Display for ExitCodeError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let out = String::from_utf8_lossy(&self.stdout);

src/lib.rs

@@ -127,6 +127,7 @@ extern crate failure_derive;
 extern crate serde_json;
 
 mod errors;
+pub use errors::AssertionError;
 
 #[macro_use]
 mod macros;