fixed #125: improved unit tests

Author: RaphGL

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "tuckr"
-version = "0.12.0"
+version = "0.13.0-beta"
 authors = ["RaphGL"]
 edition = "2024"
 description = "Super powered GNU Stow replacement"

Cargo.toml

@@ -184,35 +184,32 @@ pub fn group_without_target(group: &str) -> &str {
 }
 
 fn platform_is_under_wsl() -> bool {
-    if !cfg!(target_os = "linux") {
+    if cfg!(not(target_os = "linux")) {
         return false;
     }
 
     for file in &["/proc/sys/kernel/osrelease", "/proc/version"] {
-        if let Ok(content) = std::fs::read(file) {
-            let Ok(content) = std::str::from_utf8(&content) else {
-                return false;
-            };
+        let Ok(content) = std::fs::read(file) else {
+            continue;
+        };
 
-            if content.contains("microsoft") || content.contains("WSL") {
-                return true;
-            }
+        let Ok(content) = std::str::from_utf8(&content) else {
+            continue;
+        };
+
+        if content.contains("microsoft") || content.contains("WSL") {
+            return true;
         }
     }
 
-    let Ok(wsl_interop_exists) = std::fs::exists("/proc/sys/fs/binfmt_misc/WSLInterop") else {
-        return false;
-    };
-
-    wsl_interop_exists
+    std::fs::exists("/proc/sys/fs/binfmt_misc/WSLInterop").is_ok()
 }
 
 /// Returns true if a group with specified name can be used by current platform.
 /// Checks if a group should be linked on current platform. For unconditional
 /// groups, this function returns true; for conditional groups, this function
 /// returns true when group suffix matches current target_os or target_family.
 pub fn group_is_valid_target(group: &str, custom_targets: &[impl AsRef<str>]) -> bool {
-    // Gets the current OS and OS family
     let current_target_os = format!("_{}", env::consts::OS);
     let current_target_family = format!("_{}", env::consts::FAMILY);
 
@@ -247,7 +244,7 @@ impl Dotfile {
             return false;
         };
 
-        let home_dir = dirs::home_dir().unwrap();
+        let home_dir = get_dotfiles_target_dir_path().unwrap();
         !target.starts_with(home_dir)
     }
 
@@ -409,9 +406,13 @@ pub fn get_target_basepath(target: &path::Path) -> Option<PathBuf> {
 }
 
 pub fn get_dotfiles_target_dir_path() -> Result<PathBuf, String> {
-    #[cfg(test)]
-    {
-        unsafe { std::env::remove_var("TUCKR_TARGET") };
+    if cfg!(test) {
+        return Ok(std::env::temp_dir().join(format!(
+            "tuckr-target-{}",
+            // this will return a namespace but `::` is invalid on paths in windows
+            // so we need to change it to prevent panics when interacting with the file system there
+            std::thread::current().name().unwrap().replace("::", "_")
+        )));
     }
 
     if let Ok(dir) = std::env::var("TUCKR_TARGET")
@@ -554,7 +555,7 @@ mod tests {
 
         assert_eq!(
             Dotfile::try_from(group).unwrap().to_target_path().unwrap(),
-            dirs::home_dir().unwrap().join(".zshrc")
+            super::get_dotfiles_target_dir_path().unwrap().join(".zshrc")
         );
     }
 

src/dotfiles.rs

@@ -560,15 +560,18 @@ pub fn groupis_cmd(ctx: &Context, files: &[String]) -> Result<(), ExitCode> {
         }
     };
 
+    let mut found_non_group_file = false;
     for file in files {
         let file_path = Path::new(file);
         if !file_path.exists() {
             eprintln!("{}", t!("errors.x_doesnt_exist", x = file).red());
+            found_non_group_file = true;
             continue;
         }
 
         let Some(group) = dotfiles::get_dotfile_from_path(file_path) else {
             eprintln!("{}", t!("errors.not_a_tuckr_dotfile", file = file).red());
+            found_non_group_file = true;
             continue;
         };
 
@@ -578,7 +581,11 @@ pub fn groupis_cmd(ctx: &Context, files: &[String]) -> Result<(), ExitCode> {
         println!("{}", group.group_name);
     }
 
-    Ok(())
+    if found_non_group_file {
+        Err(ExitCode::FAILURE)
+    } else {
+        Ok(())
+    }
 }
 
 pub fn get_user_confirmation(msg: &str) -> bool {
@@ -774,10 +781,7 @@ mod tests {
             let dotfiles_dir = dotfiles::get_dotfiles_path(None).unwrap();
             fs::create_dir_all(dotfiles_dir.join("Configs")).unwrap();
 
-            let target_dir = dirs::home_dir().unwrap().join(format!(
-                "tuckr_test-{}",
-                std::thread::current().name().unwrap().replace("::", "_")
-            ));
+            let target_dir = dotfiles::get_dotfiles_target_dir_path().unwrap();
             fs::create_dir_all(&target_dir).unwrap();
 
             Self {
@@ -945,4 +949,30 @@ mod tests {
         assert!(dotfiles_dir.join("Hooks").exists());
         assert!(dotfiles_dir.join("Secrets").exists());
     }
+
+    #[test]
+    fn groupis_cmd_detects_groups_properly() {
+        let ft = FileopsTest::start();
+        let ctx = Context::default();
+
+        let testfile = ft.target_dir.join("Tuckr-GroupIs-UnitTest-File");
+
+        assert!(groupis_cmd(&ctx, &[testfile.to_str().unwrap().into()]).is_err());
+
+        fs::write(&testfile, "test".as_bytes()).unwrap();
+        assert!(groupis_cmd(&ctx, &[testfile.to_str().unwrap().into()]).is_err());
+
+        push_cmd(
+            &ctx,
+            "test".into(),
+            &[testfile.to_str().unwrap().into()],
+            true,
+            false,
+            true,
+        ).unwrap();
+
+        assert!(groupis_cmd(&ctx, &[testfile.to_str().unwrap().into()]).is_ok());
+
+        fs::remove_file(testfile).unwrap();
+    }
 }

src/fileops.rs

@@ -254,7 +254,7 @@ pub fn set_cmd(
     }
 
     let run_deploy_steps = |stages: DeployStages, group: String| -> Result<(), ExitCode> {
-        if !dotfiles::group_is_valid_target(&group, &ctx.custom_targets) || exclude.contains(&group)
+        if exclude.contains(&group)
         {
             return Ok(());
         }
@@ -377,7 +377,7 @@ pub fn unset_cmd(ctx: &Context, groups: &[String], exclude: &[String]) -> Result
     };
 
     for group in groups.iter() {
-        if !dotfiles::group_is_valid_target(group, &ctx.custom_targets) || exclude.contains(group) {
+        if exclude.contains(group) {
             continue;
         }
 

src/hooks.rs

@@ -1196,19 +1196,33 @@ mod tests {
 
     impl Test {
         fn start() -> Self {
+            let target_dir =  dotfiles::get_dotfiles_target_dir_path().unwrap();
+            fs::create_dir_all(&target_dir).unwrap();
+
             crate::fileops::init_cmd(&Context::default()).unwrap();
             let dotfiles_dir = dotfiles::get_dotfiles_path(None).unwrap();
+            let configs_dir = dotfiles_dir.join("Configs");
             let group_dir = dotfiles_dir.join("Configs").join("Group1");
             let new_config_dir = group_dir.join(".config");
-
             fs::create_dir_all(&new_config_dir).unwrap();
 
             let filepaths = [
                 new_config_dir.join("group_file"),
                 group_dir.join("group_file_0"),
+
+                configs_dir
+                    .join("shared_group1")
+                    .join("shared_dir")
+                    .join("file1"),
+                configs_dir
+                    .join("shared_group2")
+                    .join("shared_dir")
+                    .join("file2"),
             ];
 
             for filepath in &filepaths {
+                fs::create_dir_all(filepath.parent().unwrap()).unwrap();
+
                 let mut file = File::create(filepath).unwrap();
                 _ = file
                     .write("Some random content on file".as_bytes())
@@ -1303,4 +1317,47 @@ mod tests {
         test_adding_symlink();
         test_removing_symlink();
     }
+
+    #[test]
+    fn resolve_shared_directories() {
+        let ctx = Context::default();
+        let target_dir = dotfiles::get_dotfiles_target_dir_path().unwrap();
+        let shared_dir_target = target_dir.join("shared_dir");
+        _ = fs::remove_dir_all(&shared_dir_target);
+
+        let test = Test::start();
+
+        assert!(!shared_dir_target.exists());
+
+        _ = super::add_cmd(
+            &ctx,
+            false,
+            &["shared_group1".into()],
+            &[],
+            false,
+            false,
+            true,
+        );
+
+        let file1_target = shared_dir_target.join("file1");
+        let file2_target = shared_dir_target.join("file2");
+
+        assert!(shared_dir_target.is_symlink());
+        assert!(!file1_target.is_symlink() && file1_target.is_file());
+
+        _ = super::add_cmd(
+            &ctx,
+            false,
+            &["shared_group2".into()],
+            &[],
+            false,
+            false,
+            true,
+        );
+
+        assert!(file1_target.is_symlink() && file1_target.is_file());
+        assert!(file2_target.is_symlink() && file2_target.is_file());
+
+        _ = fs::remove_dir_all(shared_dir_target);
+    }
 }