leptos-sync-core 0.9.0

//! Test-Driven Development tests for real WebSocket integration with leptos-ws-pro
//! 
//! These tests define the expected behavior for actual WebSocket functionality
//! using leptos-ws-pro APIs before implementation.

use super::{SyncTransport, TransportError};
use crate::transport::leptos_ws_pro_transport::{LeptosWsProTransport, LeptosWsProConfig};
use serde::{Deserialize, Serialize};
use std::time::Duration;
use tokio::time::timeout;

#[derive(Debug, Clone, Serialize, Deserialize)]
struct RealTimeMessage {
    id: String,
    content: String,
    timestamp: u64,
    message_type: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
struct SyncOperation {
    operation: String,
    data: serde_json::Value,
    client_id: String,
    sequence: u64,
}

/// Test configuration for real WebSocket integration
#[derive(Debug, Clone)]
pub struct RealWebSocketTestConfig {
    pub url: String,
    pub timeout: Duration,
    pub max_reconnect_attempts: usize,
    pub heartbeat_interval: Duration,
    pub connection_timeout: Duration,
    pub retry_delay: Duration,
    pub message_timeout: Duration,
}

impl Default for RealWebSocketTestConfig {
    fn default() -> Self {
        Self {
            url: "ws://localhost:8080".to_string(),
            timeout: Duration::from_secs(30),
            max_reconnect_attempts: 5,
            heartbeat_interval: Duration::from_secs(30),
            connection_timeout: Duration::from_secs(10),
            retry_delay: Duration::from_millis(1000),
            message_timeout: Duration::from_secs(5),
        }
    }
}

impl From<RealWebSocketTestConfig> for LeptosWsProConfig {
    fn from(config: RealWebSocketTestConfig) -> Self {
        Self {
            url: config.url,
            timeout: config.timeout,
            max_reconnect_attempts: config.max_reconnect_attempts,
            heartbeat_interval: config.heartbeat_interval,
            connection_timeout: config.connection_timeout,
            retry_delay: config.retry_delay,
        }
    }
}

#[cfg(test)]
mod real_websocket_integration_tests {
    use super::*;

    /// Test 1: Real WebSocket Connection Establishment
    /// 
    /// This test verifies that the transport can establish a real WebSocket
    /// connection using leptos-ws-pro APIs.
    #[tokio::test]
    async fn test_real_websocket_connection() {
        let config = RealWebSocketTestConfig::default();
        let transport = LeptosWsProTransport::new(config.into());
        
        // Initially disconnected
        assert!(!transport.is_connected());
        
        // Attempt to connect to a real WebSocket server
        let result = timeout(Duration::from_secs(5), transport.connect()).await;
        
        match result {
            Ok(Ok(())) => {
                // Connection succeeded
                assert!(transport.is_connected());
                
                // Should be able to disconnect
                let disconnect_result = transport.disconnect().await;
                assert!(disconnect_result.is_ok());
                assert!(!transport.is_connected());
            }
            Ok(Err(e)) => {
                // Connection failed (expected if no server running)
                assert!(!transport.is_connected());
                println!("Connection failed as expected: {}", e);
            }
            Err(_) => {
                // Timeout occurred
                assert!(!transport.is_connected());
                println!("Connection timeout as expected");
            }
        }
    }

    /// Test 2: Real Message Sending and Receiving
    /// 
    /// This test verifies that the transport can send and receive real messages
    /// through a WebSocket connection.
    #[tokio::test]
    async fn test_real_message_sending_receiving() {
        let config = RealWebSocketTestConfig::default();
        let transport = LeptosWsProTransport::new(config.into());
        
        // Connect to server
        let connect_result = timeout(Duration::from_secs(5), transport.connect()).await;
        
        if let Ok(Ok(())) = connect_result {
            // Connection successful, test message sending
            let test_message = RealTimeMessage {
                id: "test_001".to_string(),
                content: "Hello, Real WebSocket!".to_string(),
                timestamp: chrono::Utc::now().timestamp() as u64,
                message_type: "test".to_string(),
            };
            
            let serialized = serde_json::to_vec(&test_message).unwrap();
            
            // Send message
            let send_result = transport.send(&serialized).await;
            assert!(send_result.is_ok(), "Failed to send message: {:?}", send_result);
            
            // Wait for potential response
            let receive_result = timeout(
                Duration::from_secs(2), 
                transport.receive()
            ).await;
            
            match receive_result {
                Ok(Ok(messages)) => {
                    // Received messages successfully
                    println!("Received {} messages", messages.len());
                    for (i, message) in messages.iter().enumerate() {
                        println!("Message {}: {} bytes", i, message.len());
                    }
                }
                Ok(Err(e)) => {
                    println!("Receive error: {}", e);
                }
                Err(_) => {
                    println!("Receive timeout (no messages received)");
                }
            }
            
            // Disconnect
            let _ = transport.disconnect().await;
        } else {
            println!("Skipping message test - no server connection available");
        }
    }

