redis 1.3.0

Redis driver 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
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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275

//! (Unit) tests for the support module
//!
//! As the `support` module gets included in most integration tests, adding its unit tests to the
//! `support` module itself would include (and compile and run) them for each integration test
//! module. This is unwarranted. So we instead collect them in this module.

use crate::support::{
    AvailableComponents, Component, REDIS_CE_6_0, TestContext, TestContextVersioning,
};
use redis_test::{MockCmd, MockRedisConnection};

mod support;

fn build_available_components(input: &str) -> AvailableComponents {
    let mut conn = MockRedisConnection::new(vec![MockCmd::new(redis::cmd("INFO"), Ok(input))]);
    AvailableComponents::from(&mut conn)
}

fn assert_components_eq(components: AvailableComponents, mut expected: Vec<Component>) {
    let mut actual: Vec<Component> = (&components).into();
    actual.sort();
    expected.sort();
    assert_eq!(actual, expected);
}

/// Mock implementation of [`TestContextVersioning`] to allow testing default implementations
struct MockTestContext {
    /// The components to return during `get_available_components`
    components: AvailableComponents,
}

impl MockTestContext {
    /// Builds a new instance
    fn new(input: &str) -> Self {
        let components = build_available_components(input);
        Self { components }
    }
}

impl TestContextVersioning for MockTestContext {
    fn get_available_components(&self) -> AvailableComponents {
        self.components.clone()
    }
}

/// Tries to assure that `support` matches the same version
#[test]
fn ctx_supports_exact_match() {
    // The context to check with
    let mock = MockTestContext::new("foo_version: 42.4711.23");

    // Check for support
    assert!(mock.supports(("foo", (42, 4711, 23))));
}

/// Tries to assure that `support` correctly handles a smaller major number
#[test]
fn ctx_supports_major_smaller() {
    // The context to check with
    let mock = MockTestContext::new("foo_version: 42.4711.23");

    // Check for support
    assert!(mock.supports(("foo", (41, 4712, 24))));
}

/// Tries to assure that `support` correctly handles a bigger major number
#[test]
fn ctx_supports_major_bigger() {
    // The context to check with
    let mock = MockTestContext::new("foo_version: 42.4711.23");

    // Check for support
    assert!(!mock.supports(("foo", (43, 4710, 22))));
}

/// Tries to assure that `support` correctly handles a matching major but bigger minor number
#[test]
fn ctx_supports_major_match_minor_smaller() {
    // The context to check with
    let mock = MockTestContext::new("foo_version: 42.4711.23");

    // Check for support
    assert!(mock.supports(("foo", (42, 4710, 24))));
}

/// Tries to assure that `support` correctly handles a matching major but smaller minor number
#[test]
fn ctx_supports_major_match_minor_bigger() {
    // The context to check with
    let mock = MockTestContext::new("foo_version: 42.4711.23");

    // Check for support
    assert!(!mock.supports(("foo", (42, 4712, 22))));
}

/// Tries to assure that `support` correctly handles a matching major and minor but bigger patch number
#[test]
fn ctx_supports_major_match_minor_match_patch_smaller() {
    // The context to check with
    let mock = MockTestContext::new("foo_version: 42.4711.23");

    // Check for support
    assert!(mock.supports(("foo", (42, 4711, 22))));
}

/// Tries to assure that `support` correctly handles a matching major and minor but smaller patch number
#[test]
fn ctx_supports_major_match_minor_match_patch_bigger() {
    // The context to check with
    let mock = MockTestContext::new("foo_version: 42.4711.23");

    // Check for support
    assert!(!mock.supports(("foo", (42, 4711, 24))));
}

/// Tries to assure that `support` correctly handles a disjunctive match
#[test]
fn ctx_supports_disjunctive() {
    // The context to check with
    let mock = MockTestContext::new("bar_version: 42.4711.23");

    // Check for support when `bar` is `42.0.0` (matches)
    assert!(mock.supports([
        ("foo", (23, 23, 23)),
        ("bar", (42, 0, 0)),
        ("baz", (42, 42, 42)),
    ]));

    // Check for support when `bar` is `43.0.0` (too high)
    assert!(!mock.supports([
        ("foo", (23, 23, 23)),
        ("bar", (43, 0, 0)),
        ("baz", (42, 42, 42)),
    ]));

    // Check for support when `bar` is missing
    assert!(!mock.supports([("foo", (23, 23, 23)), ("baz", (42, 42, 42)),]));
}

