fix: implement assertions for Result for borrowed &Result as well

Author: haraldmaida

src/assertions.rs

@@ -1399,7 +1399,7 @@ pub trait AssertOption {
     fn is_none(self) -> Self;
 }
 
-/// Assert the option value by mapping the subject.
+/// Assert the value of an option by mapping the subject.
 ///
 /// If the option is none, the assertion fails.
 ///
@@ -1433,7 +1433,7 @@ pub trait AssertOptionValue<'a, T, R> {
     fn some(self) -> Spec<'a, T, R>;
 }
 
-/// Assert the borrowed option value by mapping the subject.
+/// Assert the value of a borrowed option by mapping the subject.
 ///
 /// If the option is none, the assertion fails.
 ///
@@ -1508,7 +1508,7 @@ pub trait AssertResult {
     fn is_err(self) -> Self;
 }
 
-/// Assert the result value or error by mapping the subject.
+/// Assert the ok-value or error of a result by mapping the subject.
 ///
 /// # Examples
 ///
@@ -1553,6 +1553,51 @@ pub trait AssertResultValue<'a, T, E, R> {
     fn err(self) -> Spec<'a, E, R>;
 }
 
+/// Assert the ok-value or error of a borrowed result by mapping the subject.
+///
+/// # Examples
+///
+/// ```
+/// use asserting::prelude::*;
+///
+/// let subject: Result<Vec<usize>, String> = Ok(vec![1, 2, 3]);
+/// assert_that!(&subject).ok().is_not_empty();
+///
+/// let subject: Result<u64, String> = Err("te anim adipisici mollit".to_string());
+/// assert_that!(&subject).err().is_equal_to("te anim adipisici mollit");
+/// ```
+pub trait AssertBorrowedResultValue<'a, T, E, R> {
+    /// Maps the subject to the result's ok value.
+    ///
+    /// If the result is an error, this method panics.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use asserting::prelude::*;
+    ///
+    /// let subject: Result<Vec<usize>, String> = Ok(vec![1, 2, 3]);
+    /// assert_that!(&subject).ok().contains_exactly(&[1, 2, 3]);
+    /// ```
+    #[track_caller]
+    fn ok(self) -> Spec<'a, &'a T, R>;
+
+    /// Maps the subject to the result's err value.
+    ///
+    /// If the result is an ok value, this method panics.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use asserting::prelude::*;
+    ///
+    /// let subject: Result<u64, String> = Err("te anim adipisici mollit".to_string());
+    /// assert_that!(&subject).err().is_equal_to("te anim adipisici mollit");
+    /// ```
+    #[track_caller]
+    fn err(self) -> Spec<'a, &'a E, R>;
+}
+
 /// Assert that a subject of some container type holds a value that is equal to
 /// the expected one.
 ///

src/result/mod.rs

@@ -1,7 +1,8 @@
 //! Implementation of assertions for `Result` values.
 
 use crate::assertions::{
-    AssertHasError, AssertHasErrorMessage, AssertHasValue, AssertResult, AssertResultValue,
+    AssertBorrowedResultValue, AssertHasError, AssertHasErrorMessage, AssertHasValue, AssertResult,
+    AssertResultValue,
 };
 use crate::colored::{mark_missing, mark_unexpected};
 use crate::expectations::{HasError, HasValue, IsEqualTo, IsErr, IsOk};
@@ -27,6 +28,21 @@ where
     }
 }
 
+impl<T, E, R> AssertResult for Spec<'_, &Result<T, E>, R>
+where
+    T: Debug,
+    E: Debug,
+    R: FailingStrategy,
+{
+    fn is_ok(self) -> Self {
+        self.expecting(IsOk)
+    }
+
+    fn is_err(self) -> Self {
+        self.expecting(IsErr)
+    }
+}
+
 impl<'a, T, E, R> AssertResultValue<'a, T, E, R> for Spec<'a, Result<T, E>, R>
 where
     T: Debug,
@@ -51,6 +67,30 @@ where
     }
 }
 
+impl<'a, T, E, R> AssertBorrowedResultValue<'a, T, E, R> for Spec<'a, &'a Result<T, E>, R>
+where
+    T: Debug,
+    E: Debug,
+{
+    fn ok(self) -> Spec<'a, &'a T, R> {
+        self.mapping(|subject| match subject {
+            Ok(value) => value,
+            Err(error) => {
+                panic!("assertion failed: expected the subject to be `Ok(_)`, but was `Err({error:?})`")
+            },
+        })
+    }
+
+    fn err(self) -> Spec<'a, &'a E, R> {
+        self.mapping(|subject| match subject {
+            Ok(value) => {
+                panic!("assertion failed: expected the subject to be `Err(_)`, but was `Ok({value:?})`")
+            },
+            Err(error) => error,
+        })
+    }
+}
+
 impl<T, E, X, R> AssertHasValue<X> for Spec<'_, Result<T, E>, R>
 where
     T: PartialEq<X> + Debug,
@@ -63,6 +103,18 @@ where
     }
 }
 
+impl<T, E, X, R> AssertHasValue<X> for Spec<'_, &Result<T, E>, R>
+where
+    T: PartialEq<X> + Debug,
+    E: Debug,
+    X: Debug,
+    R: FailingStrategy,
+{
+    fn has_value(self, expected: X) -> Self {
+        self.expecting(HasValue { expected })
+    }
+}
+
 impl<T, E, X, R> AssertHasError<X> for Spec<'_, Result<T, E>, R>
 where
     T: Debug,
