herolib_rust/src/redisclient/tests.rs

use super::*;
use redis::RedisResult;
use std::env;

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

    #[test]
    fn test_env_vars() {
        // Save original REDISDB value to restore later
        let original_redisdb = env::var("REDISDB").ok();

        // Set test environment variables
        env::set_var("REDISDB", "5");

        // Test with invalid value
        env::set_var("REDISDB", "invalid");

        // Test with unset value
        env::remove_var("REDISDB");

        // Restore original REDISDB value
        if let Some(redisdb) = original_redisdb {
            env::set_var("REDISDB", redisdb);
        } else {
            env::remove_var("REDISDB");
        }
    }

    #[test]
    fn test_redis_client_creation_mock() {
        // This is a simplified test that doesn't require an actual Redis server
        // It just verifies that the function handles environment variables correctly

        // Save original HOME value to restore later
        let original_home = env::var("HOME").ok();

        // Set HOME to a test value
        env::set_var("HOME", "/tmp");

        // The actual client creation would be tested in integration tests
        // with a real Redis server or a mock

        // Restore original HOME value
        if let Some(home) = original_home {
            env::set_var("HOME", home);
        } else {
            env::remove_var("HOME");
        }
    }

    #[test]
    fn test_reset_mock() {
        // This is a simplified test that doesn't require an actual Redis server
        // In a real test, we would need to mock the Redis client

        // Just verify that the reset function doesn't panic
        // This is a minimal test - in a real scenario, we would use mocking
        // to verify that the client is properly reset
        if let Err(_) = reset() {
            // If Redis is not available, this is expected to fail
            // So we don't assert anything here
        }
    }

    #[test]
    fn test_redis_config_builder() {
        // Test the Redis configuration builder

        // Test default values
        let config = RedisConfigBuilder::new();
        assert_eq!(config.host, "127.0.0.1");
        assert_eq!(config.port, 6379);
        assert_eq!(config.db, 0);
        assert_eq!(config.username, None);
        assert_eq!(config.password, None);
        assert_eq!(config.use_tls, false);
        assert_eq!(config.use_unix_socket, false);
        assert_eq!(config.socket_path, None);
        assert_eq!(config.connection_timeout, None);

        // Test setting values
        let config = RedisConfigBuilder::new()
            .host("redis.example.com")
            .port(6380)
            .db(1)
            .username("user")
            .password("pass")
            .use_tls(true)
            .connection_timeout(30);

        assert_eq!(config.host, "redis.example.com");
        assert_eq!(config.port, 6380);
        assert_eq!(config.db, 1);
        assert_eq!(config.username, Some("user".to_string()));
        assert_eq!(config.password, Some("pass".to_string()));
        assert_eq!(config.use_tls, true);
        assert_eq!(config.connection_timeout, Some(30));

        // Test socket path setting
        let config = RedisConfigBuilder::new().socket_path("/tmp/redis.sock");

        assert_eq!(config.use_unix_socket, true);
        assert_eq!(config.socket_path, Some("/tmp/redis.sock".to_string()));
    }

    #[test]
    fn test_connection_url_building() {
        // Test building connection URLs

        // Test default URL
        let config = RedisConfigBuilder::new();
        let url = config.build_connection_url();
        assert_eq!(url, "redis://127.0.0.1:6379/0");

        // Test with authentication
        let config = RedisConfigBuilder::new().username("user").password("pass");
        let url = config.build_connection_url();
        assert_eq!(url, "redis://user:pass@127.0.0.1:6379/0");

        // Test with password only
        let config = RedisConfigBuilder::new().password("pass");
        let url = config.build_connection_url();
        assert_eq!(url, "redis://:pass@127.0.0.1:6379/0");

        // Test with TLS
        let config = RedisConfigBuilder::new().use_tls(true);
        let url = config.build_connection_url();
        assert_eq!(url, "rediss://127.0.0.1:6379/0");

        // Test with Unix socket
        let config = RedisConfigBuilder::new().socket_path("/tmp/redis.sock");
        let url = config.build_connection_url();
        assert_eq!(url, "unix:///tmp/redis.sock");
    }
}

// Integration tests that require a real Redis server
// These tests will be skipped if Redis is not available
#[cfg(test)]
mod redis_integration_tests {
    use super::*;

    // Helper function to check if Redis is available
    fn is_redis_available() -> bool {
        match get_redis_client() {
            Ok(_) => true,
            Err(_) => false,
        }
    }

    #[test]
    fn test_redis_client_integration() {
        if !is_redis_available() {
            println!("Skipping Redis integration tests - Redis server not available");
            return;
        }

        println!("Running Redis integration tests...");

        // Test basic operations
        test_basic_redis_operations();

        // Test more complex operations
        test_hash_operations();
        test_list_operations();

        // Test error handling
        test_error_handling();
    }

