refactor(output): Make implementation more expanable.

Move from a `bool` to track the type of output predicate to a stateful
enum.

Author: epage

src/assert.rs

@@ -1,7 +1,7 @@
 use environment::Environment;
 use error_chain::ChainedError;
 use errors::*;
-use output::{OutputAssertion, OutputKind};
+use output::{Output, OutputKind, OutputPredicate};
 use std::default;
 use std::ffi::{OsStr, OsString};
 use std::io::Write;
@@ -18,7 +18,7 @@ pub struct Assert {
     current_dir: Option<PathBuf>,
     expect_success: Option<bool>,
     expect_exit_code: Option<i32>,
-    expect_output: Vec<OutputAssertion>,
+    expect_output: Vec<OutputPredicate>,
     stdin_contents: Option<String>,
 }
 
@@ -289,7 +289,6 @@ impl Assert {
         OutputAssertionBuilder {
             assertion: self,
             kind: OutputKind::StdOut,
-            expected_result: true,
         }
     }
 
@@ -310,7 +309,6 @@ impl Assert {
         OutputAssertionBuilder {
             assertion: self,
             kind: OutputKind::StdErr,
-            expected_result: true,
         }
     }
 
@@ -327,10 +325,10 @@ impl Assert {
     /// assert!(test.is_ok());
     /// ```
     pub fn execute(self) -> Result<()> {
-        let cmd = &self.cmd[0];
+        let bin = &self.cmd[0];
 
         let args: Vec<_> = self.cmd.iter().skip(1).collect();
-        let mut command = Command::new(cmd);
+        let mut command = Command::new(bin);
         let command = command
             .stdin(Stdio::piped())
             .stdout(Stdio::piped())
@@ -361,30 +359,23 @@ impl Assert {
             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();
-                bail!(ErrorKind::StatusMismatch(
-                    self.cmd.clone(),
-                    expect_success,
-                    out,
-                    err,
-                ));
+                let err: Error = ErrorKind::StatusMismatch(expect_success, out, err).into();
+                bail!(err.chain_err(|| ErrorKind::AssertionFailed(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();
-            bail!(ErrorKind::ExitCodeMismatch(
-                self.cmd.clone(),
-                self.expect_exit_code,
-                output.status.code(),
-                out,
-                err,
-            ));
+            let err: Error =
+                ErrorKind::ExitCodeMismatch(self.expect_exit_code, output.status.code(), out, err)
+                    .into();
+            bail!(err.chain_err(|| ErrorKind::AssertionFailed(self.cmd.clone())));
         }
 
         self.expect_output
             .iter()
-            .map(|a| a.execute(&output, &self.cmd))
+            .map(|a| a.verify_output(&output).chain_err(|| ErrorKind::AssertionFailed(self.cmd.clone())))
             .collect::<Result<Vec<()>>>()?;
 
         Ok(())
@@ -414,28 +405,9 @@ impl Assert {
 pub struct OutputAssertionBuilder {
     assertion: Assert,
     kind: OutputKind,
-    expected_result: bool,
 }
 
 impl OutputAssertionBuilder {
-    /// Negate the assertion predicate
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// extern crate assert_cli;
-    ///
-    /// assert_cli::Assert::command(&["echo", "42"])
-    ///     .stdout().not().contains("73")
-    ///     .unwrap();
-    /// ```
-    // No clippy, we don't want to implement std::ops::Not :)
-    #[cfg_attr(feature = "cargo-clippy", allow(should_implement_trait))]
-    pub fn not(mut self) -> Self {
-        self.expected_result = !self.expected_result;
-        self
-    }
-
     /// Expect the command's output to **contain** `output`.
     ///
     /// # Examples
@@ -448,12 +420,8 @@ impl OutputAssertionBuilder {
     ///     .unwrap();
     /// ```
     pub fn contains<O: Into<String>>(mut self, output: O) -> Assert {
-        self.assertion.expect_output.push(OutputAssertion {
-            expect: output.into(),
-            fuzzy: true,
-            expected_result: self.expected_result,
-            kind: self.kind,
-        });
+        let pred = OutputPredicate::new(self.kind, Output::contains(output));
+        self.assertion.expect_output.push(pred);
         self.assertion
     }
 
@@ -469,12 +437,8 @@ impl OutputAssertionBuilder {
     ///     .unwrap();
     /// ```
     pub fn is<O: Into<String>>(mut self, output: O) -> Assert {
-        self.assertion.expect_output.push(OutputAssertion {
-            expect: output.into(),
-            fuzzy: false,
-            expected_result: self.expected_result,
-            kind: self.kind,
-        });
+        let pred = OutputPredicate::new(self.kind, Output::is(output));
+        self.assertion.expect_output.push(pred);
         self.assertion
     }
 
@@ -489,8 +453,10 @@ impl OutputAssertionBuilder {
     ///     .stdout().doesnt_contain("73")
     ///     .unwrap();
     /// ```
-    pub fn doesnt_contain<O: Into<String>>(self, output: O) -> Assert {
-        self.not().contains(output)
+    pub fn doesnt_contain<O: Into<String>>(mut self, output: O) -> Assert {
+        let pred = OutputPredicate::new(self.kind, Output::doesnt_contain(output));
+        self.assertion.expect_output.push(pred);
+        self.assertion
     }
 
     /// Expect the command to output to not be **exactly** this `output`.
@@ -504,8 +470,10 @@ impl OutputAssertionBuilder {
     ///     .stdout().isnt("73")
     ///     .unwrap();
     /// ```
-    pub fn isnt<O: Into<String>>(self, output: O) -> Assert {
-        self.not().is(output)
+    pub fn isnt<O: Into<String>>(mut self, output: O) -> Assert {
+        let pred = OutputPredicate::new(self.kind, Output::isnt(output));
+        self.assertion.expect_output.push(pred);
+        self.assertion
     }
 }
 
@@ -522,7 +490,7 @@ mod test {
     fn take_ownership() {
         let x = Environment::inherit();
 
-        command().with_env(x.clone()).with_env(&x).with_env(x);
+        command().with_env(x.clone()).with_env(&x).with_env(x).unwrap();
     }
 
     #[test]
@@ -564,8 +532,7 @@ mod test {
         command()
             .with_env(y)
             .stdout()
-            .not()
-            .contains("key=value")
+            .doesnt_contain("key=value")
             .execute()
             .unwrap();
     }

src/errors.rs

@@ -11,6 +11,9 @@ fn format_cmd(cmd: &[OsString]) -> String {
 }
 
 error_chain! {
+    links {
+        Output(output::Error, output::ErrorKind);
+    }
     foreign_links {
         Io(::std::io::Error);
         Fmt(::std::fmt::Error);
@@ -24,46 +27,41 @@ error_chain! {
                 format_cmd(cmd),
             )
         }
-        StatusMismatch(cmd: Vec<OsString>, expected: bool, out: String, err: String) {
-            description("Wrong status")
+        AssertionFailed(cmd: Vec<OsString>) {
+            description("Assertion failed")
             display(
-                "{}: (command `{}` expected to {})\nstatus={}\nstdout=```{}```\nstderr=```{}```",
+                "{}: (command `{}` failed)",
                 ERROR_PREFIX,
                 format_cmd(cmd),
+            )
+        }
+        StatusMismatch(expected: bool, out: String, err: String) {
+            description("Wrong status")
+            display(
+                "Expected to {}\nstatus={}\nstdout=```{}```\nstderr=```{}```",
                 expected = if *expected { "succeed" } else { "fail" },
                 got = if *expected { "failed" } else { "succeeded" },
                 out = out,
                 err = err,
             )
         }
         ExitCodeMismatch(
-            cmd: Vec<OsString>,
             expected: Option<i32>,
             got: Option<i32>,
             out: String,
             err: String
         ) {
             description("Wrong exit code")
             display(
-                "{prefix}: (exit code of `{cmd}` expected to be `{expected:?}`)\n\
+                "Expected exit code to be `{expected:?}`)\n\
                 exit code=`{code:?}`\n\
                 stdout=```{stdout}```\n\
                 stderr=```{stderr}```",
-                prefix=ERROR_PREFIX,
-                cmd=format_cmd(cmd),
                 expected=expected,
                 code=got,
                 stdout=out,
                 stderr=err,
             )
         }
-        OutputMismatch(cmd: Vec<OsString>, output_err: output::Error, kind: output::OutputKind) {
-            description("Output was not as expected")
-            display(
-                "{}: `{}` {:?} mismatch: {}",
-                ERROR_PREFIX, format_cmd(cmd), kind, output_err,
-            )
-        }
-
     }
 }

src/lib.rs

@@ -129,11 +129,10 @@ mod errors;
 mod macros;
 pub use macros::flatten_escaped_string;
 
-mod output;
-
+mod assert;
 mod diff;
+mod output;
 
-mod assert;
 pub use assert::Assert;
 pub use assert::OutputAssertionBuilder;
 /// Environment is a re-export of the Environment crate