ai-session 0.5.0

//! Mockall Best Practices Tests for ai-session
//!
//! This file demonstrates mockall best practices for testing ai-session components.
//!
//! ## Best Practices Applied:
//! 1. Use `mock!` macro for defining mock types
//! 2. Set explicit expectations with `.expect_*()` methods
//! 3. Use `.times()` to verify call counts
//! 4. Use `.returning()` to define return values
//! 5. Use `.withf()` for argument matching
//! 6. Use `mockall::Sequence` for ordered call verification

use anyhow::Result;
use chrono::Utc;
use mockall::mock;
use mockall::predicate::*;
use std::path::PathBuf;
use uuid::Uuid;

// ============================================================================
// Mock Definitions
// ============================================================================

// Mock for ExternalIntegration trait
mock! {
    pub ExternalIntegration {
        fn name(&self) -> &'static str;
        fn initialize(&mut self) -> Result<()>;
        fn on_session_created(&self, session_id: &str) -> Result<()>;
        fn on_session_terminated(&self, session_id: &str) -> Result<()>;
        fn export_session_data(&self, session_id: &str) -> Result<serde_json::Value>;
    }
}

// Mock for Transport trait
mock! {
    pub Transport {
        fn send(&mut self, message: &str) -> Result<()>;
        fn receive(&mut self) -> Result<Option<String>>;
        fn close(&mut self) -> Result<()>;
    }
}

// Mock for Capabilities trait
mock! {
    pub Capabilities {
        fn request_capability(&self, capability: &Capability) -> Result<CapabilityToken>;
        fn has_capability(&self, capability: &Capability) -> bool;
        fn revoke_capability(&mut self, token: CapabilityToken) -> Result<()>;
    }
}

// Mock for SessionManager-like functionality
mock! {
    pub SessionManager {
        fn create_session(&self, config: SessionConfig) -> Result<String>;
        fn get_session(&self, id: &str) -> Option<SessionInfo>;
        fn terminate_session(&self, id: &str) -> Result<()>;
        fn list_sessions(&self) -> Vec<String>;
    }
}

// Mock for Context compression
mock! {
    pub ContextCompressor {
        fn compress(&self, input: &str) -> Result<Vec<u8>>;
        fn decompress(&self, input: &[u8]) -> Result<String>;
        fn compression_ratio(&self) -> f64;
    }
}

// ============================================================================
// Test Data Structures
// ============================================================================

#[derive(Debug, Clone, Hash, Eq, PartialEq)]
pub enum Capability {
    FileRead(PathBuf),
    FileWrite(PathBuf),
    NetworkAccess(String, u16),
    ProcessSpawn(String),
}

#[derive(Debug, Clone)]
pub struct CapabilityToken {
    pub id: Uuid,
    pub capability: Capability,
    pub expires_at: Option<chrono::DateTime<chrono::Utc>>,
}

#[derive(Debug, Clone, Default)]
pub struct SessionConfig {
    pub name: Option<String>,
    pub working_directory: Option<PathBuf>,
    pub enable_ai_features: bool,
    pub max_tokens: usize,
}

#[derive(Debug, Clone)]
pub struct SessionInfo {
    pub id: String,
    pub status: SessionStatus,
    pub created_at: chrono::DateTime<chrono::Utc>,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SessionStatus {
    Initializing,
    Running,
    Paused,
    Terminated,
}

// ============================================================================
// External Integration Tests
// ============================================================================

mod external_integration_tests {
    use super::*;

    /// Test integration initialization
    #[test]
    fn test_integration_initialization() {
        let mut mock = MockExternalIntegration::new();

        mock.expect_name().times(1).returning(|| "vscode");

        mock.expect_initialize().times(1).returning(|| Ok(()));

        assert_eq!(mock.name(), "vscode");
        assert!(mock.initialize().is_ok());
    }

    /// Test session lifecycle hooks
    #[test]
    fn test_session_lifecycle_hooks() {
        let mut mock = MockExternalIntegration::new();
        let session_id = "session-001";

        mock.expect_on_session_created()
            .with(eq(session_id))
            .times(1)
            .returning(|_| Ok(()));

        mock.expect_on_session_terminated()
            .with(eq(session_id))
            .times(1)
            .returning(|_| Ok(()));

        assert!(mock.on_session_created(session_id).is_ok());
        assert!(mock.on_session_terminated(session_id).is_ok());
    }

    /// Test session data export
    #[test]
    fn test_export_session_data() {
        let mut mock = MockExternalIntegration::new();

        mock.expect_export_session_data()
            .with(eq("session-test"))
            .times(1)
            .returning(|id| {
                Ok(serde_json::json!({
                    "session_id": id,
                    "commands_executed": 42,
                    "duration_seconds": 3600
                }))
            });

        let result = mock.export_session_data("session-test").unwrap();
        assert_eq!(result["commands_executed"], 42);
    }

