1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

use crate::*;
use std::fmt::Display;

//TODO: make trait and implement it

impl<T, K> Asserter<&Result<T, K>>
where
    T: PartialEq + Display,
    K: PartialEq + Display,
{
    pub fn is_ok(&self) {
        match &self.value {
            Ok(_) => {}
            Err(val) => {
                panic!(
                    "Expected '{}' to be Ok, but found Err({}).",
                    &self.name, val
                )
            }
        }
    }

    pub fn is_error(&self) {
        match &self.value {
            Ok(val) => {
                panic!(
                    "Expected '{}' to be Err(_), but found Ok({}).",
                    &self.name, val
                )
            }
            Err(_) => {}
        }
    }

    pub fn is_ok_with_value(&self, expected_value: T) {
        match &self.value {
            Ok(val) => {
                if *val != expected_value {
                    panic!(
                        "Expected '{}' to be Ok({}), but found Ok({}).",
                        &self.name, expected_value, val
                    )
                }
            }
            Err(val) => {
                panic!(
                    "Expected '{}' to be Ok({}), but found Err({}).",
                    &self.name, expected_value, val
                )
            }
        }
    }

    pub fn is_error_with_value(&self, expected_value: K) {
        match &self.value {
            Ok(val) => {
                panic!(
                    "Expected '{}' to be Err({}), but found Ok({}).",
                    &self.name, expected_value, val
                )
            }
            Err(val) => {
                if *val != expected_value {
                    panic!(
                        "Expected '{}' to be Err({}), but found Err({}).",
                        &self.name, expected_value, val
                    )
                }
            }
        }
    }
}

//TODO: S - add this to tests folder
#[cfg(test)]
mod test_option_asserter {
    use super::*;

    #[test]
    pub fn test_is_ok() {
        let result: Result<i32, i32> = Ok(3);
        assert_that!(&result).is_ok();

        let error: Result<i32, i32> = Err(3);

        assert_that_code!(|| assert_that!(&error).is_ok())
            .panics()
            .with_message("Expected '&error' to be Ok, but found Err(3).");
    }
    #[test]
    pub fn test_is_ok_with_value() {
        let result_3: Result<i32, i32> = Ok(3);

        assert_that!(&result_3).is_ok_with_value(3);

        assert_that_code!(|| assert_that!(&result_3).is_ok_with_value(5))
            .panics()
            .with_message("Expected '&result_3' to be Ok(5), but found Ok(3).");
    }

    #[test]
    pub fn test_is_ok_with_value_for_error() {
        let error: Result<i32, i32> = Err(3);

        assert_that_code!(|| assert_that!(&error).is_ok_with_value(3))
            .panics()
            .with_message("Expected '&error' to be Ok(3), but found Err(3).");
    }

    #[test]
    pub fn test_is_error() {
        let error: Result<i32, i32> = Err(3);
        assert_that!(&error).is_error();

        let result: Result<i32, i32> = Ok(3);
        assert_that_code!(|| assert_that!(&result).is_error())
            .panics()
            .with_message("Expected '&result' to be Err(_), but found Ok(3).");
    }

    #[test]
    pub fn test_is_error_with_value() {
        let error: Result<i32, i32> = Err(3);
        assert_that!(&error).is_error_with_value(3);

        assert_that_code!(|| assert_that!(&error).is_error_with_value(5))
            .panics()
            .with_message("Expected '&error' to be Err(5), but found Err(3).");
    }

    #[test]
    pub fn test_is_error_with_value_for_ok_result() {
        let result: Result<i32, i32> = Ok(3);

        assert_that_code!(|| assert_that!(&result).is_error_with_value(5))
            .panics()
            .with_message("Expected '&result' to be Err(5), but found Ok(3).");
    }
}