memcached-protocal 0.1.11

Memcached Text Protocal
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

use std::io::BufReader;
use memcached_protocal::StoreCommand;


#[test]
fn test_parse_with_noreply() {
	let data = "value".as_bytes();
	let key = "key";
	let cmd_str = format!("set {} 0 0 {} 1\r\n", key, data.len());
	let mut store_cmd = Vec::from(cmd_str.as_bytes());
	store_cmd.extend_from_slice(data);
	store_cmd.extend_from_slice("\r\n".as_bytes());

	let cmd1 = StoreCommand::parse(&mut BufReader::new(store_cmd.as_slice())).unwrap();
    assert_eq!(cmd1,
  	 	StoreCommand{
    		command_name: "set".to_owned(),
    		key: key.to_owned(),
    		flags: 0,
    		exptime: 0,
    		bytes: data.len() as u64,
    		cas_unique: None,
    		noreply: Some("1".to_owned()),
    		data_block: Vec::from(data),
    	}
  	);
}

#[test]
fn test_parse_without_noreply() {
  let data = "value".as_bytes();
  let key = "key";
  let cmd_str = format!("set {} 0 0 {}\r\n", key, data.len());
  let mut store_cmd = Vec::from(cmd_str.as_bytes());
  store_cmd.extend_from_slice(data);
  store_cmd.extend_from_slice("\r\n".as_bytes());

  let cmd1 = StoreCommand::parse(&mut BufReader::new(store_cmd.as_slice())).unwrap();
  assert_eq!(cmd1,
      StoreCommand{
        command_name: "set".to_owned(),
        key: key.to_owned(),
        flags: 0,
        exptime: 0,
        bytes: data.len() as u64,
        cas_unique: None,
        noreply: None,
        data_block: Vec::from(data),
      }
    );
}

#[test]
fn test_parse_cas_with_noreply() {
  let data = "value".as_bytes();
  let key = "key";
  let cmd_str = format!("cas {} 0 0 {} 1 1\r\n", key, data.len());
  let mut store_cmd = Vec::from(cmd_str.as_bytes());
  store_cmd.extend_from_slice(data);
  store_cmd.extend_from_slice("\r\n".as_bytes());

  let cmd1 = StoreCommand::parse(&mut BufReader::new(store_cmd.as_slice())).unwrap();
  assert_eq!(cmd1,
      StoreCommand{
        command_name: "cas".to_owned(),
        key: key.to_owned(),
        flags: 0,
        exptime: 0,
        bytes: data.len() as u64,
        cas_unique: Some(1),
        noreply: Some("1".to_owned()),
        data_block: Vec::from(data),
      }
    );
}


#[test]
fn test_parse_cas_without_noreply() {
  let data = "value".as_bytes();
  let key = "key";
  let cmd_str = format!("cas {} 0 0 {} 1\r\n", key, data.len());
  let mut store_cmd = Vec::from(cmd_str.as_bytes());
  store_cmd.extend_from_slice(data);
  store_cmd.extend_from_slice("\r\n".as_bytes());

  let cmd1 = StoreCommand::parse(&mut BufReader::new(store_cmd.as_slice())).unwrap();
  assert_eq!(cmd1,
      StoreCommand{
        command_name: "cas".to_owned(),
        key: key.to_owned(),
        flags: 0,
        exptime: 0,
        bytes: data.len() as u64,
        cas_unique: Some(1),
        noreply: None,
        data_block: Vec::from(data),
      }
    );
}


#[test]
#[should_panic]
fn test_parse_should_panic() {
  let data = "value".as_bytes();
  let key = "key";
  let cmd_str = format!("caas {} 0 0 {} 1\r\n", key, data.len());
  let mut store_cmd = Vec::from(cmd_str.as_bytes());
  store_cmd.extend_from_slice(data);
  store_cmd.extend_from_slice("\r\n".as_bytes());

  StoreCommand::parse(&mut BufReader::new(store_cmd.as_slice())).unwrap();
}