chore: add tests

Author: graelo

src/actions/restore.rs

@@ -18,8 +18,16 @@ use crate::{
 };
 
 /// Name of the placeholder session.
+///
+/// This session is created temporarily when starting tmux from outside a tmux environment.
+/// It's deleted after the restore completes.
 const PLACEHOLDER_SESSION_NAME: &str = "[placeholder]";
 
+/// Check if we're currently running inside a tmux session.
+fn is_inside_tmux() -> bool {
+    std::env::var("TMUX").is_ok()
+}
+
 /// Restore all sessions, windows & panes from the backup file.
 pub async fn restore<P: AsRef<Path>>(backup_filepath: P) -> Result<v1::Overview> {
     // Prepare the temp directory with the content of the backup.
@@ -28,7 +36,7 @@ pub async fn restore<P: AsRef<Path>>(backup_filepath: P) -> Result<v1::Overview>
     let panes_content_dir = temp_dir.path().join("panes-content");
 
     // Start tmux if needed.
-    let not_in_tmux = std::env::var("TMUX").is_err();
+    let not_in_tmux = !is_inside_tmux();
     if not_in_tmux {
         tmux::server::start(PLACEHOLDER_SESSION_NAME).await?;
     }
@@ -211,3 +219,99 @@ async fn restore_session(
 
     Ok(())
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    mod constants {
+        use super::*;
+
+        #[test]
+        fn placeholder_session_name_is_bracketed() {
+            // The placeholder name uses brackets to make it visually distinct
+            // and unlikely to collide with user session names
+            assert!(PLACEHOLDER_SESSION_NAME.starts_with('['));
+            assert!(PLACEHOLDER_SESSION_NAME.ends_with(']'));
+        }
+
+        #[test]
+        fn placeholder_session_name_is_not_empty() {
+            assert!(!PLACEHOLDER_SESSION_NAME.is_empty());
+            // Should have content between the brackets
+            assert!(PLACEHOLDER_SESSION_NAME.len() > 2);
+        }
+    }
+
+    mod tmux_detection {
+        use super::*;
+
+        #[test]
+        fn is_inside_tmux_reflects_environment() {
+            // This test documents the behavior - it checks the TMUX env var
+            // The actual result depends on the test environment
+            let expected = std::env::var("TMUX").is_ok();
+            assert_eq!(is_inside_tmux(), expected);
+        }
+    }
+
+    mod pair_struct {
+        use super::*;
+        use std::path::PathBuf;
+        use std::str::FromStr;
+        use tmux::pane_id::PaneId;
+
+        fn make_test_pane(id: &str, command: &str, is_active: bool) -> Pane {
+            Pane {
+                id: PaneId::from_str(id).unwrap(),
+                index: 0,
+                is_active,
+                title: "test".to_string(),
+                dirpath: PathBuf::from("/tmp"),
+                command: command.to_string(),
+            }
+        }
+
+        #[test]
+        fn pair_can_be_cloned() {
+            let pane = make_test_pane("%1", "zsh", true);
+
+            let pair = Pair {
+                source: pane.clone(),
+                target: PaneId::from_str("%2").unwrap(),
+            };
+
+            let cloned = pair.clone();
+            assert_eq!(cloned.source.id, pair.source.id);
+            assert_eq!(cloned.target, pair.target);
+        }
+
+        #[test]
+        fn pair_is_debug_printable() {
+            let pane = make_test_pane("%1", "bash", false);
+
+            let pair = Pair {
+                source: pane,
+                target: PaneId::from_str("%5").unwrap(),
+            };
+
+            // Just verify it doesn't panic - Debug is derived
+            let debug_str = format!("{:?}", pair);
+            assert!(debug_str.contains("Pair"));
+        }
+
+        #[test]
+        fn pair_preserves_source_pane_properties() {
+            let pane = make_test_pane("%42", "nvim", true);
+
+            let pair = Pair {
+                source: pane,
+                target: PaneId::from_str("%99").unwrap(),
+            };
+
+            assert_eq!(pair.source.command, "nvim");
+            assert!(pair.source.is_active);
+            assert_eq!(pair.target.as_str(), "%99");
+        }
+    }
+}

src/actions/save.rs

@@ -10,6 +10,12 @@ use tempfile::TempDir;
 use crate::{management::archive::v1, tmux, Result};
 use tmux_lib::utils;
 
+/// Shell commands that are recognized for prompt line dropping.
+///
+/// When capturing pane content, if the active command is one of these shells,
+/// we can optionally drop the last N lines to avoid capturing the shell prompt.
+const DETECTED_SHELLS: &[&str] = &["zsh", "bash", "fish"];
+
 /// Save the tmux sessions, windows and panes into a backup at `backup_dirpath`.
 ///
 /// After saving, this function returns the path to the backup and the number of
@@ -88,23 +94,36 @@ pub async fn save<P: AsRef<Path>>(
     Ok((new_backup_filepath, overview))
 }
 
+/// Determine if the given command is a recognized shell.
+///
+/// Used to decide whether to drop trailing lines (shell prompt) when capturing pane content.
+fn is_shell_command(command: &str) -> bool {
+    DETECTED_SHELLS.contains(&command)
+}
+
+/// Calculate how many lines to drop from pane capture based on the active command.
+///
+/// If the pane is running a recognized shell, we drop `num_lines_to_drop` lines
+/// to avoid capturing the shell prompt. For other commands, we keep everything.
+fn lines_to_drop_for_pane(pane_command: &str, num_lines_to_drop: usize) -> usize {
+    if is_shell_command(pane_command) {
+        num_lines_to_drop
+    } else {
+        0
+    }
+}
+
 /// For each provided pane, retrieve the content and save it into `destination_dir`.
 async fn save_panes_content<P: AsRef<Path>>(
     panes: Vec<tmux::pane::Pane>,
     destination_dir: P,
     num_lines_to_drop: usize,
 ) -> Result<()> {
     let mut handles = Vec::new();
-    let detected_shells = ["zsh", "bash", "fish"];
 
     for pane in panes {
         let dest_dir = destination_dir.as_ref().to_path_buf();
-
-        let drop_n_last_lines = if detected_shells.contains(&&pane.command[..]) {
-            num_lines_to_drop
-        } else {
-            0
-        };
+        let drop_n_last_lines = lines_to_drop_for_pane(&pane.command, num_lines_to_drop);
 
         let handle = smol::spawn(async move {
             let stdout = pane.capture().await.unwrap();
@@ -120,3 +139,102 @@ async fn save_panes_content<P: AsRef<Path>>(
     join_all(handles).await;
     Ok(())
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    mod shell_detection {
+        use super::*;
+
+        #[test]
+        fn recognizes_zsh() {
+            assert!(is_shell_command("zsh"));
+        }
+
+        #[test]
+        fn recognizes_bash() {
+            assert!(is_shell_command("bash"));
+        }
+
+        #[test]
+        fn recognizes_fish() {
+            assert!(is_shell_command("fish"));
+        }
+
+        #[test]
+        fn rejects_vim() {
+            assert!(!is_shell_command("vim"));
+        }
+
+        #[test]
+        fn rejects_nvim() {
+            assert!(!is_shell_command("nvim"));
+        }
+
+        #[test]
+        fn rejects_python() {
+            assert!(!is_shell_command("python"));
+        }
+
+        #[test]
+        fn rejects_empty_command() {
+            assert!(!is_shell_command(""));
+        }
+
+        #[test]
+        fn rejects_similar_but_different() {
+            // Shell name as substring shouldn't match
+            assert!(!is_shell_command("zsh-5.9"));
+            assert!(!is_shell_command("/bin/zsh"));
+            assert!(!is_shell_command("bash-5.2"));
+        }
+
+        #[test]
+        fn case_sensitive() {
+            assert!(!is_shell_command("ZSH"));
+            assert!(!is_shell_command("BASH"));
+            assert!(!is_shell_command("Fish"));
+        }
+    }
+
+    mod lines_to_drop {
+        use super::*;
+
+        #[test]
+        fn drops_lines_for_shells() {
+            assert_eq!(lines_to_drop_for_pane("zsh", 2), 2);
+            assert_eq!(lines_to_drop_for_pane("bash", 3), 3);
+            assert_eq!(lines_to_drop_for_pane("fish", 1), 1);
+        }
+
+        #[test]
+        fn zero_drop_for_non_shells() {
+            assert_eq!(lines_to_drop_for_pane("vim", 5), 0);
+            assert_eq!(lines_to_drop_for_pane("python", 10), 0);
+            assert_eq!(lines_to_drop_for_pane("htop", 3), 0);
+        }
+
+        #[test]
+        fn zero_requested_means_zero_dropped() {
+            assert_eq!(lines_to_drop_for_pane("zsh", 0), 0);
+            assert_eq!(lines_to_drop_for_pane("bash", 0), 0);
+        }
+    }
+
+    mod constants {
+        use super::*;
+
+        #[test]
+        fn detected_shells_includes_common_shells() {
+            assert!(DETECTED_SHELLS.contains(&"zsh"));
+            assert!(DETECTED_SHELLS.contains(&"bash"));
+            assert!(DETECTED_SHELLS.contains(&"fish"));
+        }
+
+        #[test]
+        fn detected_shells_is_not_empty() {
+            assert!(!DETECTED_SHELLS.is_empty());
+        }
+    }
+}