embedded-redis 0.8.0

A no_std Redis client
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

use crate::commands::auth::AuthCommand;
use crate::commands::Command;
use alloc::vec;
use bytes::Bytes;
use redis_protocol::resp2::types::{BytesFrame as Resp2Frame, Resp2Frame as _};
use redis_protocol::resp3::types::{BytesFrame as Resp3Frame, Resp3Frame as _};

#[test]
fn test_resp2_encode_no_username() {
    let command = AuthCommand::new(None as Option<Bytes>, "secret123!");
    let frame: Resp2Frame = command.encode();

    assert!(matches!(frame, Resp2Frame::Array(_)));
    if let Resp2Frame::Array(array) = frame {
        assert_eq!(2, array.len());
        assert_eq!("AUTH", array.first().unwrap().to_string().unwrap());
        assert_eq!("secret123!", array.get(1).unwrap().to_string().unwrap());
    }
}

#[test]
fn test_resp2_encode_username() {
    let command = AuthCommand::new(Some("test_user"), "secret123!");
    let frame: Resp2Frame = command.encode();

    assert!(matches!(frame, Resp2Frame::Array(_)));
    if let Resp2Frame::Array(array) = frame {
        assert_eq!(3, array.len());
        assert_eq!("AUTH", array.first().unwrap().to_string().unwrap());
        assert_eq!("test_user", array.get(1).unwrap().to_string().unwrap());
        assert_eq!("secret123!", array.get(2).unwrap().to_string().unwrap());
    }
}

#[test]
fn test_resp3_encode_no_username() {
    let command = AuthCommand::new(None as Option<Bytes>, "secret123!");
    let frame: Resp3Frame = command.encode();

    matches!(frame, Resp3Frame::Array { .. });
    if let Resp3Frame::Array { data, attributes } = frame {
        assert_eq!(2, data.len());
        assert!(attributes.is_none());

        assert_eq!("AUTH", data.first().unwrap().to_string().unwrap());
        assert_eq!("secret123!", data.get(1).unwrap().to_string().unwrap());
    }
}

#[test]
fn test_resp3_encode_username() {
    let command = AuthCommand::new(Some("user01"), "secret123!");
    let frame: Resp3Frame = command.encode();

    matches!(frame, Resp3Frame::Array { .. });
    if let Resp3Frame::Array { data, attributes } = frame {
        assert_eq!(3, data.len());
        assert!(attributes.is_none());

        assert_eq!("AUTH", data.first().unwrap().to_string().unwrap());
        assert_eq!("user01", data.get(1).unwrap().to_string().unwrap());
        assert_eq!("secret123!", data.get(2).unwrap().to_string().unwrap());
    }
}

#[test]
fn test_resp2_eval_response_string_ok() {
    let command = AuthCommand::new(None as Option<Bytes>, "secret123!");
    let frame = Resp2Frame::SimpleString(Bytes::from("OK"));

    assert!(command.eval_response(frame).is_ok());
}

#[test]
fn test_resp3_eval_response_string_ok() {
    let command = AuthCommand::new(None as Option<Bytes>, "secret123!");
    let frame = Resp3Frame::SimpleString {
        data: Bytes::from("OK"),
        attributes: None,
    };

    assert!(command.eval_response(frame).is_ok());
}

#[test]
fn test_resp2_eval_response_string_not_ok() {
    let command = AuthCommand::new(None as Option<Bytes>, "secret123!");
    let frame = Resp2Frame::SimpleString(Bytes::from("Other"));

    assert!(command.eval_response(frame).is_err());
}

#[test]
fn test_resp3_eval_response_string_not_ok() {
    let command = AuthCommand::new(None as Option<Bytes>, "secret123!");
    let frame = Resp3Frame::SimpleString {
        data: Bytes::from("Other"),
        attributes: None,
    };

    assert!(command.eval_response(frame).is_err());
}

#[test]
fn test_resp2_eval_response_unexpected_response_type() {
    let command = AuthCommand::new(None as Option<Bytes>, "secret123!");
    let frame = Resp2Frame::Array(vec![]);

    assert!(command.eval_response(frame).is_err());
}

#[test]
fn test_resp3_eval_response_unexpected_response_type() {
    let command = AuthCommand::new(None as Option<Bytes> as Option<Bytes>, "secret123!");
    let frame = Resp3Frame::Array {
        data: vec![],
        attributes: None,
    };

    assert!(command.eval_response(frame).is_err());
}