    /// Test 3: Real Sync Operations
    /// 
    /// This test verifies that the transport can handle real sync operations
    /// with proper message formatting and handling.
    #[tokio::test]
    async fn test_real_sync_operations() {
        let config = RealWebSocketTestConfig::default();
        let transport = LeptosWsProTransport::new(config.into());
        
        // Connect to server
        let connect_result = timeout(Duration::from_secs(5), transport.connect()).await;
        
        if let Ok(Ok(())) = connect_result {
            // Test sync operation
            let sync_op = SyncOperation {
                operation: "insert".to_string(),
                data: serde_json::json!({
                    "id": "item_123",
                    "content": "New item",
                    "position": 0
                }),
                client_id: "client_001".to_string(),
                sequence: 1,
            };
            
            let serialized = serde_json::to_vec(&sync_op).unwrap();
            
            // Send sync operation
            let send_result = transport.send(&serialized).await;
            assert!(send_result.is_ok(), "Failed to send sync operation: {:?}", send_result);
            
            // Test multiple sync operations
            for i in 2..=5 {
                let sync_op = SyncOperation {
                    operation: "update".to_string(),
                    data: serde_json::json!({
                        "id": "item_123",
                        "content": format!("Updated item {}", i),
                        "version": i
                    }),
                    client_id: "client_001".to_string(),
                    sequence: i,
                };
                
                let serialized = serde_json::to_vec(&sync_op).unwrap();
                let send_result = transport.send(&serialized).await;
                assert!(send_result.is_ok(), "Failed to send sync operation {}: {:?}", i, send_result);
            }
            
            // Disconnect
            let _ = transport.disconnect().await;
        } else {
            println!("Skipping sync operations test - no server connection available");
        }
    }

    /// Test 4: Real Reconnection with Server Restart
    /// 
    /// This test verifies that the transport can handle server disconnections
    /// and reconnections properly.
    #[tokio::test]
    async fn test_real_reconnection_behavior() {
        let config = RealWebSocketTestConfig {
            max_reconnect_attempts: 3,
            retry_delay: Duration::from_millis(500),
            ..Default::default()
        };
        let transport = LeptosWsProTransport::new(config.into());
        
        // Attempt initial connection
        let connect_result = timeout(Duration::from_secs(5), transport.connect()).await;
        
        if let Ok(Ok(())) = connect_result {
            println!("Initial connection successful");
            
            // Send a test message
            let test_message = RealTimeMessage {
                id: "reconnect_test".to_string(),
                content: "Testing reconnection".to_string(),
                timestamp: chrono::Utc::now().timestamp() as u64,
                message_type: "reconnect_test".to_string(),
            };
            
            let serialized = serde_json::to_vec(&test_message).unwrap();
            let send_result = transport.send(&serialized).await;
            assert!(send_result.is_ok(), "Failed to send test message: {:?}", send_result);
            
            // Simulate connection loss by disconnecting
            let disconnect_result = transport.disconnect().await;
            assert!(disconnect_result.is_ok());
            assert!(!transport.is_connected());
            
            // Attempt reconnection
            let reconnect_result = timeout(Duration::from_secs(10), transport.connect()).await;
            
            match reconnect_result {
                Ok(Ok(())) => {
                    println!("Reconnection successful");
                    assert!(transport.is_connected());
                    
                    // Send another message after reconnection
                    let test_message = RealTimeMessage {
                        id: "after_reconnect".to_string(),
                        content: "Message after reconnection".to_string(),
                        timestamp: chrono::Utc::now().timestamp() as u64,
                        message_type: "after_reconnect".to_string(),
                    };
                    
                    let serialized = serde_json::to_vec(&test_message).unwrap();
                    let send_result = transport.send(&serialized).await;
                    assert!(send_result.is_ok(), "Failed to send message after reconnection: {:?}", send_result);
                }
                Ok(Err(e)) => {
                    println!("Reconnection failed: {}", e);
                }
                Err(_) => {
                    println!("Reconnection timeout");
                }
            }
            
            // Final disconnect
            let _ = transport.disconnect().await;
        } else {
            println!("Skipping reconnection test - no server connection available");
        }
    }