@@ -75,6 +127,18 @@ where
     }
 }
 
+impl<T, E, X, R> AssertHasError<X> for Spec<'_, &Result<T, E>, R>
+where
+    T: Debug,
+    E: PartialEq<X> + Debug,
+    X: Debug,
+    R: FailingStrategy,
+{
+    fn has_error(self, expected: X) -> Self {
+        self.expecting(HasError { expected })
+    }
+}
+
 impl<'a, T, E, X, R> AssertHasErrorMessage<'a, X, R> for Spec<'a, Result<T, E>, R>
 where
     T: Debug,
@@ -95,6 +159,26 @@ where
     }
 }
 
+impl<'a, T, E, X, R> AssertHasErrorMessage<'a, X, R> for Spec<'a, &Result<T, E>, R>
+where
+    T: Debug,
+    E: Display,
+    X: Debug,
+    String: PartialEq<X>,
+    R: FailingStrategy,
+{
+    fn has_error_message(self, expected: X) -> Spec<'a, String, R> {
+        self.mapping(|result| match result {
+            Ok(value) => panic!(
+                r"assertion failed: expected the subject to be `Err(_)` with message {expected:?}, but was `Ok({value:?})`"
+            ),
+            Err(error) => {
+                error.to_string()
+            },
+        }).expecting(IsEqualTo {expected})
+    }
+}
+
 impl<T, E> Expectation<Result<T, E>> for IsOk
 where
     T: Debug,
@@ -143,6 +227,54 @@ where
     }
 }
 
+impl<T, E> Expectation<&Result<T, E>> for IsOk
+where
+    T: Debug,
+    E: Debug,
+{
+    fn test(&mut self, subject: &&Result<T, E>) -> bool {
+        subject.is_ok()
+    }
+
+    fn message(
+        &self,
+        expression: &Expression<'_>,
+        actual: &&Result<T, E>,
+        format: &DiffFormat,
+    ) -> String {
+        let expected = Ok::<_, Unknown>(Unknown);
+        let marked_actual = mark_unexpected(actual, format);
+        let marked_expected = mark_missing(&expected, format);
+        format!(
+            "expected {expression} is {expected:?}\n   but was: {marked_actual}\n  expected: {marked_expected}"
+        )
+    }
+}
+
+impl<T, E> Expectation<&Result<T, E>> for IsErr
+where
+    T: Debug,
+    E: Debug,
+{
+    fn test(&mut self, subject: &&Result<T, E>) -> bool {
+        subject.is_err()
+    }
+
+    fn message(
+        &self,
+        expression: &Expression<'_>,
+        actual: &&Result<T, E>,
+        format: &DiffFormat,
+    ) -> String {
+        let expected = Err::<Unknown, Unknown>(Unknown);
+        let marked_actual = mark_unexpected(actual, format);
+        let marked_expected = mark_missing(&expected, format);
+        format!(
+            "expected {expression} is {expected:?}\n   but was: {marked_actual}\n  expected: {marked_expected}"
+        )
+    }
+}
+
 impl<T, E, X> Expectation<Result<T, E>> for HasValue<X>
 where
     T: PartialEq<X> + Debug,
@@ -168,6 +300,31 @@ where
     }
 }
 
+impl<T, E, X> Expectation<&Result<T, E>> for HasValue<X>
+where
+    T: PartialEq<X> + Debug,
+    E: Debug,
+    X: Debug,
+{
+    fn test(&mut self, subject: &&Result<T, E>) -> bool {
+        subject.as_ref().is_ok_and(|value| value == &self.expected)
+    }
+
+    fn message(
+        &self,
+        expression: &Expression<'_>,
+        actual: &&Result<T, E>,
+        format: &DiffFormat,
+    ) -> String {
+        let expected = &self.expected;
+        let marked_actual = mark_unexpected(actual, format);
+        let marked_expected = mark_missing(&Ok::<_, E>(expected), format);
+        format!(
+            "expected {expression} is ok containing {expected:?}\n   but was: {marked_actual}\n  expected: {marked_expected}"
+        )
+    }
+}
+
 impl<T, E, X> Expectation<Result<T, E>> for HasError<X>
 where
     T: Debug,
@@ -193,5 +350,30 @@ where
     }
 }
 
+impl<T, E, X> Expectation<&Result<T, E>> for HasError<X>
+where
+    T: Debug,
+    E: PartialEq<X> + Debug,
+    X: Debug,
+{
+    fn test(&mut self, subject: &&Result<T, E>) -> bool {
+        subject.as_ref().is_err_and(|err| err == &self.expected)
+    }
+
+    fn message(
+        &self,
+        expression: &Expression<'_>,
+        actual: &&Result<T, E>,
+        format: &DiffFormat,
+    ) -> String {
+        let expected = &self.expected;
+        let marked_actual = mark_unexpected(actual, format);
+        let marked_expected = mark_missing(&Err::<T, _>(expected), format);
+        format!(
+            "expected {expression} is error containing {expected:?}\n   but was: {marked_actual}\n  expected: {marked_expected}"
+        )
+    }
+}
+
 #[cfg(test)]
 mod tests;