1 #![warn(rust_2018_idioms)]
2 #![cfg(feature = "full")]
3 
4 use tokio::fs;
5 use tokio_test::{assert_err, assert_ok};
6 
7 use std::sync::{Arc, Mutex};
8 use tempfile::tempdir;
9 
10 #[tokio::test]
create_dir()11 async fn create_dir() {
12     let base_dir = tempdir().unwrap();
13     let new_dir = base_dir.path().join("foo");
14     let new_dir_2 = new_dir.clone();
15 
16     assert_ok!(fs::create_dir(new_dir).await);
17 
18     assert!(new_dir_2.is_dir());
19 }
20 
21 #[tokio::test]
create_all()22 async fn create_all() {
23     let base_dir = tempdir().unwrap();
24     let new_dir = base_dir.path().join("foo").join("bar");
25     let new_dir_2 = new_dir.clone();
26 
27     assert_ok!(fs::create_dir_all(new_dir).await);
28     assert!(new_dir_2.is_dir());
29 }
30 
31 #[tokio::test]
build_dir()32 async fn build_dir() {
33     let base_dir = tempdir().unwrap();
34     let new_dir = base_dir.path().join("foo").join("bar");
35     let new_dir_2 = new_dir.clone();
36 
37     assert_ok!(fs::DirBuilder::new().recursive(true).create(new_dir).await);
38 
39     assert!(new_dir_2.is_dir());
40     assert_err!(
41         fs::DirBuilder::new()
42             .recursive(false)
43             .create(new_dir_2)
44             .await
45     );
46 }
47 
48 #[tokio::test]
remove()49 async fn remove() {
50     let base_dir = tempdir().unwrap();
51     let new_dir = base_dir.path().join("foo");
52     let new_dir_2 = new_dir.clone();
53 
54     std::fs::create_dir(new_dir.clone()).unwrap();
55 
56     assert_ok!(fs::remove_dir(new_dir).await);
57     assert!(!new_dir_2.exists());
58 }
59 
60 #[tokio::test]
read_inherent()61 async fn read_inherent() {
62     let base_dir = tempdir().unwrap();
63 
64     let p = base_dir.path();
65     std::fs::create_dir(p.join("aa")).unwrap();
66     std::fs::create_dir(p.join("bb")).unwrap();
67     std::fs::create_dir(p.join("cc")).unwrap();
68 
69     let files = Arc::new(Mutex::new(Vec::new()));
70 
71     let f = files.clone();
72     let p = p.to_path_buf();
73 
74     let mut entries = fs::read_dir(p).await.unwrap();
75 
76     while let Some(e) = assert_ok!(entries.next_entry().await) {
77         let s = e.file_name().to_str().unwrap().to_string();
78         f.lock().unwrap().push(s);
79     }
80 
81     let mut files = files.lock().unwrap();
82     files.sort(); // because the order is not guaranteed
83     assert_eq!(
84         *files,
85         vec!["aa".to_string(), "bb".to_string(), "cc".to_string()]
86     );
87 }
88 
89 #[tokio::test]
read_stream()90 async fn read_stream() {
91     use tokio::stream::StreamExt;
92 
93     let base_dir = tempdir().unwrap();
94 
95     let p = base_dir.path();
96     std::fs::create_dir(p.join("aa")).unwrap();
97     std::fs::create_dir(p.join("bb")).unwrap();
98     std::fs::create_dir(p.join("cc")).unwrap();
99 
100     let files = Arc::new(Mutex::new(Vec::new()));
101 
102     let f = files.clone();
103     let p = p.to_path_buf();
104 
105     let mut entries = fs::read_dir(p).await.unwrap();
106 
107     while let Some(res) = entries.next().await {
108         let e = assert_ok!(res);
109         let s = e.file_name().to_str().unwrap().to_string();
110         f.lock().unwrap().push(s);
111     }
112 
113     let mut files = files.lock().unwrap();
114     files.sort(); // because the order is not guaranteed
115     assert_eq!(
116         *files,
117         vec!["aa".to_string(), "bb".to_string(), "cc".to_string()]
118     );
119 }
120