/// Tries to assure that `support` correctly handles a conjunctive match
#[test]
fn ctx_supports_conjunctive() {
    // The context to check with
    let input = r#"
foo_version: 42.0.0
bar_version: 4711.0.0
baz_version: 23.0.0
"#;
    let mock = MockTestContext::new(input);

    // Check for successful support
    assert!(mock.supports([
        &[
            ("foo", (43, 0, 0)),  // does not match (too high)
            ("bar", (151, 0, 0))  // matches
        ][..],
        &[("baz", (23, 0, 0))], // matches
    ]));

    // Check for failing support (first disjunctive fails)
    assert!(!mock.supports([
        &[
            ("foo", (43, 0, 0)),   // does not match (too high)
            ("bar", (4712, 0, 0))  // does not match (too high)
        ][..],
        &[("baz", (23, 0, 0))], // matches
    ]));

    // Check for failing support (second disjunctive fails)
    assert!(!mock.supports([
        &[
            ("foo", (43, 0, 0)),  // does not match (too high)
            ("bar", (151, 0, 0))  // matches
        ][..],
        &[("baz", (151, 0, 0))][..], // does not match (too high)
    ]));
}

/// Tries to assure that the current server allows to parse the versions
#[test]
fn ctx_live_test_server() {
    let ctx = TestContext::new();
    let mut conn = ctx.connection();

    let components = AvailableComponents::from(&mut conn);

    assert!(components.supports(REDIS_CE_6_0));
}

/// Tries to assure versions get correctly extracted from a single number with single digit components
#[test]
fn component_parse_single_all_single_digit() {
    let input = "foo_version: 10203";

    let components = build_available_components(input);

    assert_components_eq(components, vec![("foo", (1, 2, 3))]);
}

/// Tries to assure versions get correctly extracted from a single number with multiple digit components and a suffix
#[test]
fn component_parse_single_multiple_digits_suffixed() {
    let input = "foo_version: 1234567-rc23";

    let components = build_available_components(input);

    assert_components_eq(components, vec![("foo", (123, 45, 67))]);
}

/// Tries to assure versions get correctly extracted from a triplet with single digit components
#[test]
fn component_parse_triplet_all_single_digit() {
    let input = "foo_version: 4.2.6";

    let components = build_available_components(input);

    assert_components_eq(components, vec![("foo", (4, 2, 6))]);
}

/// Tries to assure versions get correctly extracted from a triplet with multiple digit components and a suffix
#[test]
fn component_parse_triplet_multiple_digits_suffixed() {
    let input = "foo_version: 42.4711.23-rc121";

    let components = build_available_components(input);

    assert_components_eq(components, vec![("foo", (42, 4711, 23))]);
}

/// Tries to assure that a simple server version gets properly extracted from an info response
#[test]
fn component_parse_multiline_simple_server_version() {
    let input = r#"
bar: baz
foo_version:4711.23.42
quux: quuux
"#;

    let components = build_available_components(input);

    assert_components_eq(components, vec![("foo", (4711, 23, 42))]);
}

/// Tries to assure that a simple module version gets properly extracted from an info response
#[test]
fn component_parse_multiline_simple_module_version() {
    let input = r#"
bar: baz
module:name=foo,ver=47112342
quux: quuux
"#;

    let components = build_available_components(input);

    assert_components_eq(components, vec![("foo", (4711, 23, 42))]);
}

/// Tries to assure that versions properly parse from a complex info response
#[test]
fn component_parse_mix() {
    let input = r#"
   foo_version   :  2600.3.14159  # with whitespace padding
#bar_version:1.2.3 # commented out
this is # partly commented out

   module  :  foo=bar, ver  =  47112342, quux=quuux,  name = baz , baz =
"#;

    let components = build_available_components(input);

    assert_components_eq(
        components,
        vec![("foo", (2600, 3, 14159)), ("baz", (4711, 23, 42))],
    );
}