yang-db 0.1.2

个人使用数据库操作
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

use yang_db::{RedisClient, RedisConfig, RedisValue};

/// 测试 Redis 连接
///
/// 需要本地 Redis 服务器运行在 127.0.0.1:6379
#[tokio::test]
async fn test_redis_connect() {
    let result = RedisClient::connect("redis://127.0.0.1:6379").await;
    assert!(result.is_ok(), "Redis 连接失败: {:?}", result.err());
}

/// 测试使用自定义配置连接
#[tokio::test]
async fn test_redis_connect_with_config() {
    let config = RedisConfig::new(5, 3, 5, false);
    let result = RedisClient::connect_with_config("redis://127.0.0.1:6379", config).await;
    assert!(result.is_ok(), "使用自定义配置连接失败: {:?}", result.err());
}

/// 测试连接池功能
#[tokio::test]
async fn test_redis_pool() {
    let client = RedisClient::connect("redis://127.0.0.1:6379")
        .await
        .expect("连接失败");

    let pool = client.pool();
    let conn_result = pool.get().await;
    assert!(conn_result.is_ok(), "从连接池获取连接失败");
}

/// 测试执行 PING 命令
#[tokio::test]
async fn test_redis_execute_ping() {
    let client = RedisClient::connect("redis://127.0.0.1:6379")
        .await
        .expect("连接失败");

    let cmd = redis::cmd("PING");
    let result = client.execute(&cmd).await;
    assert!(result.is_ok(), "执行 PING 命令失败: {:?}", result.err());

    let value = result.unwrap();
    assert!(matches!(value, RedisValue::String(_)));
}

/// 测试执行 SET 和 GET 命令
#[tokio::test]
async fn test_redis_execute_set_get() {
    let client = RedisClient::connect("redis://127.0.0.1:6379")
        .await
        .expect("连接失败");

    // SET 命令
    let mut set_cmd = redis::cmd("SET");
    set_cmd.arg("test_key").arg("test_value");
    let set_result = client.execute(&set_cmd).await;
    assert!(
        set_result.is_ok(),
        "执行 SET 命令失败: {:?}",
        set_result.err()
    );

    // GET 命令
    let mut get_cmd = redis::cmd("GET");
    get_cmd.arg("test_key");
    let get_result = client.execute(&get_cmd).await;
    assert!(
        get_result.is_ok(),
        "执行 GET 命令失败: {:?}",
        get_result.err()
    );

    let value = get_result.unwrap();
    if let RedisValue::String(s) = value {
        assert_eq!(s, "test_value");
    } else {
        panic!("期望返回字符串类型");
    }

    // 清理测试数据
    let mut del_cmd = redis::cmd("DEL");
    del_cmd.arg("test_key");
    let _ = client.execute(&del_cmd).await;
}

/// 测试并发连接
#[tokio::test]
async fn test_redis_concurrent_connections() {
    let client = RedisClient::connect("redis://127.0.0.1:6379")
        .await
        .expect("连接失败");

    let mut handles = vec![];

    // 创建 10 个并发任务
    for i in 0..10 {
        let client_clone = client.clone();
        let handle = tokio::spawn(async move {
            let mut cmd = redis::cmd("SET");
            cmd.arg(format!("concurrent_key_{}", i))
                .arg(format!("value_{}", i));
            client_clone.execute(&cmd).await
        });
        handles.push(handle);
    }

    // 等待所有任务完成
    for handle in handles {
        let result = handle.await.expect("任务执行失败");
        assert!(result.is_ok(), "并发执行失败: {:?}", result.err());
    }

    // 清理测试数据
    for i in 0..10 {
        let mut del_cmd = redis::cmd("DEL");
        del_cmd.arg(format!("concurrent_key_{}", i));
        let _ = client.execute(&del_cmd).await;
    }
}

/// 测试错误处理 - 无效的连接 URL
#[tokio::test]
async fn test_redis_invalid_url() {
    let result = RedisClient::connect("redis://invalid-host:9999").await;
    assert!(result.is_err(), "应该连接失败");
}

/// 测试错误处理 - 无效的命令
#[tokio::test]
async fn test_redis_invalid_command() {
    let client = RedisClient::connect("redis://127.0.0.1:6379")
        .await
        .expect("连接失败");

    // 执行一个不存在的命令
    let cmd = redis::cmd("INVALID_COMMAND");
    let result = client.execute(&cmd).await;
    assert!(result.is_err(), "应该执行失败");
}