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

// Copyright Valkey GLIDE Project Contributors - SPDX Identifier: Apache-2.0
//! Mock-executor unit tests for the bitmap command family (command dispatch).
use super::Mock;
use crate::ValkeyValue;
use crate::commands::bitmap::{
    BitEncoding, BitFieldOffset, BitFieldSubcommand, BitmapCommands, BitmapIndexType,
};

#[tokio::test]
async fn bitpos_and_range() {
    let m = Mock::int(3);
    assert_eq!(m.bitpos("k", 1).await.unwrap(), 3);
    m.assert_args(&["BITPOS", "k", "1"]);

    let m = Mock::int(3);
    m.bitpos_range("k", 1, 0, 10, Some(BitmapIndexType::Bit))
        .await
        .unwrap();
    m.assert_args(&["BITPOS", "k", "1", "0", "10", "BIT"]);
}

#[tokio::test]
async fn bitfield_get_set_incrby() {
    let m = Mock::array(vec![ValkeyValue::Int(5)]);
    let r = m
        .bitfield(
            "k",
            &[BitFieldSubcommand::Get {
                encoding: BitEncoding::Unsigned(8),
                offset: BitFieldOffset::Bit(0),
            }],
        )
        .await
        .unwrap();
    m.assert_args(&["BITFIELD", "k", "GET", "u8", "0"]);
    assert_eq!(r, vec![Some(5)]);

    let m = Mock::array(vec![ValkeyValue::Int(0), ValkeyValue::Nil]);
    let r = m
        .bitfield(
            "k",
            &[
                BitFieldSubcommand::Set {
                    encoding: BitEncoding::Signed(5),
                    offset: BitFieldOffset::Multiplier(1),
                    value: 12,
                },
                BitFieldSubcommand::IncrBy {
                    encoding: BitEncoding::Unsigned(4),
                    offset: BitFieldOffset::Bit(2),
                    increment: 3,
                },
            ],
        )
        .await
        .unwrap();
    m.assert_args(&[
        "BITFIELD", "k", "SET", "i5", "#1", "12", "INCRBY", "u4", "2", "3",
    ]);
    assert_eq!(r, vec![Some(0), None]);
}

#[tokio::test]
async fn bitfield_readonly() {
    let m = Mock::array(vec![ValkeyValue::Int(7)]);
    m.bitfield_readonly(
        "k",
        &[BitFieldSubcommand::Get {
            encoding: BitEncoding::Unsigned(8),
            offset: BitFieldOffset::Bit(0),
        }],
    )
    .await
    .unwrap();
    m.assert_args(&["BITFIELD_RO", "k", "GET", "u8", "0"]);
}