    /// Test integration error handling
    #[test]
    fn test_integration_error_handling() {
        let mut mock = MockExternalIntegration::new();

        mock.expect_initialize()
            .times(1)
            .returning(|| Err(anyhow::anyhow!("Connection refused")));

        let result = mock.initialize();
        assert!(result.is_err());
        assert!(result.unwrap_err().to_string().contains("refused"));
    }
}

// ============================================================================
// Transport Tests
// ============================================================================

mod transport_tests {
    use super::*;

    /// Test message send/receive cycle
    #[test]
    fn test_send_receive_cycle() {
        let mut mock = MockTransport::new();
        let mut seq = mockall::Sequence::new();

        // Send must happen before receive
        mock.expect_send()
            .with(eq(r#"{"method":"ping"}"#))
            .times(1)
            .in_sequence(&mut seq)
            .returning(|_| Ok(()));

        mock.expect_receive()
            .times(1)
            .in_sequence(&mut seq)
            .returning(|| Ok(Some(r#"{"result":"pong"}"#.to_string())));

        assert!(mock.send(r#"{"method":"ping"}"#).is_ok());
        let response = mock.receive().unwrap();
        assert!(response.unwrap().contains("pong"));
    }

    /// Test transport close
    #[test]
    fn test_transport_close() {
        let mut mock = MockTransport::new();

        mock.expect_close().times(1).returning(|| Ok(()));

        mock.expect_send().times(0); // No sends after close

        assert!(mock.close().is_ok());
    }

    /// Test receive timeout (returns None)
    #[test]
    fn test_receive_timeout() {
        let mut mock = MockTransport::new();

        mock.expect_receive().times(1).returning(|| Ok(None));

        let result = mock.receive().unwrap();
        assert!(result.is_none());
    }

    /// Test multiple message exchange
    #[test]
    fn test_multiple_messages() {
        let mut mock = MockTransport::new();
        let counter = std::sync::atomic::AtomicUsize::new(0);

        mock.expect_send().times(3).returning(|_| Ok(()));

        mock.expect_receive().times(3).returning(move || {
            let n = counter.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
            Ok(Some(format!("response-{}", n)))
        });

        for i in 0..3 {
            mock.send(&format!("request-{}", i)).unwrap();
            let resp = mock.receive().unwrap().unwrap();
            assert!(resp.starts_with("response-"));
        }
    }
}

// ============================================================================
// Capabilities Tests
// ============================================================================

mod capabilities_tests {
    use super::*;

    /// Test capability request and check
    #[test]
    fn test_capability_request() {
        let mut mock = MockCapabilities::new();
        let cap = Capability::FileRead(PathBuf::from("/tmp/test.txt"));

        let token = CapabilityToken {
            id: Uuid::new_v4(),
            capability: cap.clone(),
            expires_at: None,
        };
        let token_clone = token.clone();

        mock.expect_request_capability()
            .withf(|c| matches!(c, Capability::FileRead(_)))
            .times(1)
            .returning(move |_| Ok(token_clone.clone()));

        mock.expect_has_capability()
            .with(eq(cap.clone()))
            .times(1)
            .returning(|_| true);

        let result = mock.request_capability(&cap).unwrap();
        assert_eq!(result.capability, cap);
        assert!(mock.has_capability(&cap));
    }

    /// Test capability revocation
    #[test]
    fn test_capability_revocation() {
        let mut mock = MockCapabilities::new();
        let cap = Capability::NetworkAccess("localhost".to_string(), 8080);

        let token = CapabilityToken {
            id: Uuid::new_v4(),
            capability: cap.clone(),
            expires_at: Some(Utc::now()),
        };

        mock.expect_revoke_capability()
            .withf(|t| matches!(t.capability, Capability::NetworkAccess(_, 8080)))
            .times(1)
            .returning(|_| Ok(()));

        mock.expect_has_capability()
            .with(eq(cap.clone()))
            .times(1)
            .returning(|_| false);

        assert!(mock.revoke_capability(token).is_ok());
        assert!(!mock.has_capability(&cap));
    }

    /// Test denied capability
    #[test]
    fn test_capability_denied() {
        let mut mock = MockCapabilities::new();
        let cap = Capability::ProcessSpawn("rm -rf /".to_string());

        mock.expect_request_capability()
            .times(1)
            .returning(|_| Err(anyhow::anyhow!("Capability denied: dangerous operation")));

        mock.expect_has_capability()
            .with(eq(cap.clone()))
            .times(1)
            .returning(|_| false);

        assert!(mock.request_capability(&cap).is_err());
        assert!(!mock.has_capability(&cap));
    }
}

// ============================================================================
// Session Manager Tests
// ============================================================================

mod session_manager_tests {
    use super::*;

    /// Test session creation and retrieval
    #[test]
    fn test_session_lifecycle() {
        let mut mock = MockSessionManager::new();
        let config = SessionConfig {
            name: Some("test-session".to_string()),
            enable_ai_features: true,
            max_tokens: 4096,
            ..Default::default()
        };

        mock.expect_create_session()
            .times(1)
            .returning(|_| Ok("session-123".to_string()));

        mock.expect_get_session()
            .with(eq("session-123"))
            .times(1)
            .returning(|id| {
                Some(SessionInfo {
                    id: id.to_string(),
                    status: SessionStatus::Running,
                    created_at: Utc::now(),
                })
            });

        mock.expect_terminate_session()
            .with(eq("session-123"))
            .times(1)
            .returning(|_| Ok(()));

        let session_id = mock.create_session(config).unwrap();
        assert_eq!(session_id, "session-123");

        let info = mock.get_session(&session_id).unwrap();
        assert_eq!(info.status, SessionStatus::Running);

        assert!(mock.terminate_session(&session_id).is_ok());
    }

    /// Test list sessions
    #[test]
    fn test_list_sessions() {
        let mut mock = MockSessionManager::new();

        mock.expect_list_sessions().times(1).returning(|| {
            vec![
                "session-1".to_string(),
                "session-2".to_string(),
                "session-3".to_string(),
            ]
        });

        let sessions = mock.list_sessions();
        assert_eq!(sessions.len(), 3);
        assert!(sessions.contains(&"session-2".to_string()));
    }

    /// Test get nonexistent session
    #[test]
    fn test_get_nonexistent_session() {
        let mut mock = MockSessionManager::new();

        mock.expect_get_session()
            .with(eq("nonexistent"))
            .times(1)
            .returning(|_| None);

        assert!(mock.get_session("nonexistent").is_none());
    }
}

// ============================================================================
// Context Compressor Tests
// ============================================================================

mod context_compressor_tests {
    use super::*;

    /// Test compression and decompression
    #[test]
    fn test_compression_roundtrip() {
        let mut mock = MockContextCompressor::new();
        let original = "This is a test message for compression";

        mock.expect_compress()
            .with(eq(original))
            .times(1)
            .returning(|_| Ok(vec![1, 2, 3, 4, 5]));

        // Use withf for dynamic matching instead of eq with borrowed data
        mock.expect_decompress()
            .withf(|input| !input.is_empty())
            .times(1)
            .returning(|_| Ok("This is a test message for compression".to_string()));

        let compressed_result = mock.compress(original).unwrap();
        assert!(!compressed_result.is_empty());

        let decompressed = mock.decompress(&compressed_result).unwrap();
        assert_eq!(decompressed, original);
    }

    /// Test compression ratio
    #[test]
    fn test_compression_ratio() {
        let mut mock = MockContextCompressor::new();

        // Expect 93% compression (0.07 ratio means 93% reduction)
        mock.expect_compression_ratio().times(1).returning(|| 0.07);

        let ratio = mock.compression_ratio();
        assert!(ratio < 0.1); // Less than 10% of original size
    }

    /// Test compression error
    #[test]
    fn test_compression_error() {
        let mut mock = MockContextCompressor::new();

        mock.expect_compress()
            .times(1)
            .returning(|_| Err(anyhow::anyhow!("Input too large")));

        assert!(mock.compress("huge input").is_err());
    }
}

// ============================================================================
// Integration Pattern Tests
// ============================================================================

mod integration_patterns {
    use super::*;

    /// Test full workflow with multiple mocks
    #[test]
    fn test_session_with_integration_workflow() {
        let mut session_mock = MockSessionManager::new();
        let mut integration_mock = MockExternalIntegration::new();
        let mut compressor_mock = MockContextCompressor::new();

        // Setup session creation
        session_mock
            .expect_create_session()
            .times(1)
            .returning(|_| Ok("workflow-session".to_string()));

        // Setup integration notification
        integration_mock
            .expect_on_session_created()
            .with(eq("workflow-session"))
            .times(1)
            .returning(|_| Ok(()));

        // Setup context compression
        compressor_mock
            .expect_compress()
            .times(1)
            .returning(|_| Ok(vec![1, 2, 3]));

        // Execute workflow
        let session_id = session_mock
            .create_session(SessionConfig::default())
            .unwrap();

        integration_mock.on_session_created(&session_id).unwrap();

        let _ = compressor_mock.compress("session context data").unwrap();
    }

    /// Test capability-based operation
    #[test]
    fn test_capability_gated_operation() {
        let mut caps_mock = MockCapabilities::new();
        let mut transport_mock = MockTransport::new();

        let network_cap = Capability::NetworkAccess("api.example.com".to_string(), 443);

        // First check capability
        caps_mock
            .expect_has_capability()
            .with(eq(network_cap.clone()))
            .times(1)
            .returning(|_| true);

        // Then allow transport operation
        transport_mock.expect_send().times(1).returning(|_| Ok(()));

        // Simulate capability check before network operation
        if caps_mock.has_capability(&network_cap) {
            transport_mock.send("api request").unwrap();
        }
    }
}