Tests, documentation, assert_cmd!

Author: killercup

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "assert_cli"
-version = "0.3.0"
+version = "0.4.0"
 authors = ["Pascal Hertleif <[email protected]>"]
 repository = "https://github.com/killercup/assert_cli.git"
 homepage = "https://github.com/killercup/assert_cli"
@@ -10,15 +10,10 @@ documentation = "http://killercup.github.io/assert_cli/"
 description = "Test CLI Applications."
 build = "build.rs"
 
-[features]
-default = []
-dev = ["clippy"]
-
 [dependencies]
 colored = "1.4"
 difference = "1.0"
 error-chain = "0.10.0"
-clippy = {version = "*", optional = true}
 
 [build-dependencies]
 skeptic = "0.5"

README.md

@@ -15,7 +15,7 @@ Just add it to your `Cargo.toml`:
 
 ```toml
 [dependencies]
-assert_cli = "0.3"
+assert_cli = "0.4"
 ```
 
 ## Example
@@ -24,59 +24,56 @@ Here's a trivial example:
 
 ```rust
 extern crate assert_cli;
+
 fn main() {
-  assert_cli::assert_cli_output("echo", &["42"], "42").unwrap();
+    assert_cli::Assert::command(&["echo", "42"]).prints("42").unwrap();
 }
 ```
 
 Or if you'd rather use the macro:
 
-```rust,ignore
+```rust
 #[macro_use] extern crate assert_cli;
-fn main() {
-  assert_cli!("echo", &["42"] => Success, "42").unwrap();
-  assert_cli!("black-box", &["--special"] => Error 42, "error no 42\n").unwrap()
-}
-```
-
-And here is one that will fail:
 
-```rust,should_panic
-extern crate assert_cli;
 fn main() {
-  assert_cli::assert_cli_output("echo", &["42"], "1337").unwrap();
+    assert_cmd!(echo 42).succeeds().and().prints("42").unwrap();
 }
 ```
 
-this will show a nice, colorful diff in your terminal, like this:
-
-```diff
--1337
-+42
-```
-
-If you'd prefer to not check the output:
+And here is one that will fail (which also shows `execute` which returns a
+`Result` and can be used instead of `unwrap`):
 
 ```rust
 #[macro_use] extern crate assert_cli;
+
 fn main() {
-  assert_cli::assert_cli("echo", &["42"]).unwrap();
-  assert_cli!("echo", &["42"] => Success).unwrap();
+    let test = assert_cmd!(grep amet Cargo.toml)
+        .fails_with(1)
+        .execute();
+    assert!(test.is_err());
 }
 ```
 
-All exported functions and the macro return a `Result` containing the
-`Output` of the process, allowing you to do further custom assertions:
+If you want to check for the program's output, you can use `print` or
+`print_exactly`:
 
-```rust
+```rust,should_panic="Assert CLI failure"
 #[macro_use] extern crate assert_cli;
+
 fn main() {
-  let output = assert_cli!("echo", &["Number 42"] => Success).unwrap();
-  let stdout = std::str::from_utf8(&output.stdout).unwrap();
-  assert!(stdout.contains("42"));
+    assert_cmd!("wc" "README.md")
+        .prints_exactly("1337 README.md")
+        .unwrap();
 }
 ```
 
+this will show a nice, colorful diff in your terminal, like this:
+
+```diff
+-1337
++92
+```
+
 ## License
 
 Licensed under either of

src/diff.rs

@@ -6,27 +6,30 @@ use std::fmt::Write;
 
 use errors::*;
 
-pub fn render(Changeset { diffs, .. }: Changeset) -> Result<String> {
+pub fn render(&Changeset { ref diffs, .. }: &Changeset) -> Result<String> {
     let mut t = String::new();
 
     for i in 0..diffs.len() {
         match diffs[i] {
             Difference::Same(ref x) => {
                 writeln!(t, " {}", x)?;
             }
+            Difference::Rem(ref x) => {
+                writeln!(t, "{}", format!("-{}", x).red())?;
+            }
             Difference::Add(ref x) => {
                 match diffs[i - 1] {
                     Difference::Rem(ref y) => {
                         write!(t, "{}", "+".green())?;
                         let Changeset { diffs, .. } = Changeset::new(y, x, " ");
                         for c in diffs {
                             match c {
-                                Difference::Same(ref z) => {
+                                Difference::Same(ref z) if !z.is_empty() => {
                                     write!(t, "{}", z.green())?;
                                     write!(t, " ")?;
                                 }
-                                Difference::Add(ref z) => {
-                                    write!(t, "{}", z.white().on_green())?;
+                                Difference::Add(ref z) if !z.is_empty() => {
+                                    write!(t, "{}", z.green().reverse())?;
                                     write!(t, " ")?;
                                 }
                                 _ => (),
@@ -39,9 +42,6 @@ pub fn render(Changeset { diffs, .. }: Changeset) -> Result<String> {
                     }
                 };
             }
-            Difference::Rem(ref x) => {
-                writeln!(t, "{}", format!("-{}", x).red())?;
-            }
         }
     }
 
@@ -50,20 +50,19 @@ pub fn render(Changeset { diffs, .. }: Changeset) -> Result<String> {
 
 #[cfg(test)]
 mod tests {
-    use difference::diff;
     use super::*;
 
     #[test]
     fn basic_diff() {
-        let (_, diff) = diff("lol", "yay", "\n");
+        let diff = Changeset::new("lol", "yay", "\n");
+        println!("{}", render(&diff).unwrap());
         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")
+                   " \n\u{1b}[31m-lol\u{1b}[0m\n\u{1b}[32m+\u{1b}[0m\u{1b}[7;32myay\u{1b}[0m \n")
     }
 
     #[test]
     fn multiline_diff() {
-        let (_, diff) = diff("Lorem ipsum dolor sit amet, consectetur adipisicing elit,
+        let diff = Changeset::new("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.",
@@ -72,6 +71,7 @@ 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");
+        println!("{}", render(&diff).unwrap());
+        assert_eq!(render(&diff).unwrap(), " Lorem ipsum dolor sit amet, consectetur adipisicing elit,\n\u{1b}[31m-sed 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\u{1b}[0m \u{1b}[7;32m**incididunt**\u{1b}[0m \u{1b}[32mut labore et dolore magna\u{1b}[0m \n aliqua. Ut enim ad minim veniam, quis nostrud exercitation\nullamco laboris nisi ut aliquip ex ea commodo consequat.\n");
     }
 }

src/errors.rs

@@ -3,4 +3,34 @@ error_chain! {
         Io(::std::io::Error);
         Fmt(::std::fmt::Error);
     }
+    errors {
+        StatusMismatch(cmd: Vec<String>, expected: bool) {
+            description("Wrong status")
+            display(
+                "Command {:?} {got} but expected it to {expected}",
+                cmd.join(" "),
+                got = if *expected { "failed" } else { "succeed" },
+                expected = if *expected { "succeed" } else { "failed" },
+            )
+        }
+        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,
+            )
+        }
+        OutputMismatch(expected: String, got: String) {
+            description("Output was not as expected")
+            display(
+                "Expected output to contain\n{}\nbut could not find it in\n{}",
+                expected,
+                got,
+            )
+        }
+        ExactOutputMismatch(diff: String) {
+            description("Output was not as expected")
+            display("{}", diff)
+        }
+    }
 }