rxpect 0.10.0

Extensible fluent expectations for Rust
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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

use crate::{CheckResult, ExpectProjection, Expectation, ExpectationBuilder};
use std::fmt::Debug;

/// Extension trait for equality expectations for iterables
pub trait IterableCountExpectations<'e, B>
where
    B: ExpectationBuilder<'e>,
{
    /// Make expectations on the number of items in the iterable.
    ///
    /// Don't call this on never-ending iterables.
    ///
    /// ```
    /// # use rxpect::expect;
    /// # use rxpect::expectations::iterables::IterableCountExpectations;
    /// # use rxpect::expectations::OrderExpectations;
    ///
    /// let items = vec!["bar", "foo", "foo"];
    /// expect(items).count().to_be_greater_than_or_equal(2);
    /// ```
    /// asserts that `items` contains at least 2 items
    fn count(self) -> impl ExpectationBuilder<'e, Value = usize>
    where
        Self: Sized;

    /// Expect an iterable to not be empty.
    ///
    /// ```
    /// # use rxpect::expect;
    /// # use rxpect::expectations::iterables::IterableCountExpectations;
    ///
    /// let items = vec!["bar", "foo", "foo"];
    /// expect(items).to_not_be_empty();
    /// ```
    /// asserts that `items` contains at least one item
    fn to_not_be_empty(self) -> Self;

    /// Expect an iterable to be empty.
    ///
    /// ```
    /// # use rxpect::expect;
    /// # use rxpect::expectations::iterables::IterableCountExpectations;
    ///
    /// let items: Vec<u8> = vec![];
    /// expect(items).to_be_empty();
    /// ```
    /// asserts that `items` contains no items
    fn to_be_empty(self) -> Self;
}

impl<'e, I, C, B> IterableCountExpectations<'e, B> for B
where
    I: Debug + 'e,
    for<'a> &'a I: IntoIterator<Item = &'a C>,
    C: Debug,
    B: ExpectationBuilder<'e, Value = I>,
{
    fn count(self) -> impl ExpectationBuilder<'e, Value = usize> {
        self.projected_by(|it: &I| Iterator::count(it.into_iter()))
    }

    fn to_not_be_empty(self) -> Self {
        self.to_pass(NotEmptyExpectation {})
    }

    fn to_be_empty(self) -> Self {
        self.to_pass(EmptyExpectation {})
    }
}

struct EmptyExpectation;

impl<I, C> Expectation<I> for EmptyExpectation
where
    I: Debug,
    for<'a> &'a I: IntoIterator<Item = &'a C>,
    C: Debug,
{
    fn check(&self, value: &I) -> CheckResult {
        if value.into_iter().next().is_none() {
            CheckResult::Pass
        } else {
            CheckResult::Fail(
                "Expected iterable to be empty, but it had at least one item".to_string(),
            )
        }
    }
}

struct NotEmptyExpectation;

impl<I, C> Expectation<I> for NotEmptyExpectation
where
    I: Debug,
    for<'a> &'a I: IntoIterator<Item = &'a C>,
    C: Debug,
{
    fn check(&self, value: &I) -> CheckResult {
        if value.into_iter().next().is_some() {
            CheckResult::Pass
        } else {
            CheckResult::Fail("Expected iterable to not be empty, but it was".to_string())
        }
    }
}

#[cfg(test)]
mod tests {
    use super::IterableCountExpectations;
    use crate::expect;
    use crate::expectations::EqualityExpectations;
    use rstest::rstest;

    #[test]
    pub fn that_to_be_empty_accepts_empty_iterable() {
        // Given an empty vector
        let value: Vec<u32> = vec![];

        // Expect to_be_empty to pass
        expect(value).to_be_empty();
    }

    #[test]
    #[should_panic]
    pub fn that_to_be_empty_does_not_accept_non_empty_iterable() {
        // Given a non-empty vector
        let value = vec![1];

        // Expect to_be_empty to fail
        expect(value).to_be_empty();
    }

    #[test]
    pub fn that_to_not_be_empty_accepts_non_empty_iterable() {
        // Given a non-empty vector
        let value = vec![1];

        // Expect to_not_be_empty to pass
        expect(value).to_not_be_empty();
    }

    #[test]
    #[should_panic]
    pub fn that_to_not_be_empty_does_not_accept_empty_iterable() {
        // Given an empty vector
        let value: Vec<u32> = vec![];

        // Expect to_not_be_empty to fail
        expect(value).to_not_be_empty();
    }

    #[rstest]
    #[case(vec![])]
    #[case(vec![1])]
    #[case(vec![1, 2])]
    #[case(vec![1, 2, 3])]
    pub fn that_count_projects_correctly(#[case] items: Vec<u32>) {
        let expected_count = items.len();
        // Expect the count() projection to project the count of the iterable
        expect(items).count().to_equal(expected_count);
    }
}