Added tests for stubbed functions

src/validate.rs

@@ -1,4 +1,4 @@
-use std::{path::PathBuf, fs, collections::HashMap};
+use std::{path::PathBuf, fs, collections::HashMap, borrow::BorrowMut};
 
 use crate::util;
 
@@ -27,15 +27,11 @@ pub fn validate(verbosity: u8, config: util::config::Config) {
     }
 
     // make sure each has a match
-    // - check the file stems
-    // - compare the file stems
-    // - check if either file is in the invalid list
-    // - add to the notification queue
     let mut in_to_out: (Vec<(PathBuf, PathBuf)>, Vec<PathBuf>) = map_files(in_files, out_files);
     let invalid: Vec<(PathBuf, PathBuf)> = check_mappings(in_to_out.0, in_suffix, out_suffix);
 
     print_unmached(in_to_out.1);
-    print_invalid_pairs(invalid);
+    print_invalid_pairs(invalid, in_suffix, out_suffix);
 
 }
 
@@ -147,11 +143,11 @@ fn print_unmached(unmatched: Vec<PathBuf>) {
 }
 
 /**
- * @brief Utility function to print invalid pairs
+ * @brief Utility function to print invalid pairs and suggest a fix
  *
  * @param invalid: A vector of invalid pairs
 */
-fn print_invalid_pairs(invalid: Vec<(PathBuf, PathBuf)>) {
+fn print_invalid_pairs(invalid: Vec<(PathBuf, PathBuf)>, in_suffix: &str, out_suffix: &str) {
 
 }
 
@@ -177,6 +173,38 @@ mod tests {
         return files;
     }
 
+    #[fixture]
+    fn in_files() -> Vec<PathBuf> {
+        let invalid_map11 = PathBuf::from("in/inv/path/file.in ");
+        let invalid_map12 = PathBuf::from("in/inv/path/file_stupid.in");
+        let invalid_map13 = PathBuf::from("in/inv/path/file/dead.inn");
+
+        let valid_map11 = PathBuf::from("in/val/path/file.in");
+        let valid_map12 = PathBuf::from("in/val/path/file_stupid.in");
+        let valid_map13 = PathBuf::from("in/val/path/file/dead.in");
+
+        let in_files = vec![invalid_map11, invalid_map12, invalid_map13,
+                            valid_map11, valid_map12, valid_map13];
+
+        return in_files;
+    }
+
+    #[fixture]
+    fn out_files() -> Vec<PathBuf> {
+        let invalid_map21 = PathBuf::from("out/inv/path/file.out");
+        let invalid_map22 = PathBuf::from("out/inv/path/file_stupid.out ");
+        let invalid_map23 = PathBuf::from("out/inv/path/file.outt");
+
+        let valid_map21 = PathBuf::from("out/val/path/file.out");
+        let valid_map22 = PathBuf::from("out/val/path/file_stupid.out");
+        let valid_map23 = PathBuf::from("out/val/path/file.out");
+
+        let out_files = vec![invalid_map21, invalid_map22, invalid_map23,
+                             valid_map21, valid_map22, valid_map23];
+
+        return out_files;
+    }
+
     #[rstest]
     fn test_collect_invalid(files: Vec<PathBuf>) {
         let suffix = "suf";
@@ -195,4 +223,33 @@ mod tests {
         assert!(invalid.contains(&files[4]));
         assert!(invalid.contains(&files[5]));
     }
+
+    #[rstest]
+    fn test_map(in_files: Vec<PathBuf>, out_files: Vec<PathBuf>) {
+        let mappings: (Vec<(PathBuf, PathBuf)>, Vec<PathBuf>) = map_files(in_files, out_files);
+
+        print_unmached(mappings.1);
+        assert!(&mappings.0.contains(&(in_files[0], out_files[0])));
+        assert!(&mappings.0.contains(&(in_files[1], out_files[1])));
+        assert!(&mappings.0.contains(&(in_files[2], out_files[2])));
+        assert!(&mappings.0.contains(&(in_files[3], out_files[3])));
+        assert!(&mappings.0.contains(&(in_files[4], out_files[4])));
+        assert!(&mappings.0.contains(&(in_files[5], out_files[5])));
+    }
+
+    #[rstest]
+    fn test_check_valid_mappings(in_files: Vec<PathBuf>, out_files: Vec<PathBuf>) {
+        let in_suffix = "in";
+        let out_suffix = "out";
+        let invalid: Vec<(PathBuf, PathBuf)> = check_mappings(map_files(in_files, out_files).0, in_suffix, out_suffix);
+
+        print_invalid_pairs(invalid, in_suffix, out_suffix);
+        assert!(&invalid.contains(&(in_files[0], out_files[0])));
+        assert!(&invalid.contains(&(in_files[1], out_files[1])));
+        assert!(&invalid.contains(&(in_files[2], out_files[2])));
+
+        assert!(!&invalid.contains(&(in_files[3], out_files[3])));
+        assert!(!&invalid.contains(&(in_files[4], out_files[4])));
+        assert!(!&invalid.contains(&(in_files[5], out_files[5])));
+    }
 }