xpct 0.5.1

An extensible test assertion library
Documentation 
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

use std::fmt;

use crate::core::{Matcher, NegFormat};
use crate::matchers::result::BeOkMatcher;

use super::ExpectationFormat;

fn result_format<T, E>() -> ExpectationFormat<Result<T, E>> {
    ExpectationFormat::new("to be Ok(_)", "to be Err(_)")
}

/// Succeeds when the actual value is [`Ok`].
///
/// If this matcher succeeds, it unwraps the [`Ok`] value. When negated, it behaves like
/// [`be_err`].
///
/// # Examples
///
/// ```
/// use std::io;
/// use xpct::{expect, equal, be_ok};
///
/// fn might_fail() -> io::Result<String> {
///     Ok(String::from("foobar"))
/// }
///
/// expect!(might_fail())
///     .to(be_ok())
///     .to(equal("foobar"));
/// ```
pub fn be_ok<'a, T, E>() -> Matcher<'a, Result<T, E>, T, E>
where
    T: fmt::Debug + 'a,
    E: fmt::Debug + 'a,
{
    Matcher::transform(BeOkMatcher::new(), result_format())
}

/// Succeeds when the actual value is [`Err`].
///
/// If this matcher succeeds, it unwraps the [`Err`] value. When negated, it behaves like
/// [`be_ok`].
///
/// # Examples
///
/// ```
/// use std::io;
/// use xpct::{expect, equal, be_err};
///
/// fn might_fail() -> io::Result<()> {
///     Err(io::Error::new(io::ErrorKind::Other, "something bad happened"))
/// }
///
/// expect!(might_fail())
///     .to(be_err())
///     .map(|err| err.kind())
///     .to(equal(io::ErrorKind::Other));
/// ```
pub fn be_err<'a, T, E>() -> Matcher<'a, Result<T, E>, E, T>
where
    T: fmt::Debug + 'a,
    E: fmt::Debug + 'a,
{
    Matcher::transform_neg(BeOkMatcher::new(), NegFormat(result_format()))
}

#[cfg(test)]
mod tests {
    use super::{be_err, be_ok};
    use crate::expect;

    fn ok() -> Result<(), ()> {
        Ok(())
    }

    fn err() -> Result<(), ()> {
        Err(())
    }

    #[test]
    fn succeeds_when_ok() {
        expect!(ok()).to(be_ok());
    }

    #[test]
    fn succeeds_when_not_ok() {
        expect!(err()).to_not(be_ok());
    }

    #[test]
    #[should_panic]
    fn fails_when_ok() {
        expect!(ok()).to_not(be_ok());
    }

    #[test]
    #[should_panic]
    fn fails_when_not_ok() {
        expect!(err()).to(be_ok());
    }

    #[test]
    fn succeeds_when_err() {
        expect!(err()).to(be_err());
    }

    #[test]
    fn succeeds_when_not_err() {
        expect!(ok()).to_not(be_err());
    }

    #[test]
    #[should_panic]
    fn fails_when_err() {
        expect!(err()).to_not(be_err());
    }

    #[test]
    #[should_panic]
    fn fails_when_not_err() {
        expect!(ok()).to(be_err());
    }
}