Added predicates.

Author: DariuszDepta

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "cli-assert"
-version = "0.1.12"
+version = "0.1.12-rc.0"
 authors = ["Dariusz Depta <depta@engos.de>"]
 description = "Testing command-line applications"
 documentation = "https://docs.rs/cli-assert"
@@ -18,4 +18,4 @@ exclude = [
 ]
 
 [dependencies]
-tempfile = "3.24.0"
+tempfile = "3.26.0"

Cargo.toml

@@ -1,5 +1,9 @@
 use crate::utils::bytes_to_str;
 
+type StatusPredicate = Box<dyn Fn(i32) -> bool>;
+
+type StdPredicate = Box<dyn Fn(Vec<u8>) -> bool>;
+
 #[derive(Default)]
 pub struct Assertions {
   /// Flag indicating if the command is expected to complete successfully.
@@ -8,10 +12,16 @@ pub struct Assertions {
   failure: Option<bool>,
   /// Expected status code.
   status: Option<i32>,
+  /// Predicate for status code.
+  status_predicate: Option<StatusPredicate>,
   /// Expected content of `stdout` after executing the command.
   stdout: Option<Vec<u8>>,
+  /// Predicate for stdout.
+  stdout_predicate: Option<StdPredicate>,
   /// Expected content of `stderr` after executing the command.
   stderr: Option<Vec<u8>>,
+  /// Predicate for stderr.
+  stderr_predicate: Option<StdPredicate>,
 }
 
 impl Assertions {
@@ -29,14 +39,26 @@ impl Assertions {
     self.status = Some(code);
   }
 
+  pub fn code_fn(&mut self, predicate: impl Fn(i32) -> bool + 'static) {
+    self.status_predicate = Some(Box::new(predicate));
+  }
+
   pub fn stdout(&mut self, bytes: impl AsRef<[u8]>) {
     self.stdout = Some(bytes.as_ref().to_vec());
   }
 
+  pub fn stdout_fn(&mut self, predicate: impl Fn(Vec<u8>) -> bool + 'static) {
+    self.stdout_predicate = Some(Box::new(predicate));
+  }
+
   pub fn stderr(&mut self, bytes: impl AsRef<[u8]>) {
     self.stderr = Some(bytes.as_ref().to_vec());
   }
 
+  pub fn stderr_fn(&mut self, predicate: impl Fn(Vec<u8>) -> bool + 'static) {
+    self.stderr_predicate = Some(Box::new(predicate));
+  }
+
   /// Checks all assertions.
   pub fn assert(&self, command: &crate::Command) {
     if let Some(true) = self.success {
@@ -56,6 +78,13 @@ impl Assertions {
         panic!("unexpected status");
       }
     }
+    if let Some(predicate) = &self.status_predicate {
+      let actual = command.get_status().code().expect("failed to retrieve status code");
+      if !predicate(actual) {
+        println!("\nunexpected status code: {}", actual);
+        panic!("unexpected status code");
+      }
+    }
     if let Some(expected) = &self.stdout {
       let actual = command.get_stdout_raw();
       if actual != expected {
@@ -64,6 +93,14 @@ impl Assertions {
         panic!("unexpected stdout");
       }
     }
+    if let Some(predicate) = &self.stdout_predicate {
+      let actual = command.get_stdout_raw();
+      if !predicate(actual.into()) {
+        println!("\nunexpected stdout: {:?}\n", actual);
+        println!("\n\nunexpected stdout: {}\n", bytes_to_str(actual));
+        panic!("unexpected stdout");
+      }
+    }
     if let Some(expected) = &self.stderr {
       let actual = command.get_stderr_raw();
       if actual != expected {
@@ -72,5 +109,13 @@ impl Assertions {
         panic!("unexpected stderr");
       }
     }
+    if let Some(predicate) = &self.stderr_predicate {
+      let actual = command.get_stderr_raw();
+      if !predicate(actual.into()) {
+        println!("\nunexpected stderr: {:?}\n", actual);
+        println!("\n\nunexpected stderr: {}\n", bytes_to_str(actual));
+        panic!("unexpected stderr");
+      }
+    }
   }
 }

src/assertions.rs

@@ -84,16 +84,31 @@ impl Command {
     self
   }
 
+  pub fn code_fn(mut self, predicate: impl Fn(i32) -> bool + 'static) -> Self {
+    self.assertions.code_fn(predicate);
+    self
+  }
+
   pub fn stdout(mut self, bytes: impl AsRef<[u8]>) -> Self {
     self.assertions.stdout(bytes);
     self
   }
 
+  pub fn stdout_fn(mut self, predicate: impl Fn(Vec<u8>) -> bool + 'static) -> Self {
+    self.assertions.stdout_fn(predicate);
+    self
+  }
+
   pub fn stderr(mut self, bytes: impl AsRef<[u8]>) -> Self {
     self.assertions.stderr(bytes);
     self
   }
 
+  pub fn stderr_fn(mut self, predicate: impl Fn(Vec<u8>) -> bool + 'static) -> Self {
+    self.assertions.stderr_fn(predicate);
+    self
+  }
+
   pub fn spawn(&mut self) {
     if self.child.is_some() {
       panic!("command is already spawned");

src/command.rs

@@ -2,8 +2,10 @@ mod assertions;
 mod command;
 mod files;
 mod macros;
+mod predicates;
 mod utils;
 
 pub use command::Command;
 pub use files::TmpFile;
+pub use predicates::{and, contains, eq, ge, gt, le, lt, ne, not, or};
 pub use utils::{sleep, PathExt};

src/lib.rs

@@ -0,0 +1,70 @@
+pub fn eq<T>(expected: T) -> impl Fn(T) -> bool
+where
+  T: PartialEq,
+{
+  move |actual: T| expected == actual
+}
+
+pub fn ne<T>(expected: T) -> impl Fn(T) -> bool
+where
+  T: PartialEq,
+{
+  move |actual: T| expected != actual
+}
+
+pub fn ge<T>(expected: T) -> impl Fn(T) -> bool
+where
+  T: PartialOrd,
+{
+  move |actual: T| actual >= expected
+}
+
+pub fn gt<T>(expected: T) -> impl Fn(T) -> bool
+where
+  T: PartialOrd,
+{
+  move |actual: T| actual > expected
+}
+
+pub fn le<T>(expected: T) -> impl Fn(T) -> bool
+where
+  T: PartialOrd,
+{
+  move |actual: T| actual <= expected
+}
+
+pub fn lt<T>(expected: T) -> impl Fn(T) -> bool
+where
+  T: PartialOrd,
+{
+  move |actual: T| actual < expected
+}
+
+pub fn and<T>(a: impl Fn(T) -> bool, b: impl Fn(T) -> bool) -> impl Fn(T) -> bool
+where
+  T: Clone,
+{
+  move |actual: T| a(actual.clone()) && b(actual)
+}
+
+pub fn or<T>(a: impl Fn(T) -> bool, b: impl Fn(T) -> bool) -> impl Fn(T) -> bool
+where
+  T: Clone,
+{
+  move |actual: T| a(actual.clone()) || b(actual)
+}
+
+pub fn not<T>(a: impl Fn(T) -> bool) -> impl Fn(T) -> bool
+where
+  T: Sized,
+{
+  move |actual: T| !a(actual)
+}
+
+pub fn contains<T>(needle: T) -> impl Fn(T) -> bool
+where
+  T: AsRef<[u8]>,
+{
+  let needle = String::from_utf8_lossy(needle.as_ref()).to_string();
+  move |actual: T| String::from_utf8_lossy(actual.as_ref()).contains(&needle)
+}