mecha10-cli 0.1.47

Mecha10 CLI tool
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

//! Integration tests for RedisService
//!
//! These tests verify that the RedisService correctly handles Redis connections
//! and operations. Some tests require a running Redis instance.

mod common;

use mecha10_cli::services::RedisService;
use std::time::Duration;

#[test]
fn test_service_creation_with_valid_url() {
    let service = RedisService::new("redis://localhost:6379");
    assert!(service.is_ok());
}

#[test]
fn test_service_url_accessor() {
    let service = RedisService::new("redis://localhost:6379").unwrap();
    assert_eq!(service.url(), "redis://localhost:6379");
}

#[test]
fn test_from_env_without_env_vars() {
    // Clear env vars to test default
    std::env::remove_var("MECHA10_REDIS_URL");
    std::env::remove_var("REDIS_URL");

    let service = RedisService::from_env();
    assert!(service.is_ok());
    // Should fall back to default
    assert_eq!(service.unwrap().url(), "redis://localhost:6379");
}

#[test]
fn test_from_env_with_mecha10_redis_url() {
    std::env::set_var("MECHA10_REDIS_URL", "redis://custom:1234");

    let service = RedisService::from_env().unwrap();
    assert_eq!(service.url(), "redis://custom:1234");

    std::env::remove_var("MECHA10_REDIS_URL");
}

#[test]
fn test_from_env_with_redis_url_fallback() {
    std::env::remove_var("MECHA10_REDIS_URL");
    std::env::set_var("REDIS_URL", "redis://fallback:5678");

    let service = RedisService::from_env().unwrap();
    assert_eq!(service.url(), "redis://fallback:5678");

    std::env::remove_var("REDIS_URL");
}

#[test]
fn test_from_env_precedence() {
    // MECHA10_REDIS_URL should take precedence over REDIS_URL
    std::env::set_var("MECHA10_REDIS_URL", "redis://primary:1111");
    std::env::set_var("REDIS_URL", "redis://secondary:2222");

    let service = RedisService::from_env().unwrap();
    assert_eq!(service.url(), "redis://primary:1111");

    std::env::remove_var("MECHA10_REDIS_URL");
    std::env::remove_var("REDIS_URL");
}

#[test]
fn test_default_service() {
    // Default should use from_env logic
    std::env::remove_var("MECHA10_REDIS_URL");
    std::env::remove_var("REDIS_URL");

    let service = RedisService::default();
    assert_eq!(service.url(), "redis://localhost:6379");
}

#[tokio::test]
async fn test_health_check_with_invalid_url() {
    // Service with unreachable Redis instance
    let service = RedisService::new("redis://localhost:9999").unwrap();

    // Health check should fail quickly
    let healthy = service.check_health(Duration::from_millis(500)).await;
    assert!(!healthy);
}

#[tokio::test]
async fn test_is_healthy_with_invalid_url() {
    // is_healthy is a convenience wrapper around check_health
    let service = RedisService::new("redis://localhost:9999").unwrap();
    let healthy = service.is_healthy().await;
    assert!(!healthy);
}

// The following tests require a running Redis instance
// They are ignored by default and can be run with: cargo test -- --ignored

#[tokio::test]
#[ignore]
async fn test_get_connection_with_running_redis() {
    let service = RedisService::new("redis://localhost:6379").unwrap();
    let result = service.get_connection().await;
    assert!(result.is_ok(), "Failed to connect to Redis: {:?}", result.err());
}

#[tokio::test]
#[ignore]
async fn test_get_multiplexed_connection_with_running_redis() {
    let service = RedisService::new("redis://localhost:6379").unwrap();
    let result = service.get_multiplexed_connection().await;
    assert!(
        result.is_ok(),
        "Failed to get multiplexed connection: {:?}",
        result.err()
    );
}

#[tokio::test]
#[ignore]
async fn test_health_check_with_running_redis() {
    let service = RedisService::new("redis://localhost:6379").unwrap();
    let healthy = service.check_health(Duration::from_secs(2)).await;
    assert!(healthy, "Redis health check failed");
}

#[tokio::test]
#[ignore]
async fn test_health_check_timeout() {
    // This test would need a Redis instance that's slow to respond
    // For now, we'll just verify the timeout mechanism doesn't panic
    let service = RedisService::new("redis://localhost:6379").unwrap();
    let _healthy = service.check_health(Duration::from_nanos(1)).await;
    // The result doesn't matter - we're testing that timeout works
}

#[tokio::test]
#[ignore]
async fn test_multiple_connections() {
    // Verify we can create multiple connections
    let service = RedisService::new("redis://localhost:6379").unwrap();

    let conn1 = service.get_connection().await;
    let conn2 = service.get_connection().await;

    assert!(conn1.is_ok());
    assert!(conn2.is_ok());
}