    fn test_basic_redis_operations() {
        if !is_redis_available() {
            return;
        }

        // Test setting and getting values
        let client_result = get_redis_client();

        if client_result.is_err() {
            // Skip the test if we can't connect to Redis
            return;
        }

        // Create SET command
        let mut set_cmd = redis::cmd("SET");
        set_cmd.arg("test_key").arg("test_value");

        // Execute SET command
        let set_result: RedisResult<()> = execute(&mut set_cmd);
        assert!(set_result.is_ok());

        // Create GET command
        let mut get_cmd = redis::cmd("GET");
        get_cmd.arg("test_key");

        // Execute GET command and check the result
        if let Ok(value) = execute::<String>(&mut get_cmd) {
            assert_eq!(value, "test_value");
        }

        // Test expiration
        let mut expire_cmd = redis::cmd("EXPIRE");
        expire_cmd.arg("test_key").arg(1); // Expire in 1 second
        let expire_result: RedisResult<i32> = execute(&mut expire_cmd);
        assert!(expire_result.is_ok());
        assert_eq!(expire_result.unwrap(), 1);

        // Sleep for 2 seconds to let the key expire
        std::thread::sleep(std::time::Duration::from_secs(2));

        // Check that the key has expired
        let mut exists_cmd = redis::cmd("EXISTS");
        exists_cmd.arg("test_key");
        let exists_result: RedisResult<i32> = execute(&mut exists_cmd);
        assert!(exists_result.is_ok());
        assert_eq!(exists_result.unwrap(), 0);

        // Clean up
        let _: RedisResult<()> = execute(&mut redis::cmd("DEL").arg("test_key"));
    }

    fn test_hash_operations() {
        if !is_redis_available() {
            return;
        }

        // Test hash operations
        let hash_key = "test_hash";

        // Set hash fields
        let mut hset_cmd = redis::cmd("HSET");
        hset_cmd
            .arg(hash_key)
            .arg("field1")
            .arg("value1")
            .arg("field2")
            .arg("value2");
        let hset_result: RedisResult<i32> = execute(&mut hset_cmd);
        assert!(hset_result.is_ok());
        assert_eq!(hset_result.unwrap(), 2);

        // Get hash field
        let mut hget_cmd = redis::cmd("HGET");
        hget_cmd.arg(hash_key).arg("field1");
        let hget_result: RedisResult<String> = execute(&mut hget_cmd);
        assert!(hget_result.is_ok());
        assert_eq!(hget_result.unwrap(), "value1");

        // Get all hash fields
        let mut hgetall_cmd = redis::cmd("HGETALL");
        hgetall_cmd.arg(hash_key);
        let hgetall_result: RedisResult<Vec<String>> = execute(&mut hgetall_cmd);
        assert!(hgetall_result.is_ok());
        let hgetall_values = hgetall_result.unwrap();
        assert_eq!(hgetall_values.len(), 4); // field1, value1, field2, value2

        // Delete hash field
        let mut hdel_cmd = redis::cmd("HDEL");
        hdel_cmd.arg(hash_key).arg("field1");
        let hdel_result: RedisResult<i32> = execute(&mut hdel_cmd);
        assert!(hdel_result.is_ok());
        assert_eq!(hdel_result.unwrap(), 1);

        // Clean up
        let _: RedisResult<()> = execute(&mut redis::cmd("DEL").arg(hash_key));
    }

    fn test_list_operations() {
        if !is_redis_available() {
            return;
        }

        // Test list operations
        let list_key = "test_list";

        // Push items to list
        let mut rpush_cmd = redis::cmd("RPUSH");
        rpush_cmd
            .arg(list_key)
            .arg("item1")
            .arg("item2")
            .arg("item3");
        let rpush_result: RedisResult<i32> = execute(&mut rpush_cmd);
        assert!(rpush_result.is_ok());
        assert_eq!(rpush_result.unwrap(), 3);

        // Get list length
        let mut llen_cmd = redis::cmd("LLEN");
        llen_cmd.arg(list_key);
        let llen_result: RedisResult<i32> = execute(&mut llen_cmd);
        assert!(llen_result.is_ok());
        assert_eq!(llen_result.unwrap(), 3);

        // Get list range
        let mut lrange_cmd = redis::cmd("LRANGE");
        lrange_cmd.arg(list_key).arg(0).arg(-1);
        let lrange_result: RedisResult<Vec<String>> = execute(&mut lrange_cmd);
        assert!(lrange_result.is_ok());
        let lrange_values = lrange_result.unwrap();
        assert_eq!(lrange_values.len(), 3);
        assert_eq!(lrange_values[0], "item1");
        assert_eq!(lrange_values[1], "item2");
        assert_eq!(lrange_values[2], "item3");

        // Pop item from list
        let mut lpop_cmd = redis::cmd("LPOP");
        lpop_cmd.arg(list_key);
        let lpop_result: RedisResult<String> = execute(&mut lpop_cmd);
        assert!(lpop_result.is_ok());
        assert_eq!(lpop_result.unwrap(), "item1");

        // Clean up
        let _: RedisResult<()> = execute(&mut redis::cmd("DEL").arg(list_key));
    }

    fn test_error_handling() {
        if !is_redis_available() {
            return;
        }

        // Test error handling

        // Test invalid command
        let mut invalid_cmd = redis::cmd("INVALID_COMMAND");
        let invalid_result: RedisResult<()> = execute(&mut invalid_cmd);
        assert!(invalid_result.is_err());

        // Test wrong data type
        let key = "test_wrong_type";

        // Set a string value
        let mut set_cmd = redis::cmd("SET");
        set_cmd.arg(key).arg("string_value");
        let set_result: RedisResult<()> = execute(&mut set_cmd);
        assert!(set_result.is_ok());

        // Try to use a hash command on a string
        let mut hget_cmd = redis::cmd("HGET");
        hget_cmd.arg(key).arg("field");
        let hget_result: RedisResult<String> = execute(&mut hget_cmd);
        assert!(hget_result.is_err());

        // Clean up
        let _: RedisResult<()> = execute(&mut redis::cmd("DEL").arg(key));
    }
}