test4a 0.1.1

Testing library that provides some tools to apply "Advanced" Arrange-Act-Assert testing design.
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

//! Defines the type `Message`.

use crate::messages::message_type::MessageType;

const DEFAULT_MESSAGE: &str = "-";

/// Stores messages for successive steps of a test.
///
/// # Examples
///
/// ```rust
/// use test4a::Message;
///
/// fn do_something(message: &mut Message) {
///     message.set("Execution of X");
///     // Execute X
/// }
/// ```
pub struct Message<'a> {
    current_type: MessageType,
    arrange_message: &'a str,
    act_message: &'a str,
    assert_message: &'a str,
}

impl<'a> Message<'a> {
    /// Constructor.
    pub(crate) const fn new() -> Self {
        Self {
            current_type: MessageType::Arrange,
            arrange_message: DEFAULT_MESSAGE,
            act_message: DEFAULT_MESSAGE,
            assert_message: DEFAULT_MESSAGE,
        }
    }

    /// Set the message for the current step of the test.
    pub fn set(&mut self, message: &'a str) {
        match self.current_type {
            MessageType::Arrange => self.arrange_message = message,
            MessageType::Act => self.act_message = message,
            MessageType::Assert => {
                self.assert_message = message;
            }
        }
    }

    /// Get the message corresponding to the Arrange step.
    pub(crate) const fn arrange_message(&self) -> &'a str {
        self.arrange_message
    }

    /// Get the message corresponding to the Act step.
    pub(crate) const fn act_message(&self) -> &'a str {
        self.act_message
    }

    /// Get the message corresponding to the Assert step.
    pub(crate) const fn assert_message(&self) -> &'a str {
        self.assert_message
    }

    /// Set the current step of the test.
    pub(crate) fn set_current_type(&mut self, current_type: MessageType) {
        self.current_type = current_type;
    }
}

#[cfg(test)]
mod tests {
    use crate::messages::message::DEFAULT_MESSAGE;
    use crate::messages::MessageType;
    use crate::Message;

    #[test]
    fn test_new() {
        let message = Message::new();
        assert_eq!(message.arrange_message(), DEFAULT_MESSAGE);
        assert_eq!(message.act_message(), DEFAULT_MESSAGE);
        assert_eq!(message.assert_message(), DEFAULT_MESSAGE);
    }

    #[test]
    fn test_arrange() {
        let mut message = Message::new();
        let arrange_message = "Arrange message example";
        message.set(arrange_message);
        assert_eq!(message.arrange_message(), arrange_message);
        assert_eq!(message.act_message(), DEFAULT_MESSAGE);
        assert_eq!(message.assert_message(), DEFAULT_MESSAGE);
    }

    #[test]
    fn test_act() {
        let mut message = Message::new();
        let act_message = "Act message example";
        message.set_current_type(MessageType::Act);
        message.set(act_message);
        assert_eq!(message.arrange_message(), DEFAULT_MESSAGE);
        assert_eq!(message.act_message(), act_message);
        assert_eq!(message.assert_message(), DEFAULT_MESSAGE);
    }

    #[test]
    fn test_assert() {
        let mut message = Message::new();
        let assert_message = "Assert message example";
        message.set_current_type(MessageType::Assert);
        message.set(assert_message);
        assert_eq!(message.arrange_message(), DEFAULT_MESSAGE);
        assert_eq!(message.act_message(), DEFAULT_MESSAGE);
        assert_eq!(message.assert_message(), assert_message);
    }

    #[test]
    fn test_all() {
        let mut message = Message::new();
        let arrange_message = "Arrange message example";
        let act_message = "Act message example";
        let assert_message = "Assert message example";
        message.set(arrange_message);
        message.set_current_type(MessageType::Act);
        message.set(act_message);
        message.set_current_type(MessageType::Assert);
        message.set(assert_message);
        assert_eq!(message.arrange_message(), arrange_message);
        assert_eq!(message.act_message(), act_message);
        assert_eq!(message.assert_message(), assert_message);
    }

    #[test]
    fn test_all_reversed() {
        let mut message = Message::new();
        let arrange_message = "Arrange message example";
        let act_message = "Act message example";
        let assert_message = "Assert message example";
        message.set_current_type(MessageType::Assert);
        message.set(assert_message);
        message.set_current_type(MessageType::Act);
        message.set(act_message);
        message.set_current_type(MessageType::Arrange);
        message.set(arrange_message);
        assert_eq!(message.arrange_message(), arrange_message);
        assert_eq!(message.act_message(), act_message);
        assert_eq!(message.assert_message(), assert_message);
    }
}