tower-redis 0.5.0

A Tower service for asynchronous Redis request/response performed over a managed, multplexed connection.
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

//! Redis Tower Service

mod service;

#[cfg(feature = "util")]
mod util;

pub use service::RedisService;

#[cfg(test)]
mod test {
    use crate::RedisService;
    use redis::{aio::ConnectionManager, Client, Cmd, Value};
    use tower::{Service, ServiceExt};

    const URL: &str = "redis://127.0.0.1:6379";

    macro_rules! call {
        ($service:expr, $cmd:expr) => {
            $service.ready().await.unwrap().call($cmd).await
        };
    }

    #[tokio::test]
    async fn test_redis_service() {
        let client = Client::open(URL).unwrap();
        let connection = ConnectionManager::new(client).await.unwrap();
        let service = RedisService::new(connection);
        let mut join_handles = Vec::new();

        for i in 0..100 {
            let mut service = service.clone();
            let key = format!("foo-{}", i);
            let value = format!("bar-{}", i);

            join_handles.push(tokio::spawn(async move {
                let res = call!(service, Cmd::set(key, value)).unwrap();

                assert_eq!(res, Value::Okay);
            }));
        }

        for i in 0..100 {
            let mut service = service.clone();
            let mut service_clone = service.clone();
            let key = format!("foo-{}", i);
            let key_clone = key.clone();
            let value = format!("bar-{}", i);

            tokio::spawn(async move {
                let res = call!(service, Cmd::get(key)).unwrap();
                assert_eq!(res, Value::BulkString(value.into()));

                let res = call!(service_clone, Cmd::del(key_clone)).unwrap();
                assert_eq!(res, Value::Int(1));
            });
        }
    }
}