redust 0.4.0

A simple Redis client for Rust.
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

use std::{borrow::Cow, collections::HashMap};

use serde::{Deserialize, Serialize};

use super::Id;

/// A stream key in the Redis keyspace.
#[derive(Debug, Default, PartialEq, Eq, Hash, Clone, Serialize, Deserialize)]
#[serde(transparent)]
pub struct Key<'a>(#[serde(borrow, with = "serde_bytes")] pub Cow<'a, [u8]>);

/// A field from a stream, associated to a [`Value`].
#[derive(Debug, Default, PartialEq, Eq, Hash, Clone, Serialize, Deserialize)]
#[serde(transparent)]
pub struct Field<'a>(#[serde(borrow, with = "serde_bytes")] pub Cow<'a, [u8]>);

/// A value from a stream, keyed by a [`Field`].
#[derive(Debug, Default, PartialEq, Eq, Hash, Clone, Serialize, Deserialize)]
#[serde(transparent)]
pub struct Value<'a>(#[serde(borrow, with = "serde_bytes")] pub Cow<'a, [u8]>);

/// All entries in a stream, belonging to a [`Key`].
#[derive(Debug, Default, PartialEq, Eq, Clone, Serialize, Deserialize)]
#[serde(transparent)]
pub struct Entries<'a>(
	#[serde(borrow, with = "redust_resp::util::tuple_map")] pub HashMap<Id, Entry<'a>>,
);

pub type Entry<'a> = HashMap<Field<'a>, Value<'a>>;

/// A stream read response from [`XREAD(GROUP)`](https://redis.io/commands/xread/).
#[derive(Debug, Default, PartialEq, Eq, Clone, Serialize, Deserialize)]
#[serde(transparent)]
pub struct ReadResponse<'a>(
	#[serde(borrow, with = "redust_resp::util::tuple_map")] pub HashMap<Key<'a>, Entries<'a>>,
);

#[cfg(test)]
mod test {
	use std::borrow::Cow;

	use redust_resp::{array, from_bytes, from_data, Data};

	use crate::model::stream::{
		read::{Field, Key, Value},
		Id,
	};

	use super::ReadResponse;

	#[test]
	fn stream_read_some() {
		let data = array![array![
			Data::BulkString(b"foo"[..].into()),
			array![array![
				Data::BulkString(b"1-0"[..].into()),
				array![
					Data::BulkString(b"abc"[..].into()),
					Data::BulkString(b"def"[..].into())
				]
			]]
		]];

		let resp = from_data::<Option<ReadResponse>>(data)
			.expect("read data")
			.expect("some");
		assert_eq!(
			resp.0[&Key(b"foo"[..].into())].0[&Id(1, 0)][&Field(b"abc"[..].into())],
			Value(Cow::from(&b"def"[..]))
		);
	}

	#[test]
	fn stream_read_none() {
		let bytes = b"*-1\r\n";

		let (resp, rem) = from_bytes::<Option<ReadResponse>>(bytes).expect("read data");
		assert_eq!(resp, None);
		assert_eq!(rem, []);
	}
}