refactor: regroup integration tests into modules

tests/fs.rs

@@ -4,14 +4,19 @@ use kxio::fs;
 
 type TestResult = Result<(), fs::Error>;
 
+mod path {
+    use super::*;
+
     mod path_of {
         use super::*;
 
         #[test]
-    fn validate_fails_on_path_traversal() -> TestResult {
+        fn should_fail_on_path_traversal() -> TestResult {
             let fs = fs::temp().expect("temp fs");
 
-        let_assert!(Err(fs::Error::PathTraversal { base, path: _path }) = fs.path_of("..".into()));
+            let_assert!(
+                Err(fs::Error::PathTraversal { base, path: _path }) = fs.path_of("..".into())
+            );
             assert_eq!(base, fs.base());
 
             Ok(())
@@ -32,7 +37,7 @@ mod path_of {
         }
     }
 
-mod path {
+    mod as_dir {
         use super::*;
 
         #[test]
@@ -65,6 +70,9 @@ mod path {
 
             Ok(())
         }
+    }
+    mod as_file {
+        use super::*;
         #[test]
         fn path_is_dir_as_file_none() -> TestResult {
             let fs = fs::temp().expect("temp fs");
@@ -90,6 +98,173 @@ mod path {
             Ok(())
         }
     }
+    mod is_dir {
+        use super::*;
+        #[test]
+        fn should_be_true_when_is_a_dir() -> TestResult {
+            let fs = fs::temp().expect("temp fs");
+            let path = fs.base().join("foo");
+            fs.dir(&path).create().expect("create");
+            let is_dir = fs.path(&path).is_dir().expect("is_dir");
+            assert!(is_dir);
+
+            Ok(())
+        }
+        #[test]
+        fn should_be_false_when_is_a_file() -> TestResult {
+            let fs = fs::temp().expect("temp fs");
+            let path = fs.base().join("foo");
+            fs.file(&path).write("bar").expect("write");
+            let is_dir = fs.path(&path).is_dir().expect("is_dir");
+            assert!(!is_dir);
+
+            Ok(())
+        }
+        #[test]
+        #[ignore]
+        fn should_be_false_when_is_a_link() -> TestResult {
+            let fs = fs::temp().expect("temp fs");
+            let path = fs.base().join("foo");
+            // TODO: (#38) create a link
+            // let_assert!(Ok(_) = fs.file_write(&path, "bar"));
+            let is_dir = fs.path(&path).is_dir().expect("is_dir");
+            assert!(!is_dir);
+
+            Ok(())
+        }
+        #[test]
+        fn should_fail_on_path_traversal() -> TestResult {
+            let fs = fs::temp().expect("temp fs");
+            let path = fs.base().join("..").join("foo");
+            let_assert!(
+                Err(fs::Error::PathTraversal {
+                    base: _base,
+                    path: _path
+                }) = fs.dir(&path).is_dir()
+            );
+
+            Ok(())
+        }
+    }
+    mod exists {
+        use super::*;
+        #[test]
+        fn should_be_true_when_it_exists() -> TestResult {
+            let fs = fs::temp().expect("temp fs");
+            let path = fs.base().join("foo");
+            fs.file(&path).write("bar").expect("write");
+            let exists = fs.path(&path).exists().expect("exists");
+            assert!(exists);
+
+            Ok(())
+        }
+        #[test]
+        fn should_be_false_when_it_does_not_exist() -> TestResult {
+            let fs = fs::temp().expect("temp fs");
+            let path = fs.base().join("foo");
+            let exists = fs.path(&path).exists().expect("exists");
+            assert!(!exists);
+
+            Ok(())
+        }
+        #[test]
+        fn should_fail_on_path_traversal() -> TestResult {
+            let fs = fs::temp().expect("temp fs");
+            let path = fs.base().join("..").join("foo");
+            let_assert!(
+                Err(fs::Error::PathTraversal {
+                    base: _base,
+                    path: _path
+                }) = fs.path(&path).exists()
+            );
+
+            Ok(())
+        }
+    }
+    mod is_file {
+        use super::*;
+        #[test]
+        fn should_be_true_when_is_a_file() -> TestResult {
+            let fs = fs::temp().expect("temp fs");
+            let path = fs.base().join("foo");
+            fs.file(&path).write("bar").expect("write");
+
+            let is_file = fs.path(&path).is_file().expect("is_file");
+            assert!(is_file);
+
+            Ok(())
+        }
+        #[test]
+        fn should_be_false_when_is_a_dir() -> TestResult {
+            let fs = fs::temp().expect("temp fs");
+            let path = fs.base().join("foo");
+            fs.dir(&path).create().expect("create");
+            let is_file = fs.path(&path).is_file().expect("is_file");
+            assert!(!is_file);
+
+            Ok(())
+        }
+        #[test]
+        #[ignore]
+        fn should_be_false_when_is_a_link() -> TestResult {
+            let fs = fs::temp().expect("temp fs");
+            let path = fs.base().join("foo");
+            // TODO: (#38) create a link
+            // let_assert!(Ok(_) = fs.file_write(&path, "bar"));
+            let is_file = fs.path(&path).is_file().expect("is_file");
+            assert!(!is_file);
+
+            Ok(())
+        }
+        #[test]
+        fn should_fail_on_path_traversal() -> TestResult {
+            let fs = fs::temp().expect("temp fs");
+            let path = fs.base().join("..").join("foo");
+            let_assert!(
+                Err(fs::Error::PathTraversal {
+                    base: _base,
+                    path: _path
+                }) = fs.file(&path).is_file()
+            );
+
+            Ok(())
+        }
+    }
+    mod rename {
+        use super::*;
+        #[test]
+        fn should_rename_a_file() -> TestResult {
+            let fs = fs::temp().expect("temp fs");
+            let src_path = fs.base().join("foo");
+            let src = fs.file(&src_path);
+            src.write("bar").expect("write");
+            let src_contents = src.reader().expect("reader").to_string();
+            let dst_path = fs.base().join("bar");
+            let dst = fs.file(&dst_path);
+            src.rename(&dst).expect("rename");
+            let dst_contents = dst.reader().expect("reader").to_string();
+            assert_eq!(src_contents, dst_contents);
+            let src_exists = src.exists().expect("exists");
+            assert!(!src_exists);
+
+            Ok(())
+        }
+
+        #[test]
+        fn should_fail_on_path_traversal() -> TestResult {
+            let fs = fs::temp().expect("temp fs");
+            let src_path = fs.base().join("..").join("foo");
+            let_assert!(
+                Err(fs::Error::PathTraversal {
+                    base: _base,
+                    path: _path
+                }) = fs.file(&src_path).rename(&fs.file(&src_path))
+            );
+
+            Ok(())
+        }
+    }
+}
 
 mod file {
     use super::*;
@@ -115,6 +290,75 @@ mod file {
         Ok(())
     }
 
+    mod remove {
+        use super::*;
+        #[test]
+        fn should_remove_a_file() -> TestResult {
+            let fs = fs::temp().expect("temp fs");
+            let path = fs.base().join("foo");
+            let file = fs.file(&path);
+            file.write("bar").expect("write");
+            file.remove().expect("remove");
+            let exists = file.exists().expect("exists");
+            assert!(!exists);
+
+            Ok(())
+        }
+
+        #[test]
+        fn should_fail_on_path_traversal() -> TestResult {
+            let fs = fs::temp().expect("temp fs");
+            let path = fs.base().join("..").join("foo");
+            let_assert!(
+                Err(fs::Error::PathTraversal {
+                    base: _base,
+                    path: _path
+                }) = fs.file(&path).remove()
+            );
+
+            Ok(())
+        }
+    }
+    mod copy {
+        use super::*;
+        #[test]
+        fn should_copy_a_file() -> TestResult {
+            let fs = fs::temp().expect("temp fs");
+            let src_path = fs.base().join("foo");
+            let src = fs.file(&src_path);
+            src.write("bar").expect("write");
+            let dst_path = fs.base().join("bar");
+            let dst = fs.file(&dst_path);
+            src.copy(&dst).expect("copy");
+            let src_contents = src.reader().expect("reader").to_string();
+            let dst_contents = dst.reader().expect("reader").to_string();
+            assert_eq!(src_contents, dst_contents);
+
+            Ok(())
+        }
+    }
+    mod reader {
+        use super::*;
+        mod to_string {
+            use super::*;
+            #[test]
+            fn read_file_to_string() -> TestResult {
+                let fs = fs::temp().expect("temp fs");
+
+                let path = fs.base().join("foo");
+                let file = fs.file(&path);
+                file.write("line 1\nline 2").expect("write");
+
+                let reader = file.reader().expect("reader");
+                let string = reader.to_string();
+
+                assert_eq!(string, "line 1\nline 2");
+
+                Ok(())
+            }
+        }
+        mod lines {
+            use super::*;
             #[test]
             fn read_file_lines() -> TestResult {
                 let fs = fs::temp().expect("temp fs");
@@ -131,8 +375,30 @@ mod file {
                 Ok(())
             }
         }
+        mod bytes {
+            use super::*;
+            #[test]
+            fn should_return_bytes() -> TestResult {
+                let fs = fs::temp().expect("temp fs");
+                let path = fs.base().join("foo");
+                let file = fs.file(&path);
+                file.write("bar").expect("write");
+                let reader = file.reader().expect("reader");
+                let bytes = reader.bytes();
+                assert_eq!(bytes.len(), 3);
+                assert_eq!(bytes[0], b'b');
+                assert_eq!(bytes[1], b'a');
+                assert_eq!(bytes[2], b'r');
 
-mod dir_create {
+                Ok(())
+            }
+        }
+    }
+}
+mod dir {
+    use super::*;
+
+    mod create {
         use super::*;
         #[test]
         fn should_create_a_dir() -> TestResult {
@@ -164,7 +430,7 @@ mod dir_create {
         }
     }
 
-mod dir_create_all {
+    mod create_all {
         use super::*;
 
         #[test]
@@ -198,7 +464,7 @@ mod dir_create_all {
         }
     }
 
-mod dir_dir_read {
+    mod read {
         use crate::fs::DirItem;
 
         use super::*;
@@ -250,7 +516,7 @@ mod dir_dir_read {
             Ok(())
         }
     }
-mod dir_remove {
+    mod remove {
         use super::*;
         #[test]
         fn should_remove_a_dir() -> TestResult {
@@ -279,7 +545,7 @@ mod dir_remove {
         }
     }
 
-mod dir_remove_all {
+    mod remove_all {
         use super::*;
         #[test]
         fn should_remove_a_dir() -> TestResult {
@@ -313,240 +579,4 @@ mod dir_remove_all {
             Ok(())
         }
     }
-
-mod path_exists {
-    use super::*;
-    #[test]
-    fn should_be_true_when_it_exists() -> TestResult {
-        let fs = fs::temp().expect("temp fs");
-        let path = fs.base().join("foo");
-        fs.file(&path).write("bar").expect("write");
-        let exists = fs.path(&path).exists().expect("exists");
-        assert!(exists);
-
-        Ok(())
-    }
-    #[test]
-    fn should_be_false_when_it_does_not_exist() -> TestResult {
-        let fs = fs::temp().expect("temp fs");
-        let path = fs.base().join("foo");
-        let exists = fs.path(&path).exists().expect("exists");
-        assert!(!exists);
-
-        Ok(())
-    }
-    #[test]
-    fn should_fail_on_path_traversal() -> TestResult {
-        let fs = fs::temp().expect("temp fs");
-        let path = fs.base().join("..").join("foo");
-        let_assert!(
-            Err(fs::Error::PathTraversal {
-                base: _base,
-                path: _path
-            }) = fs.path(&path).exists()
-        );
-
-        Ok(())
-    }
-}
-
-mod path_is_dir {
-    use super::*;
-    #[test]
-    fn should_be_true_when_is_a_dir() -> TestResult {
-        let fs = fs::temp().expect("temp fs");
-        let path = fs.base().join("foo");
-        fs.dir(&path).create().expect("create");
-        let is_dir = fs.path(&path).is_dir().expect("is_dir");
-        assert!(is_dir);
-
-        Ok(())
-    }
-    #[test]
-    fn should_be_false_when_is_a_file() -> TestResult {
-        let fs = fs::temp().expect("temp fs");
-        let path = fs.base().join("foo");
-        fs.file(&path).write("bar").expect("write");
-        let is_dir = fs.path(&path).is_dir().expect("is_dir");
-        assert!(!is_dir);
-
-        Ok(())
-    }
-    #[test]
-    #[ignore]
-    fn should_be_false_when_is_a_link() -> TestResult {
-        let fs = fs::temp().expect("temp fs");
-        let path = fs.base().join("foo");
-        // TODO: (#38) create a link
-        // let_assert!(Ok(_) = fs.file_write(&path, "bar"));
-        let is_dir = fs.path(&path).is_dir().expect("is_dir");
-        assert!(!is_dir);
-
-        Ok(())
-    }
-    #[test]
-    fn should_fail_on_path_traversal() -> TestResult {
-        let fs = fs::temp().expect("temp fs");
-        let path = fs.base().join("..").join("foo");
-        let_assert!(
-            Err(fs::Error::PathTraversal {
-                base: _base,
-                path: _path
-            }) = fs.dir(&path).is_dir()
-        );
-
-        Ok(())
-    }
-}
-
-mod path_is_file {
-    use super::*;
-    #[test]
-    fn should_be_true_when_is_a_file() -> TestResult {
-        let fs = fs::temp().expect("temp fs");
-        let path = fs.base().join("foo");
-        fs.file(&path).write("bar").expect("write");
-
-        let is_file = fs.path(&path).is_file().expect("is_file");
-        assert!(is_file);
-
-        Ok(())
-    }
-    #[test]
-    fn should_be_false_when_is_a_dir() -> TestResult {
-        let fs = fs::temp().expect("temp fs");
-        let path = fs.base().join("foo");
-        fs.dir(&path).create().expect("create");
-        let is_file = fs.path(&path).is_file().expect("is_file");
-        assert!(!is_file);
-
-        Ok(())
-    }
-    #[test]
-    #[ignore]
-    fn should_be_false_when_is_a_link() -> TestResult {
-        let fs = fs::temp().expect("temp fs");
-        let path = fs.base().join("foo");
-        // TODO: (#38) create a link
-        // let_assert!(Ok(_) = fs.file_write(&path, "bar"));
-        let is_file = fs.path(&path).is_file().expect("is_file");
-        assert!(!is_file);
-
-        Ok(())
-    }
-    #[test]
-    fn should_fail_on_path_traversal() -> TestResult {
-        let fs = fs::temp().expect("temp fs");
-        let path = fs.base().join("..").join("foo");
-        let_assert!(
-            Err(fs::Error::PathTraversal {
-                base: _base,
-                path: _path
-            }) = fs.file(&path).is_file()
-        );
-
-        Ok(())
-    }
-}
-mod path_rename {
-    use super::*;
-    #[test]
-    fn should_rename_a_file() -> TestResult {
-        let fs = fs::temp().expect("temp fs");
-        let src_path = fs.base().join("foo");
-        let src = fs.file(&src_path);
-        src.write("bar").expect("write");
-        let src_contents = src.reader().expect("reader").to_string();
-        let dst_path = fs.base().join("bar");
-        let dst = fs.file(&dst_path);
-        src.rename(&dst).expect("rename");
-        let dst_contents = dst.reader().expect("reader").to_string();
-        assert_eq!(src_contents, dst_contents);
-        let src_exists = src.exists().expect("exists");
-        assert!(!src_exists);
-
-        Ok(())
-    }
-
-    #[test]
-    fn should_fail_on_path_traversal() -> TestResult {
-        let fs = fs::temp().expect("temp fs");
-        let src_path = fs.base().join("..").join("foo");
-        let_assert!(
-            Err(fs::Error::PathTraversal {
-                base: _base,
-                path: _path
-            }) = fs.file(&src_path).rename(&fs.file(&src_path))
-        );
-
-        Ok(())
-    }
-}
-mod copy {
-    use super::*;
-    #[test]
-    fn should_copy_a_file() -> TestResult {
-        let fs = fs::temp().expect("temp fs");
-        let src_path = fs.base().join("foo");
-        let src = fs.file(&src_path);
-        src.write("bar").expect("write");
-        let dst_path = fs.base().join("bar");
-        let dst = fs.file(&dst_path);
-        src.copy(&dst).expect("copy");
-        let src_contents = src.reader().expect("reader").to_string();
-        let dst_contents = dst.reader().expect("reader").to_string();
-        assert_eq!(src_contents, dst_contents);
-
-        Ok(())
-    }
-}
-mod file_remove {
-    use super::*;
-    #[test]
-    fn should_remove_a_file() -> TestResult {
-        let fs = fs::temp().expect("temp fs");
-        let path = fs.base().join("foo");
-        let file = fs.file(&path);
-        file.write("bar").expect("write");
-        file.remove().expect("remove");
-        let exists = file.exists().expect("exists");
-        assert!(!exists);
-
-        Ok(())
-    }
-
-    #[test]
-    fn should_fail_on_path_traversal() -> TestResult {
-        let fs = fs::temp().expect("temp fs");
-        let path = fs.base().join("..").join("foo");
-        let_assert!(
-            Err(fs::Error::PathTraversal {
-                base: _base,
-                path: _path
-            }) = fs.file(&path).remove()
-        );
-
-        Ok(())
-    }
-}
-mod reader {
-    use super::*;
-    mod bytes {
-        use super::*;
-        #[test]
-        fn should_return_bytes() -> TestResult {
-            let fs = fs::temp().expect("temp fs");
-            let path = fs.base().join("foo");
-            let file = fs.file(&path);
-            file.write("bar").expect("write");
-            let reader = file.reader().expect("reader");
-            let bytes = reader.bytes();
-            assert_eq!(bytes.len(), 3);
-            assert_eq!(bytes[0], b'b');
-            assert_eq!(bytes[1], b'a');
-            assert_eq!(bytes[2], b'r');
-
-            Ok(())
-        }
-    }
 }