asserting 0.15.0

Fluent assertions for tests in Rust that are convenient to write and easy to extend.
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

//! This example demonstrates how to write a custom assertion for a custom
//! struct by reusing existing assertion methods.
//!
//! We define the extension trait `AssertSnake` with the custom assertion method
//! `has_body`. This trait is implemented for `Spec`. The implementation reuses
//! built-in assertions on each field of the snake. In case of failing
//! assertions, the names of the fields are printed with the failure message.
//!
//! The custom assertion method does not fail on the first failure but collects
//! all failures first and then fails, according to the current
//! `FailingStrategy` of the `Spec`.
//!
//! Running the example will print a failed assertion to the console:
//!
//! ```console
//! thread 'main' (28052) panicked at examples\custom_assertion_reusing_existing.rs:122:25:
//! assertion of snake body failed:
//!
//! expected snake.length to be equal to 3
//!    but was: 2
//!   expected: 3
//!
//! expected snake.body to contain exactly in order [Coord { x: 2, y: 1 }, Coord { x: 1, y: 1 }, Coord { x: 1, y: 2 }]
//!        but was: [Coord { x: 2, y: 1 }, Coord { x: 1, y: 2 }, Coord { x: -1, y: 1 }]
//!       expected: [Coord { x: 2, y: 1 }, Coord { x: 1, y: 1 }, Coord { x: 1, y: 2 }]
//!        missing: [Coord { x: 1, y: 1 }]
//!          extra: [Coord { x: -1, y: 1 }]
//!   out-of-order: [Coord { x: 1, y: 2 }]
//!
//! expected snake.head to be equal to Coord { x: 2, y: 1 }
//!    but was: Coord { x: 3, y: 1 }
//!   expected: Coord { x: 2, y: 1 }
//! ```
//!
//! [image of colored output in the console](custom_assertion_reusing_existing.png)

// just to prevent some linter warnings
mod fixture;

use asserting::prelude::*;
use asserting::spec::{FailingStrategy, Spec};
use std::borrow::Borrow;

#[derive(Debug, Clone, Copy, PartialEq)]
struct Coord {
    x: i32,
    y: i32,
}

struct Snake {
    length: usize,
    head: Coord,
    body: Vec<Coord>,
}

/// Custom assertion methods for `Snake`.
trait AssertSnake {
    #[track_caller]
    fn has_body(self, expected_body: &[Coord]) -> Self;
}

// we implement the `AssertSnake` trait for a generic `S: Borrow<Snake>` so that
// the assertion method `has_body` can be called on owned and borrowed `Snake`
// instances.
impl<S, R> AssertSnake for Spec<'_, S, R>
where
    S: Borrow<Snake>,
    R: FailingStrategy,
{
    fn has_body(mut self, expected_body: &[Coord]) -> Self {
        let expected_body = expected_body.to_vec();
        let expected_head = expected_body[0];
        let actual_body = self.subject().borrow();
        // we first collect all failures using the "soft assertion" mode of
        // asserting, which is started by using the `verify_that` function.
        let failures = verify_that(actual_body)
            // `verify_that` does not highlight differences by default, so we
            // switch on highlighting using the configured `DiffFormat`
            .with_configured_diff_format()
            .extracting_ref("length", |s| &s.length)
            .is_equal_to(expected_body.len())
            .and()
            .extracting_ref("body", |s| &s.body)
            .contains_exactly(expected_body)
            .and()
                .extracting_ref("head", |s| &s.head)
                .is_equal_to(expected_head)
                .display_failures();
        // if there are failures, we fail the whole assertion according to the
        // current `FailingStrategy`.
        if !failures.is_empty() {
            self.do_fail_with_message(format!(
                "assertion of snake body failed: \n\n{}",
                failures.join("\n")
            ));
        }
        self
    }
}

fn test() {
    let snake = Snake {
        length: 2,
        head: Coord { x: 3, y: 1 },
        body: vec![
            Coord { x: 2, y: 1 },
            Coord { x: 1, y: 2 },
            Coord { x: -1, y: 1 },
        ],
    };

    assert_that!(snake).has_body(&[
        Coord { x: 2, y: 1 },
        Coord { x: 1, y: 1 },
        Coord { x: 1, y: 2 },
    ]);
}

fn main() {
    test();
}