valkey-glide 0.9.0

Valkey GLIDE — native Rust client for Valkey and Redis OSS, built on glide-core.
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

// Copyright Valkey GLIDE Project Contributors - SPDX Identifier: Apache-2.0
//! Mock-executor unit tests for the stream command family.
use super::Mock;
use crate::ValkeyValue;
use crate::commands::stream::StreamCommands;
use crate::commands::stream::StreamGroupCreateOptions;
use crate::commands::stream::StreamReadGroupOptions;

fn entry(id: &str, field: &str, val: &str) -> ValkeyValue {
    ValkeyValue::Array(vec![
        ValkeyValue::BulkString(id.as_bytes().to_vec().into()),
        ValkeyValue::Array(vec![
            ValkeyValue::BulkString(field.as_bytes().to_vec().into()),
            ValkeyValue::BulkString(val.as_bytes().to_vec().into()),
        ]),
    ])
}

#[tokio::test]
async fn xreadgroup_encoding() {
    let m = Mock::array(vec![ValkeyValue::Array(vec![
        ValkeyValue::BulkString(b"s".to_vec().into()),
        ValkeyValue::Array(vec![entry("1-0", "f", "v")]),
    ])]);
    let opts = StreamReadGroupOptions {
        block_ms: None,
        count: Some(5),
        no_ack: true,
    };
    m.xreadgroup("g", "c", &[("s", ">")], Some(opts))
        .await
        .unwrap();
    m.assert_args(&[
        "XREADGROUP",
        "GROUP",
        "g",
        "c",
        "COUNT",
        "5",
        "NOACK",
        "STREAMS",
        "s",
        ">",
    ]);
}

#[tokio::test]
async fn xsetid_encoding() {
    let m = Mock::ok();
    m.xsetid("s", "5-0", Some(10), Some("4-0")).await.unwrap();
    m.assert_args(&[
        "XSETID",
        "s",
        "5-0",
        "ENTRIESADDED",
        "10",
        "MAXDELETEDID",
        "4-0",
    ]);
}

#[tokio::test]
async fn xgroup_option_variants() {
    let m = Mock::ok();
    let opts = StreamGroupCreateOptions {
        make_stream: true,
        entries_read: Some(0),
    };
    m.xgroup_create_options("s", "g", "$", &opts).await.unwrap();
    m.assert_args(&[
        "XGROUP",
        "CREATE",
        "s",
        "g",
        "$",
        "MKSTREAM",
        "ENTRIESREAD",
        "0",
    ]);

    let m = Mock::ok();
    m.xgroup_set_id("s", "g", "0", None).await.unwrap();
    m.assert_args(&["XGROUP", "SETID", "s", "g", "0"]);
}

#[tokio::test]
async fn xpending_range_encoding() {
    let m = Mock::array(vec![ValkeyValue::Array(vec![
        ValkeyValue::BulkString(b"1-0".to_vec().into()),
        ValkeyValue::BulkString(b"c1".to_vec().into()),
        ValkeyValue::Int(100),
        ValkeyValue::Int(3),
    ])]);
    let entries = m
        .xpending_range("s", "g", "-", "+", 10, Some(50), Some("c1"))
        .await
        .unwrap();
    m.assert_args(&["XPENDING", "s", "g", "IDLE", "50", "-", "+", "10", "c1"]);
    assert_eq!(entries.len(), 1);
    assert_eq!(entries[0].delivery_count, 3);
}