konnektoren_core/challenges/
challenge_history.rs

1use serde::{Deserialize, Serialize};
2
3use super::Challenge;
4
5#[derive(Debug, Default, Clone, Serialize, Deserialize, PartialEq)]
6pub struct ChallengeHistory {
7    pub challenges: Vec<Challenge>,
8}
9
10impl ChallengeHistory {
11    pub fn new() -> Self {
12        ChallengeHistory { challenges: vec![] }
13    }
14
15    /// Add a challenge to the history if it is different from the last one.
16    pub fn add_challenge(&mut self, challenge: Challenge) {
17        if let Some(last) = self.challenges.last() {
18            if last != &challenge {
19                self.challenges.push(challenge);
20            }
21        } else {
22            self.challenges.push(challenge);
23        }
24    }
25
26    pub fn len(&self) -> usize {
27        self.challenges.len()
28    }
29
30    pub fn is_empty(&self) -> bool {
31        self.challenges.is_empty()
32    }
33
34    pub fn extend(&mut self, other: &ChallengeHistory) {
35        self.challenges.extend(other.challenges.iter().cloned());
36    }
37
38    pub fn merge(&mut self, other: &ChallengeHistory) {
39        for challenge in &other.challenges {
40            if !self.challenges.contains(challenge) {
41                self.challenges.push(challenge.clone());
42            }
43        }
44    }
45}
46
47#[cfg(test)]
48mod tests {
49    use super::*;
50    use crate::challenges::challenge::Challenge;
51    use crate::challenges::challenge_config::ChallengeConfig;
52    use crate::challenges::challenge_type::ChallengeType;
53
54    #[test]
55    fn new_challenge_history() {
56        let challenge_history = ChallengeHistory::new();
57        assert!(challenge_history.challenges.is_empty());
58    }
59
60    #[test]
61    fn add_challenge() {
62        let mut challenge_history = ChallengeHistory::new();
63        let challenge = Challenge::new(&ChallengeType::default(), &ChallengeConfig::default());
64        challenge_history.add_challenge(challenge);
65        assert_eq!(challenge_history.challenges.len(), 1);
66    }
67
68    #[test]
69    fn test_len() {
70        let mut challenge_history = ChallengeHistory::new();
71        let challenge = Challenge::new(&ChallengeType::default(), &ChallengeConfig::default());
72        challenge_history.add_challenge(challenge);
73        assert_eq!(challenge_history.len(), 1);
74    }
75
76    #[test]
77    fn test_is_empty() {
78        let challenge_history = ChallengeHistory::new();
79        assert!(challenge_history.is_empty());
80
81        let mut challenge_history = ChallengeHistory::new();
82        let challenge = Challenge::new(&ChallengeType::default(), &ChallengeConfig::default());
83        challenge_history.add_challenge(challenge);
84        assert!(!challenge_history.is_empty());
85    }
86
87    #[test]
88    fn test_extend() {
89        let mut challenge_history = ChallengeHistory::new();
90        let challenge = Challenge::new(&ChallengeType::default(), &ChallengeConfig::default());
91        challenge_history.add_challenge(challenge);
92
93        let mut other_challenge_history = ChallengeHistory::new();
94        let other_challenge =
95            Challenge::new(&ChallengeType::default(), &ChallengeConfig::default());
96        other_challenge_history.add_challenge(other_challenge);
97
98        challenge_history.extend(&mut other_challenge_history);
99        assert_eq!(challenge_history.len(), 2);
100    }
101
102    #[test]
103    fn test_merge() {
104        let mut challenge_history1 = ChallengeHistory::new();
105        let challenge1 = Challenge::new(&ChallengeType::default(), &ChallengeConfig::default());
106        challenge_history1.add_challenge(challenge1.clone());
107
108        let mut challenge_history2 = ChallengeHistory::new();
109        challenge_history2.add_challenge(challenge1.clone());
110        let challenge2 = Challenge::new(
111            &ChallengeType::default(),
112            &ChallengeConfig {
113                id: "456".to_string(),
114                ..ChallengeConfig::default()
115            },
116        );
117        challenge_history2.add_challenge(challenge2.clone());
118
119        challenge_history1.merge(&challenge_history2);
120        assert_eq!(challenge_history1.len(), 2);
121        assert!(challenge_history1.challenges.contains(&challenge1));
122        assert!(challenge_history1.challenges.contains(&challenge2));
123    }
124}