detached-shell 0.1.4

#[cfg(test)]
mod tests {
    use detached_shell::Session;
    use tempfile::TempDir;

    // Mock session for testing
    fn create_mock_session(id: &str, name: Option<String>) -> Session {
        let temp_dir = TempDir::new().unwrap();
        Session {
            id: id.to_string(),
            name,
            pid: 12345,
            created_at: chrono::Utc::now(),
            socket_path: temp_dir.path().join("test.sock"),
            shell: "/bin/bash".to_string(),
            working_dir: "/home/test".to_string(),
            attached: false,
        }
    }

    mod session_handlers {
        use super::*;

        #[test]
        fn test_handle_new_session_with_name() {
            // This would need actual implementation mocking
            // For now, we test the logic flow
            let _name = Some("test-session".to_string());
            let _attach = false;

            // We can't easily test this without mocking SessionManager
            // but we can ensure the function exists and compiles
            assert!(true);
        }

        #[test]
        fn test_kill_single_session_by_id() {
            let sessions = vec![
                create_mock_session("abc123", None),
                create_mock_session("def456", Some("test".to_string())),
            ];

            // Test partial ID matching logic
            let matching: Vec<_> = sessions
                .iter()
                .filter(|s| s.id.starts_with("abc"))
                .collect();

            assert_eq!(matching.len(), 1);
            assert_eq!(matching[0].id, "abc123");
        }

        #[test]
        fn test_kill_single_session_by_name() {
            let sessions = vec![
                create_mock_session("abc123", Some("production".to_string())),
                create_mock_session("def456", Some("development".to_string())),
            ];

            // Test name matching logic
            let matching: Vec<_> = sessions
                .iter()
                .filter(|s| {
                    if let Some(ref name) = s.name {
                        name.starts_with("prod")
                    } else {
                        false
                    }
                })
                .collect();

            assert_eq!(matching.len(), 1);
            assert_eq!(matching[0].name, Some("production".to_string()));
        }

        #[test]
        fn test_session_name_case_insensitive_matching() {
            let sessions = vec![
                create_mock_session("abc123", Some("MySession".to_string())),
                create_mock_session("def456", Some("OtherSession".to_string())),
            ];

            let search_term = "mysess";
            let matching: Vec<_> = sessions
                .iter()
                .filter(|s| {
                    if let Some(ref name) = s.name {
                        name.to_lowercase().starts_with(&search_term.to_lowercase())
                    } else {
                        false
                    }
                })
                .collect();

            assert_eq!(matching.len(), 1);
            assert_eq!(matching[0].name, Some("MySession".to_string()));
        }
    }

    mod info_handlers {
        use super::*;

        #[test]
        fn test_session_display_formatting() {
            let session = create_mock_session("test123", Some("test-session".to_string()));
            let display_name = session.display_name();
            assert_eq!(display_name, "test-session [test123]");
        }

        #[test]
        fn test_session_display_no_name() {
            let session = create_mock_session("test123", None);
            let display_name = session.display_name();
            assert_eq!(display_name, "test123");
        }

        #[test]
        fn test_session_history_event_formatting() {
            use detached_shell::history_v2::{HistoryEntry, SessionEvent};

            let event = SessionEvent::Created;
            let entry = HistoryEntry {
                session_id: "test123".to_string(),
                session_name: Some("test".to_string()),
                event,
                timestamp: chrono::Utc::now(),
                pid: 12345,
                shell: "/bin/bash".to_string(),
                working_dir: "/home/test".to_string(),
                duration_seconds: None,
            };

            // Test that the entry can be created and fields are accessible
            assert_eq!(entry.session_id, "test123");
            assert_eq!(entry.session_name, Some("test".to_string()));
            assert!(matches!(entry.event, SessionEvent::Created));
        }

        #[test]
        fn test_session_event_variants() {
            use detached_shell::history_v2::SessionEvent;

            // Test all event variants
            let events = vec![
                SessionEvent::Created,
                SessionEvent::Attached,
                SessionEvent::Detached,
                SessionEvent::Killed,
                SessionEvent::Crashed,
                SessionEvent::Renamed {
                    from: Some("old".to_string()),
                    to: "new".to_string(),
                },
            ];

            // Ensure all variants can be created and matched
            for event in events {
                match event {
                    SessionEvent::Created => assert!(true),
                    SessionEvent::Attached => assert!(true),
                    SessionEvent::Detached => assert!(true),
                    SessionEvent::Killed => assert!(true),
                    SessionEvent::Crashed => assert!(true),
                    SessionEvent::Renamed { from: _, to: _ } => assert!(true),
                }
            }
        }
    }

    mod edge_cases {
        use super::*;

        #[test]
        fn test_empty_session_name() {
            let session = create_mock_session("test123", Some("".to_string()));
            assert_eq!(session.name, Some("".to_string()));
            assert_eq!(session.display_name(), " [test123]");
        }

        #[test]
        fn test_very_long_session_id() {
            let long_id = "a".repeat(100);
            let session = create_mock_session(&long_id, None);
            assert_eq!(session.id.len(), 100);
        }

        #[test]
        fn test_special_characters_in_name() {
            let special_name = "test!@#$%^&*()[]{}".to_string();
            let session = create_mock_session("test123", Some(special_name.clone()));
            assert_eq!(session.name, Some(special_name));
        }

        #[test]
        fn test_session_id_partial_matching() {
            let sessions = vec![
                create_mock_session("abc123def", None),
                create_mock_session("abc456ghi", None),
                create_mock_session("xyz789jkl", None),
            ];

            // Test prefix matching
            let matching: Vec<_> = sessions
                .iter()
                .filter(|s| s.id.starts_with("abc"))
                .collect();
            assert_eq!(matching.len(), 2);

            // Test unique partial match
            let matching: Vec<_> = sessions
                .iter()
                .filter(|s| s.id.starts_with("xyz"))
                .collect();
            assert_eq!(matching.len(), 1);
        }

        #[test]
        fn test_ambiguous_session_matching() {
            let sessions = vec![
                create_mock_session("session1", Some("production".to_string())),
                create_mock_session("session2", Some("production-backup".to_string())),
            ];

            // Ambiguous name prefix
            let search_term = "prod";
            let matching: Vec<_> = sessions
                .iter()
                .filter(|s| {
                    if let Some(ref name) = s.name {
                        name.to_lowercase().starts_with(&search_term.to_lowercase())
                    } else {
                        false
                    }
                })
                .collect();

            // Should match both sessions
            assert_eq!(matching.len(), 2);
        }
    }
}