feat(assert_output): Basic CLI Output Diff

Author: killercup

src/cli_error.rs

@@ -0,0 +1,44 @@
+use std::error::Error;
+use std::fmt;
+
+use diff::render as render_diff;
+use std::process::Output;
+use difference::Difference;
+
+pub enum CliError {
+    NoSuccess(Output),
+    OutputMissmatch(Vec<Difference>),
+}
+
+impl fmt::Display for CliError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{:?}", self)
+    }
+}
+
+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}",
+                       code = output.status.code(),
+                       stderr = String::from_utf8_lossy(&output.stderr)),
+            CliError::OutputMissmatch(ref diff) => {
+                let diff = match render_diff(&diff) {
+                    Ok(diff) => diff,
+                    Err(_) => return Err(fmt::Error),
+                };
+                write!(f, "Output was not as expected:\n{}", diff)
+            }
+        }
+    }
+}
+
+impl Error for CliError {
+    fn description(&self) -> &str {
+        match *self {
+            CliError::NoSuccess(_) => "Command return non-success error code.",
+            CliError::OutputMissmatch(_) => "Command output was not as expected.",
+        }
+    }
+}

src/diff.rs

@@ -0,0 +1,58 @@
+use std::fmt;
+
+use difference::Difference;
+use ansi_term::Colour::{Green, Red};
+
+pub fn render(changeset: &[Difference]) -> Result<String, fmt::Error> {
+    use std::fmt::Write;
+
+    let mut t = String::new();
+
+    for change in changeset {
+        match *change {
+            Difference::Same(ref x) => {
+                for line in x.lines() {
+                    try!(writeln!(t, " {}", line));
+                }
+            }
+            Difference::Add(ref x) => {
+                try!(write!(t, "{}", Green.paint("+")));
+                try!(writeln!(t, "{}", Green.paint(x)));
+            }
+            Difference::Rem(ref x) => {
+                try!(write!(t, "{}", Red.paint("-")));
+                try!(writeln!(t, "{}", Red.paint(x)));
+            }
+        }
+    }
+
+    Ok(t)
+}
+
+#[cfg(test)]
+mod tests {
+    use difference::diff;
+    use super::*;
+
+    #[test]
+    fn basic_diff() {
+        let (_, diff) = diff("lol", "yay", "\n");
+        assert_eq!(render(&diff).unwrap(),
+                   "\u{1b}[31m-\u{1b}[0m\u{1b}[31mlol\u{1b}[0m\n\u{1b}[32m+\u{1b}[0m\u{1b}[32myay\
+                    \u{1b}[0m\n")
+    }
+
+    #[test]
+    fn multiline_diff() {
+        let (_, diff) = diff("Lorem ipsum dolor sit amet, consectetur adipisicing elit,
+sed do eiusmod tempor incididunt ut labore et dolore magna
+aliqua. Ut enim ad minim veniam, quis nostrud exercitation
+ullamco laboris nisi ut aliquip ex ea commodo consequat.",
+                             "Lorem ipsum dolor sit amet, consectetur adipisicing elit,
+sed do eiusmod tempor **incididunt** ut labore et dolore magna
+aliqua. Ut enim ad minim veniam, quis nostrud exercitation
+ullamco laboris nisi ut aliquip ex ea commodo consequat.",
+                             "\n");
+        assert_eq!(render(&diff).unwrap(), " Lorem ipsum dolor sit amet, consectetur adipisicing elit,\n\u{1b}[31m-\u{1b}[0m\u{1b}[31msed do eiusmod tempor incididunt ut labore et dolore magna\u{1b}[0m\n\u{1b}[32m+\u{1b}[0m\u{1b}[32msed do eiusmod tempor **incididunt** ut labore et dolore magna\u{1b}[0m\n aliqua. Ut enim ad minim veniam, quis nostrud exercitation\n ullamco laboris nisi ut aliquip ex ea commodo consequat.\n");
+    }
+}

src/lib.rs

@@ -1,3 +1,92 @@
-#[test]
-fn it_works() {
+//! # Test CLI Applications
+//!
+//! Currently, this crate only includes basic functionality to check the output of a child process
+//! is as expected.
+//!
+//! ## Example
+//!
+//! Here's a trivial example:
+//!
+//! ```rust
+//! extern crate assert_cli;
+//! assert_cli::assert_cli_output("echo", &["42"], "42").unwrap();
+//! ```
+//!
+//! And here is one that will fail:
+//!
+//! ```rust,should_panic
+//! extern crate assert_cli;
+//! assert_cli::assert_cli_output("echo", &["42"], "1337").unwrap();
+//! ```
+//!
+//! this will show a nice, colorful diff in your terminal, like this:
+//!
+//! ```diff
+//! -1337
+//! +42
+//! ```
+
+#![cfg_attr(feature = "dev", feature(plugin))]
+#![cfg_attr(feature = "dev", plugin(clippy))]
+
+#![deny(missing_docs)]
+
+extern crate ansi_term;
+extern crate difference;
+
+use std::process::{Command, Output};
+use std::error::Error;
+use std::ffi::OsStr;
+
+mod cli_error;
+mod diff;
+
+use cli_error::CliError;
+
+/// Assert a CLI call returns the expected output.
+///
+/// To test that
+///
+/// ```sh
+/// ls -n1 src/
+/// ```
+///
+/// returns
+///
+/// ```plain
+/// cli_error.rs
+/// diff.rs
+/// lib.rs
+/// ```
+///
+/// you would call it like this:
+///
+/// ```rust,no_run
+/// # extern crate assert_cli;
+/// assert_cli::assert_cli_output("ls", &["-n1", "src/"], "cli_error.rs\ndiff.rs\nlib.rs");
+/// ```
+pub fn assert_cli_output<S>(cmd: &str, args: &[S], 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::NoSuccess(output)));
+            }
+
+            let stdout = String::from_utf8_lossy(&output.stdout);
+            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)
 }