fred 0.2.5

A Redis client for Rust built on Futures and Tokio.
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


use futures::future;
use futures::{
  IntoFuture,
  Future,
  Stream
};
use futures::stream;

use std::rc::Rc;

use fred::error::{
  RedisErrorKind,
  RedisError
};
use fred::types::*;
use fred::RedisClient;

use super::utils;

pub fn should_set_and_get_simple_key(client: RedisClient) -> Box<Future<Item=(), Error=RedisError>> {
  Box::new(client.hset("foo", "bar", "baz").and_then(|(client, _)| {
    client.hget("foo", "bar")
  })
  .and_then(|(client, val)| {
    let val = match val {
      Some(v) => v,
      None => panic!("Expected value for foo not found.")
    };

    assert_eq!(val.into_string().unwrap(), "baz");
    client.hdel("foo", "bar")
  })
  .and_then(|(client, count)| {
    assert_eq!(count, 1);
    client.hget("foo", "bar")
  })
  .and_then(|(client, val)| {
    assert!(val.is_none());
    Ok(())
  }))
}

pub fn should_set_and_get_all_simple_key(client: RedisClient) -> Box<Future<Item=(), Error=RedisError>> {
  Box::new(client.hset("foo", "bar", "baz").and_then(|(client, _)| {
    client.hgetall("foo")
  })
  .and_then(|(client, mut val)| {
    assert_eq!(val.len(), 1);
    assert!(val.contains_key("bar".into()));
    assert_eq!(val.remove("bar".into()).unwrap().into_string().unwrap(), "baz");
    client.hdel("foo", "bar")
  })
  .and_then(|(client, count)| {
    assert_eq!(count, 1);
    client.hgetall("foo")
  })
  .and_then(|(client, val)| {
    assert_eq!(val.len(), 0);
    Ok(())
  }))
}

pub fn should_check_hexists(client: RedisClient) -> Box<Future<Item=(), Error=RedisError>> {
  Box::new(client.hset("foo", "bar", "baz").and_then(|(client, count)| {
    client.hexists("foo", "bar")
  })
  .and_then(|(client, exists)| {
    assert!(exists);
    client.hdel("foo", "bar")
  })
  .and_then(|(client, deleted)| {
    assert_eq!(deleted, 1);
    client.hexists("foo", "bar")
  })
  .and_then(|(client, exists)| {
    assert!(!exists);
    Ok(())
  }))
}

pub fn should_read_large_hash(client: RedisClient) -> Box<Future<Item=(), Error=RedisError>> {
  // set 1000 4k strings in a hashmap, then read in hkeys and hvals
  let mut keys = Vec::with_capacity(1000);
  let mut vals = Vec::with_capacity(1000);
  for _ in 0..1000 {
    keys.push(utils::random_string(32));
    vals.push(utils::random_string(4000));
  }
  let keys = Rc::new(keys);
  let vals = Rc::new(vals);

  let set_keys = keys.clone();
  let set_vals = vals.clone();
  let get_keys = keys.clone();
  let get_vals = vals.clone();

  Box::new(stream::iter_ok(0..1000).fold(client, move |client, idx| {
    client.hset("foo", &set_keys[idx], &set_vals[idx]).and_then(|(client, _)| {
      Ok(client)
    })
  })
  .and_then(|client| {
    client.hgetall("foo")
  })
  .and_then(move |(client, mut values)| {
    for (idx, key) in get_keys.iter().enumerate() {
      let expected: RedisValue = (&get_vals[idx]).into();
      assert_eq!(values.get(key).unwrap(), &expected);
      let _ = values.remove(key);
    }
    assert_eq!(values.len(), 0);

    client.del("foo")
  })
  .and_then(|(client, _)| {
    client.hgetall("foo")
  })
  .and_then(|(client, values)| {
    assert_eq!(values.len(), 0);
    Ok(())
  }))
}