    /// Test 5: Real Heartbeat Mechanism
    /// 
    /// This test verifies that the transport implements proper heartbeat
    /// functionality to keep connections alive.
    #[tokio::test]
    async fn test_real_heartbeat_mechanism() {
        let config = RealWebSocketTestConfig {
            heartbeat_interval: Duration::from_millis(1000), // 1 second for testing
            ..Default::default()
        };
        let transport = LeptosWsProTransport::new(config.into());
        
        // Connect to server
        let connect_result = timeout(Duration::from_secs(5), transport.connect()).await;
        
        if let Ok(Ok(())) = connect_result {
            println!("Connected, testing heartbeat mechanism");
            
            // Wait for heartbeat to be sent
            tokio::time::sleep(Duration::from_millis(1500)).await;
            
            // Connection should still be alive
            assert!(transport.is_connected(), "Connection should still be alive after heartbeat");
            
            // Send a regular message to verify connection is working
            let test_message = RealTimeMessage {
                id: "heartbeat_test".to_string(),
                content: "Testing heartbeat".to_string(),
                timestamp: chrono::Utc::now().timestamp() as u64,
                message_type: "heartbeat_test".to_string(),
            };
            
            let serialized = serde_json::to_vec(&test_message).unwrap();
            let send_result = transport.send(&serialized).await;
            assert!(send_result.is_ok(), "Failed to send message after heartbeat: {:?}", send_result);
            
            // Disconnect
            let _ = transport.disconnect().await;
        } else {
            println!("Skipping heartbeat test - no server connection available");
        }
    }

    /// Test 6: Real Concurrent Operations
    /// 
    /// This test verifies that the transport can handle concurrent send/receive
    /// operations safely.
    #[tokio::test]
    async fn test_real_concurrent_operations() {
        let config = RealWebSocketTestConfig::default();
        let transport = LeptosWsProTransport::new(config.into());
        
        // Connect to server
        let connect_result = timeout(Duration::from_secs(5), transport.connect()).await;
        
        if let Ok(Ok(())) = connect_result {
            println!("Connected, testing concurrent operations");
            
            // Spawn multiple concurrent send operations
            let mut send_handles = Vec::new();
            for i in 0..10 {
                let transport_clone = transport.clone();
                let handle = tokio::spawn(async move {
                    let test_message = RealTimeMessage {
                        id: format!("concurrent_{}", i),
                        content: format!("Concurrent message {}", i),
                        timestamp: chrono::Utc::now().timestamp() as u64,
                        message_type: "concurrent".to_string(),
                    };
                    
                    let serialized = serde_json::to_vec(&test_message).unwrap();
                    transport_clone.send(&serialized).await
                });
                send_handles.push(handle);
            }
            
            // Spawn concurrent receive operations
            let mut receive_handles = Vec::new();
            for _ in 0..5 {
                let transport_clone = transport.clone();
                let handle = tokio::spawn(async move {
                    timeout(Duration::from_secs(2), transport_clone.receive()).await
                });
                receive_handles.push(handle);
            }
            
            // Wait for all send operations to complete
            for (i, handle) in send_handles.into_iter().enumerate() {
                let result = handle.await.unwrap();
                assert!(result.is_ok(), "Concurrent send operation {} failed: {:?}", i, result);
            }
            
            // Wait for all receive operations to complete
            for (i, handle) in receive_handles.into_iter().enumerate() {
                let result = handle.await.unwrap();
                match result {
                    Ok(Ok(messages)) => {
                        println!("Concurrent receive {} got {} messages", i, messages.len());
                    }
                    Ok(Err(e)) => {
                        println!("Concurrent receive {} error: {}", i, e);
                    }
                    Err(_) => {
                        println!("Concurrent receive {} timeout", i);
                    }
                }
            }
            
            // Connection should still be alive
            assert!(transport.is_connected(), "Connection should still be alive after concurrent operations");
            
            // Disconnect
            let _ = transport.disconnect().await;
        } else {
            println!("Skipping concurrent operations test - no server connection available");
        }
    }

