media_catalogue/repository/
test.rs

1#[cfg(test)]
2mod tests_repository {
3    use crate::domain;
4    use crate::domain::media;
5    use crate::repository::json::JsonRepository;
6    use crate::repository::Error;
7    use crate::repository::Repository;
8    use std::collections::{HashMap, VecDeque};
9    use std::fs;
10    use std::string::String;
11    use std::vec::Vec;
12
13    #[test]
14    fn test_save_a_user() -> Result<(), Error> {
15        let file = format!("{}/test_save_a_user.json", DIRECTORY);
16        let _ = fs::remove_file(file.clone());
17        let mut repo = JsonRepository::new(&file)?;
18        let name = String::from("foo");
19        let medias: HashMap<String, media::Media> = [
20            (
21                String::from("bar"),
22                media::Media {
23                    name: String::from("bar"),
24                    chapters: Vec::new(),
25                    cursor: media::Cursor::default(),
26                    source: Some(String::from("alpha")),
27                },
28            ),
29            (
30                String::from("too"),
31                media::Media {
32                    name: String::from("too"),
33                    chapters: Vec::new(),
34                    cursor: media::Cursor::default(),
35                    source: None,
36                },
37            ),
38        ]
39        .iter()
40        .cloned()
41        .collect();
42        let user = domain::User::new(name.clone(), medias);
43
44        match repo.save(&user) {
45            Err(e) => panic!("{:?}", e),
46            Ok(_) => assert_eq!(repo.users()[&(name.clone())], user),
47        };
48        Ok(())
49    }
50
51    #[test]
52    fn test_load_a_user() -> Result<(), Error> {
53        let file = format!("{}/test_load_a_user.json", DIRECTORY);
54        let _ = fs::remove_file(file.clone());
55        let mut repo = JsonRepository::new(&file)?;
56        let name = String::from("foo");
57        let user = domain::User::new(name.clone(), HashMap::new());
58        match repo.save(&user) {
59            Ok(_) => match repo.load(&name) {
60                Ok(resp) => assert_eq!(resp, user),
61                Err(e) => panic!("{:?}", e),
62            },
63            Err(e) => panic!("{:?}", e),
64        }
65
66        Ok(())
67    }
68
69    #[test]
70    fn test_load_multiple_users() -> Result<(), Error> {
71        let file = format!("{}/test_load_multiple_users.json", DIRECTORY);
72        let _ = fs::remove_file(file.clone());
73        let mut repo = JsonRepository::new(&file)?;
74
75        let users = vec![
76            domain::User::new(String::from("foo"), HashMap::new()),
77            domain::User::new(String::from("bar"), HashMap::new()),
78            domain::User::new(String::from("too"), HashMap::new()),
79        ];
80
81        for user in users.iter() {
82            if let Err(e) = repo.save(user) {
83                panic!("{:?}", e)
84            }
85        }
86
87        for user in users.iter() {
88            match repo.load(user.name()) {
89                Ok(u) => assert_eq!(u, *user),
90                Err(e) => panic!("{:?}", e),
91            }
92        }
93        Ok(())
94    }
95
96    #[test]
97    fn test_persistance() -> Result<(), Error> {
98        let file = format!("{}/test_persistance.json", DIRECTORY);
99        let _ = fs::remove_file(file.clone());
100        let mut repo = JsonRepository::new(&file.clone())?;
101
102        let users = vec![
103            domain::User::new(String::from("foo"), HashMap::new()),
104            domain::User::new(String::from("bar"), HashMap::new()),
105            domain::User::new(String::from("too"), HashMap::new()),
106        ];
107
108        for user in users.iter() {
109            if let Err(e) = repo.save(user) {
110                panic!("{:?}", e)
111            }
112        }
113
114        let new_repo = JsonRepository::new(&file.clone())?;
115        for user in users.iter() {
116            match new_repo.load(user.name()) {
117                Ok(u) => assert_eq!(u, *user),
118                Err(e) => panic!("{:?}", e),
119            }
120        }
121
122        Ok(())
123    }
124
125    #[test]
126    fn test_update_a_user() -> Result<(), Error> {
127        let file = format!("{}/test_update_a_user.json", DIRECTORY);
128        let _ = fs::remove_file(file.clone());
129        let mut repo = JsonRepository::new(&file)?;
130        let name = String::from("foo");
131        let user = domain::User::new(name.clone(), HashMap::new());
132        let medias: HashMap<String, media::Media> = [
133            (
134                String::from("bar"),
135                media::Media {
136                    name: String::from("bar"),
137                    chapters: Vec::new(),
138                    cursor: media::Cursor::default(),
139                    source: None,
140                },
141            ),
142            (
143                String::from("too"),
144                media::Media {
145                    name: String::from("too"),
146                    chapters: Vec::new(),
147                    cursor: media::Cursor {
148                        current: None,
149                        history: VecDeque::new(),
150                    },
151                    source: None,
152                },
153            ),
154        ]
155        .iter()
156        .cloned()
157        .collect();
158
159        let _ = repo.save(&user).expect("unable to save");
160        let mut user_modified = user.clone();
161        user_modified.medias = medias;
162        user_modified.name = String::from("bar");
163
164        match repo.update(&user.name, &user_modified) {
165            Ok(_) => match repo.load(&user_modified.name) {
166                Ok(u) => assert_eq!(u, user_modified),
167                Err(e) => panic!("{:?}", e),
168            },
169            Err(e) => panic!("{:?}", e),
170        }
171        Ok(())
172    }
173
174    #[test]
175    fn test_update_a_non_existant_user() -> Result<(), Error> {
176        let file = format!("{}/test_update_a_non_existant_user.json", DIRECTORY);
177        let _ = fs::remove_file(file.clone());
178        let mut repo = JsonRepository::new(&file)?;
179        let name = String::from("foo");
180        let user = domain::User::new(name.clone(), HashMap::new());
181
182        let _ = repo.save(&user).expect("unable to save");
183
184        let mut user_modified = user.clone();
185        user_modified.name = String::from("bar");
186
187        match repo.update(&String::from("do not exist"), &user_modified) {
188            Ok(_) => panic!("should not have been able to update"),
189            Err(_) => return Ok(()),
190        }
191    }
192
193    #[test]
194    fn test_delete_a_user_with_one_user() -> Result<(), Error> {
195        let file = format!("{}/test_delete_a_user_with_one_user.json", DIRECTORY);
196        let _ = fs::remove_file(file.clone());
197        let mut repo = JsonRepository::new(&file)?;
198        let name = String::from("foo");
199        let user = domain::User::new(name.clone(), HashMap::new());
200
201        let _ = repo.save(&user).expect("unable to save");
202        let _ = repo.delete(&user.name).expect("unable to delete a user");
203
204        match repo.size() {
205            Ok(size) => {
206                assert_eq!(size, 0);
207                Ok(())
208            }
209            Err(e) => panic!("{:?}", e),
210        }
211    }
212
213    #[test]
214    fn test_delete_a_user_with_multiple_user() -> Result<(), Error> {
215        let file = format!("{}/test_delete_a_user_with_only_one_user.json", DIRECTORY);
216        let _ = fs::remove_file(file.clone());
217        let mut repo = JsonRepository::new(&file)?;
218        let user_to_delete = String::from("to delete");
219        let users = vec![
220            domain::User::new(user_to_delete.clone(), HashMap::new()),
221            domain::User::new(String::from("bar"), HashMap::new()),
222            domain::User::new(String::from("too"), HashMap::new()),
223            domain::User::new(String::from("zoo"), HashMap::new()),
224        ];
225
226        for user in users.iter() {
227            let _ = repo.save(&user).expect("unable to save");
228        }
229
230        let _ = repo
231            .delete(&user_to_delete)
232            .expect("unable to delete a user");
233
234        match repo.size() {
235            Ok(size) => {
236                assert_eq!(size, users.len() - 1);
237                Ok(())
238            }
239            Err(e) => panic!("{:?}", e),
240        }
241    }
242
243    #[test]
244    fn test_clear_repository_with_users() -> Result<(), Error> {
245        let file = format!("{}/test_clear_repository_with_users.json", DIRECTORY);
246        let _ = fs::remove_file(file.clone());
247        let mut repo = JsonRepository::new(&file)?;
248        let user_to_delete = String::from("to delete");
249        let users = vec![
250            domain::User::new(user_to_delete.clone(), HashMap::new()),
251            domain::User::new(String::from("bar"), HashMap::new()),
252            domain::User::new(String::from("too"), HashMap::new()),
253            domain::User::new(String::from("zoo"), HashMap::new()),
254        ];
255
256        for user in users.iter() {
257            let _ = repo.save(&user).expect("unable to save");
258        }
259
260        match repo.clear() {
261            Err(e) => panic!("{:?}", e),
262            Ok(_) => match repo.size() {
263                Ok(size) => {
264                    assert_eq!(size, 0);
265                    Ok(())
266                }
267                Err(e) => panic!("{:?}", e),
268            },
269        }
270    }
271    #[test]
272    fn test_clear_empty_repository() -> Result<(), Error> {
273        let file = format!("{}/test_clear_empty_repository.json", DIRECTORY);
274        let _ = fs::remove_file(file.clone());
275        let mut repo = JsonRepository::new(&file)?;
276
277        match repo.clear() {
278            Err(e) => panic!("{:?}", e),
279            Ok(_) => match repo.size() {
280                Ok(size) => {
281                    assert_eq!(size, 0);
282                    Ok(())
283                }
284                Err(e) => panic!("{:?}", e),
285            },
286        }
287    }
288
289    const DIRECTORY: &str = "./src/repository/test_files";
290}
media_catalogue/repository/test.rs

media_catalogue/repository/
test.rs
