quoter/tests/redis_connection_test.rs

use redis::{Client, AsyncCommands};
use std::env;

#[tokio::test]
async fn test_redis_url_parsing() {
    // Тестируем различные форматы Redis URL
    
    let test_urls = vec![
        // Простой URL без пароля
        "redis://localhost:6379",
        // URL с паролем (должен использовать дефолтное имя пользователя 'redis')
        "redis://:password@localhost:6379",
        // URL с пользователем и паролем
        "redis://user:password@localhost:6379",
        // URL с длинным hex паролем (как в Dokku) - должен использовать дефолтное имя 'redis'
        "redis://:dbc5f9f9007c555e209964454c9d6abecae5f1db72e490acd5c94354dc012282@dokku-redis-discoursio-redis:6379",
        // URL с IP адресом
        "redis://172.17.0.3:6379",
        // URL с exposed портом
        "redis://localhost:12389",
        // Тест с явным указанием дефолтного пользователя 'redis'
        "redis://redis:password@localhost:6379",
        // Тест с пустым пользователем и паролем (должен работать как без аутентификации)
        "redis://:@localhost:6379",
    ];

    for url in test_urls {
        // Парсим URL для детального вывода
        if let Ok(parsed) = url::Url::parse(url) {
            println!("Testing Redis URL: {}", url.replace(&url.split('@').nth(0).unwrap_or(""), "***"));
            println!("  Host: {}", parsed.host_str().unwrap_or("none"));
            println!("  Port: {}", parsed.port().unwrap_or(0));
            println!("  Username: '{}'", parsed.username());
            println!("  Password: '{}'", if parsed.password().is_some() { "***" } else { "none" });
        } else {
            println!("Testing Redis URL: {}", url);
        }
        
        match Client::open(url) {
            Ok(client) => {
                println!("✅ URL parsed successfully");
                
                // Попробуем подключиться (с коротким таймаутом)
                match tokio::time::timeout(
                    std::time::Duration::from_secs(2),
                    client.get_multiplexed_async_connection()
                ).await {
                    Ok(Ok(_)) => println!("✅ Connection successful"),
                    Ok(Err(e)) => println!("❌ Connection failed: {}", e),
                    Err(_) => println!("⏰ Connection timeout"),
                }
            }
            Err(e) => {
                println!("❌ URL parsing failed: {}", e);
            }
        }
        println!("---");
    }
}

#[tokio::test]
async fn test_redis_connection_with_env() {
        // Тестируем с реальным REDIS_URL из окружения
    if let Ok(redis_url) = env::var("REDIS_URL") {
        println!("Testing with real REDIS_URL: {}", 
                 redis_url.replace(&redis_url.split('@').nth(0).unwrap_or(""), "***"));
        
        // Парсим реальный URL для детального вывода
        if let Ok(parsed) = url::Url::parse(&redis_url) {
            println!("  Host: {}", parsed.host_str().unwrap_or("none"));
            println!("  Port: {}", parsed.port().unwrap_or(0));
            println!("  Username: '{}'", parsed.username());
            println!("  Password: '{}'", if parsed.password().is_some() { "***" } else { "none" });
        }
        
        match Client::open(redis_url) {
            Ok(client) => {
                println!("✅ Real URL parsed successfully");
                
                match tokio::time::timeout(
                    std::time::Duration::from_secs(5),
                    client.get_multiplexed_async_connection()
                ).await {
                    Ok(Ok(mut conn)) => {
                        println!("✅ Real connection successful");
                        
                        // Попробуем выполнить простую команду
                        match tokio::time::timeout(
                            std::time::Duration::from_secs(2),
                            conn.ping::<String>()
                        ).await {
                            Ok(Ok(result)) => println!("✅ PING successful: {}", result),
                            Ok(Err(e)) => println!("❌ PING failed: {}", e),
                            Err(_) => println!("⏰ PING timeout"),
                        }
                    }
                    Ok(Err(e)) => println!("❌ Real connection failed: {}", e),
                    Err(_) => println!("⏰ Real connection timeout"),
                }
            }
            Err(e) => {
                println!("❌ Real URL parsing failed: {}", e);
            }
        }
    } else {
        println!("⚠️ REDIS_URL not set, skipping real connection test");
    }
}

#[test]
fn test_redis_url_components() {
    // Тестируем парсинг компонентов URL
    let test_url = "redis://:dbc5f9f9007c555e209964454c9d6abecae5f1db72e490acd5c94354dc012282@dokku-redis-discoursio-redis:6379";
    
    if let Ok(parsed) = url::Url::parse(test_url) {
        println!("✅ URL parsed successfully");
        println!("  Scheme: {}", parsed.scheme());
        println!("  Host: {}", parsed.host_str().unwrap_or("none"));
        println!("  Port: {}", parsed.port().unwrap_or(0));
        println!("  Username: '{}'", parsed.username());
        println!("  Password: {}", if parsed.password().is_some() { "***" } else { "none" });
        println!("  Path: {}", parsed.path());
        
        // Проверяем, что пустое имя пользователя означает дефолтное 'redis'
        if parsed.username().is_empty() && parsed.password().is_some() {
            println!("  ⚠️  Empty username with password - Redis client should use default 'redis' user");
        }
    } else {
        println!("❌ URL parsing failed");
    }
}

#[tokio::test]
async fn test_redis_default_username_behavior() {
    // Тестируем поведение Redis client с пустым именем пользователя
    println!("Testing Redis default username behavior...");
    
    let test_cases = vec![
        ("redis://:password@localhost:6379", "Empty username with password"),
        ("redis://redis:password@localhost:6379", "Explicit redis username"),
        ("redis://:@localhost:6379", "Empty username and password"),
        ("redis://localhost:6379", "No authentication"),
    ];
    
    for (url, description) in test_cases {
        println!("\n--- {} ---", description);
        println!("URL: {}", url.replace(&url.split('@').nth(0).unwrap_or(""), "***"));
        
        if let Ok(parsed) = url::Url::parse(url) {
            println!("  Parsed Username: '{}'", parsed.username());
            println!("  Parsed Password: {}", if parsed.password().is_some() { "***" } else { "none" });
            
            // Redis client поведение:
            // - Если username пустой, но есть password -> использует дефолтное имя 'redis'
            // - Если username и password пустые -> без аутентификации
            if parsed.username().is_empty() && parsed.password().is_some() {
                println!("  Expected Redis behavior: Use default username 'redis'");
            } else if parsed.username().is_empty() && parsed.password().is_none() {
                println!("  Expected Redis behavior: No authentication");
            } else {
                println!("  Expected Redis behavior: Use explicit credentials");
            }
        }
    }
}