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 Pub/Sub command family.
use super::Mock;
use crate::ValkeyValue;
use crate::commands::pubsub::PubSubCommands;
use bytes::Bytes;

// `PUBLISH` and `SPUBLISH` are declared in (`crate::AsyncCommands`).
// and covered by the parity guard (the `parity_tests` module).

#[tokio::test]
async fn pubsub_channels_with_and_without_pattern() {
    let m = Mock::array(vec![ValkeyValue::BulkString(b"news".to_vec().into())]);
    let chans = m.pubsub_channels(Some(b"n*")).await.unwrap();
    m.assert_args(&["PUBSUB", "CHANNELS", "n*"]);
    assert_eq!(chans, vec![Bytes::from_static(b"news")]);

    let m = Mock::array(vec![]);
    let _ = m.pubsub_channels(None).await.unwrap();
    m.assert_args(&["PUBSUB", "CHANNELS"]);
}

#[tokio::test]
async fn pubsub_numpat_int() {
    let m = Mock::int(5);
    assert_eq!(m.pubsub_numpat().await.unwrap(), 5);
    m.assert_args(&["PUBSUB", "NUMPAT"]);
}

#[tokio::test]
async fn pubsub_numsub_pairs() {
    let m = Mock::array(vec![
        ValkeyValue::BulkString(b"a".to_vec().into()),
        ValkeyValue::Int(2),
        ValkeyValue::BulkString(b"b".to_vec().into()),
        ValkeyValue::Int(0),
    ]);
    let subs = m.pubsub_numsub(&["a", "b"]).await.unwrap();
    m.assert_args(&["PUBSUB", "NUMSUB", "a", "b"]);
    assert_eq!(
        subs,
        vec![(Bytes::from_static(b"a"), 2), (Bytes::from_static(b"b"), 0)]
    );
}

#[tokio::test]
async fn pubsub_shard_variants() {
    let m = Mock::array(vec![ValkeyValue::BulkString(b"s".to_vec().into())]);
    let _ = m.pubsub_shardchannels(None).await.unwrap();
    m.assert_args(&["PUBSUB", "SHARDCHANNELS"]);

    let m = Mock::array(vec![
        ValkeyValue::BulkString(b"s".to_vec().into()),
        ValkeyValue::Int(1),
    ]);
    let subs = m.pubsub_shardnumsub(&["s"]).await.unwrap();
    m.assert_args(&["PUBSUB", "SHARDNUMSUB", "s"]);
    assert_eq!(subs, vec![(Bytes::from_static(b"s"), 1)]);
}

#[tokio::test]
async fn subscribe_encodes_channels() {
    let m = Mock::nil();
    m.subscribe(&["c1", "c2"]).await.unwrap();
    m.assert_args(&["SUBSCRIBE", "c1", "c2"]);
}

#[tokio::test]
async fn psubscribe_encodes_patterns() {
    let m = Mock::nil();
    m.psubscribe(&["news.*"]).await.unwrap();
    m.assert_args(&["PSUBSCRIBE", "news.*"]);
}

#[tokio::test]
async fn ssubscribe_encodes_channels() {
    let m = Mock::nil();
    m.ssubscribe(&["shard1"]).await.unwrap();
    m.assert_args(&["SSUBSCRIBE", "shard1"]);
}

#[tokio::test]
async fn unsubscribe_all_has_no_channel_args() {
    let m = Mock::nil();
    m.unsubscribe(&[] as &[&str]).await.unwrap();
    m.assert_args(&["UNSUBSCRIBE"]);
}

#[tokio::test]
async fn punsubscribe_specific() {
    let m = Mock::nil();
    m.punsubscribe(&["news.*"]).await.unwrap();
    m.assert_args(&["PUNSUBSCRIBE", "news.*"]);
}

#[tokio::test]
async fn sunsubscribe_all() {
    let m = Mock::nil();
    m.sunsubscribe(&[] as &[&str]).await.unwrap();
    m.assert_args(&["SUNSUBSCRIBE"]);
}