    /// Test 7: Real Error Handling and Recovery
    /// 
    /// This test verifies that the transport handles various error conditions
    /// gracefully and recovers appropriately.
    #[tokio::test]
    async fn test_real_error_handling_recovery() {
        let config = RealWebSocketTestConfig::default();
        let transport = LeptosWsProTransport::new(config.into());
        
        // Test 1: Connection to invalid URL
        let invalid_config = RealWebSocketTestConfig {
            url: "ws://invalid-url-that-does-not-exist:9999".to_string(),
            ..Default::default()
        };
        let invalid_transport = LeptosWsProTransport::new(invalid_config.into());
        
        let connect_result = timeout(Duration::from_secs(5), invalid_transport.connect()).await;
        match connect_result {
            Ok(Ok(())) => {
                // Unexpected success
                assert!(invalid_transport.is_connected());
                let _ = invalid_transport.disconnect().await;
            }
            Ok(Err(e)) => {
                // Expected failure
                assert!(!invalid_transport.is_connected());
                println!("Expected connection failure: {}", e);
            }
            Err(_) => {
                // Timeout
                assert!(!invalid_transport.is_connected());
                println!("Expected connection timeout");
            }
        }
        
        // Test 2: Send to disconnected transport
        let send_result = invalid_transport.send(b"test message").await;
        assert!(send_result.is_err(), "Send to disconnected transport should fail");
        
        // Test 3: Receive from disconnected transport
        let receive_result = invalid_transport.receive().await;
        assert!(receive_result.is_ok(), "Receive from disconnected transport should return empty");
        assert!(receive_result.unwrap().is_empty(), "Receive from disconnected transport should return empty messages");
    }

    /// Test 8: Real Performance Characteristics
    /// 
    /// This test verifies that the transport meets performance requirements
    /// for real-time applications.
    #[tokio::test]
    async fn test_real_performance_characteristics() {
        let config = RealWebSocketTestConfig::default();
        let transport = LeptosWsProTransport::new(config.into());
        
        // Connect to server
        let connect_result = timeout(Duration::from_secs(5), transport.connect()).await;
        
        if let Ok(Ok(())) = connect_result {
            println!("Connected, testing performance characteristics");
            
            // Test message throughput
            let start_time = std::time::Instant::now();
            let message_count = 100;
            
            for i in 0..message_count {
                let test_message = RealTimeMessage {
                    id: format!("perf_{}", i),
                    content: format!("Performance test message {}", i),
                    timestamp: chrono::Utc::now().timestamp() as u64,
                    message_type: "performance".to_string(),
                };
                
                let serialized = serde_json::to_vec(&test_message).unwrap();
                let send_result = transport.send(&serialized).await;
                assert!(send_result.is_ok(), "Failed to send performance test message {}: {:?}", i, send_result);
            }
            
            let elapsed = start_time.elapsed();
            let messages_per_second = message_count as f64 / elapsed.as_secs_f64();
            
            println!("Sent {} messages in {:?} ({:.2} msg/s)", message_count, elapsed, messages_per_second);
            
            // Performance should be reasonable (at least 10 messages per second)
            assert!(messages_per_second > 10.0, "Performance too low: {:.2} msg/s", messages_per_second);
            
            // Test large message handling
            let large_content = "x".repeat(10000); // 10KB message
            let large_message = RealTimeMessage {
                id: "large_message".to_string(),
                content: large_content,
                timestamp: chrono::Utc::now().timestamp() as u64,
                message_type: "large".to_string(),
            };
            
            let serialized = serde_json::to_vec(&large_message).unwrap();
            let large_send_start = std::time::Instant::now();
            let send_result = transport.send(&serialized).await;
            let large_send_elapsed = large_send_start.elapsed();
            
            assert!(send_result.is_ok(), "Failed to send large message: {:?}", send_result);
            assert!(large_send_elapsed < Duration::from_millis(100), "Large message send too slow: {:?}", large_send_elapsed);
            
            println!("Large message ({} bytes) sent in {:?}", serialized.len(), large_send_elapsed);
            
            // Disconnect
            let _ = transport.disconnect().await;
        } else {
            println!("Skipping performance test - no server connection available");
        }
    }
}

/// Integration tests that require a running WebSocket server
#[cfg(test)]
mod server_integration_tests {
    use super::*;

    /// Test 9: Full Integration with Real Server
    /// 
    /// This test requires a running WebSocket server and tests the complete
    /// integration with leptos-ws-pro.
    #[tokio::test]
    #[ignore] // Ignored by default, run with: cargo test -- --ignored
    async fn test_full_integration_with_real_server() {
        // This test requires a real WebSocket server running
        // It will be enabled when we implement the server integration
        println!("Full integration test with real server is disabled - requires server implementation");
    }

    /// Test 10: Server Message Protocol Compatibility
    /// 
    /// This test verifies compatibility with the existing server message protocol.
    #[tokio::test]
    #[ignore] // Ignored by default, run with: cargo test -- --ignored
    async fn test_server_message_protocol_compatibility() {
        // This test will verify compatibility with the existing server protocol
        println!("Server message protocol compatibility test is disabled - requires server implementation");
    }
}