preview-glide-rust 0.2.0

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

// Copyright Valkey GLIDE Project Contributors - SPDX Identifier: Apache-2.0
//! Per-command bitmap integration tests (RESP2 + RESP3).

mod common;

use glide::commands::bitmap::BitmapIndexType;
use glide::{AsyncCommands, BitmapCommands};

matrix_test!(setbit_getbit, c, {
    let k = common::key("bit");
    // SETBIT returns the previous bit (0 initially).
    let prev: i64 = c.setbit(&k, 7, true).await.unwrap();
    assert_eq!(prev, 0);
    let bit: i64 = c.getbit(&k, 7).await.unwrap();
    assert_eq!(bit, 1);
    let bit: i64 = c.getbit(&k, 0).await.unwrap();
    assert_eq!(bit, 0);
    // Setting again returns the previous value (1).
    let prev: i64 = c.setbit(&k, 7, false).await.unwrap();
    assert_eq!(prev, 1);
});

matrix_test!(getbit_missing_zero, c, {
    let bit: i64 = c.getbit(common::key("bit"), 100).await.unwrap();
    assert_eq!(bit, 0);
});

matrix_test!(bitcount, c, {
    let k = common::key("bit");
    let _: i64 = c.setbit(&k, 0, true).await.unwrap();
    let _: i64 = c.setbit(&k, 1, true).await.unwrap();
    let _: i64 = c.setbit(&k, 7, true).await.unwrap();
    let count: i64 = c.bitcount(&k).await.unwrap();
    assert_eq!(count, 3);
});

matrix_test!(bitcount_missing_zero, c, {
    let count: i64 = c.bitcount(common::key("bit")).await.unwrap();
    assert_eq!(count, 0);
});

matrix_test!(bitcount_range_byte, c, {
    let k = common::key("bit");
    // Two bytes: first byte has 8 set bits, second has 0.
    for i in 0..8usize {
        let _: i64 = c.setbit(&k, i, true).await.unwrap();
    }
    assert_eq!(
        c.bitpos_range(&k, 1, 0, 0, Some(BitmapIndexType::Byte))
            .await
            .unwrap(),
        0
    );
    // Use bitcount_range via compat
    let count: i64 = c.bitcount_range(&k, 0, 0).await.unwrap();
    assert_eq!(count, 8);
    let count: i64 = c.bitcount_range(&k, 1, 1).await.unwrap();
    assert_eq!(count, 0);
});

matrix_test!(bitcount_range_bit, c, {
    let k = common::key("bit");
    let _: i64 = c.setbit(&k, 5, true).await.unwrap();
    let _: i64 = c.setbit(&k, 6, true).await.unwrap();
    // bitcount_range in compat takes byte offsets; use native bitpos_range for BIT index type
    // Use cmd for BITCOUNT with BIT index type
    let count: i64 = c
        .glide_send(
            redis::cmd("BITCOUNT")
                .arg(&k)
                .arg(0i64)
                .arg(7i64)
                .arg("BIT")
                .clone(),
        )
        .await
        .unwrap();
    assert_eq!(count, 2);
});

matrix_test!(bitpos, c, {
    let k = common::key("bit");
    let _: i64 = c.setbit(&k, 10, true).await.unwrap();
    assert_eq!(c.bitpos(&k, 1).await.unwrap(), 10);
});

matrix_test!(bitop_and, c, {
    let a = common::tkey("bo", "a");
    let b = common::tkey("bo", "b");
    let dst = common::tkey("bo", "dst");
    let _: i64 = c.setbit(&a, 0, true).await.unwrap();
    let _: i64 = c.setbit(&a, 1, true).await.unwrap();
    let _: i64 = c.setbit(&b, 1, true).await.unwrap();
    let _: i64 = c.bit_and(&dst, &[&a, &b]).await.unwrap();
    let bit: i64 = c.getbit(&dst, 0).await.unwrap();
    assert_eq!(bit, 0);
    let bit: i64 = c.getbit(&dst, 1).await.unwrap();
    assert_eq!(bit, 1);
});

matrix_test!(bitop_or, c, {
    let a = common::tkey("bo", "a");
    let b = common::tkey("bo", "b");
    let dst = common::tkey("bo", "dst");
    let _: i64 = c.setbit(&a, 0, true).await.unwrap();
    let _: i64 = c.setbit(&b, 3, true).await.unwrap();
    let _: i64 = c.bit_or(&dst, &[&a, &b]).await.unwrap();
    let bit: i64 = c.getbit(&dst, 0).await.unwrap();
    assert_eq!(bit, 1);
    let bit: i64 = c.getbit(&dst, 3).await.unwrap();
    assert_eq!(bit, 1);
});

matrix_test!(bitop_xor, c, {
    let a = common::tkey("bo", "a");
    let b = common::tkey("bo", "b");
    let dst = common::tkey("bo", "dst");
    let _: i64 = c.setbit(&a, 0, true).await.unwrap();
    let _: i64 = c.setbit(&b, 0, true).await.unwrap();
    let _: i64 = c.setbit(&b, 1, true).await.unwrap();
    let _: i64 = c.bit_xor(&dst, &[&a, &b]).await.unwrap();
    let bit: i64 = c.getbit(&dst, 0).await.unwrap();
    assert_eq!(bit, 0);
    let bit: i64 = c.getbit(&dst, 1).await.unwrap();
    assert_eq!(bit, 1);
});

matrix_test!(bitop_not, c, {
    let a = common::tkey("bo", "a");
    let dst = common::tkey("bo", "dst");
    let _: i64 = c.setbit(&a, 0, true).await.unwrap();
    let _: i64 = c.bit_not(&dst, &a).await.unwrap();
    // NOT flips the first bit to 0 and the rest of the byte to 1.
    let bit: i64 = c.getbit(&dst, 0).await.unwrap();
    assert_eq!(bit, 0);
    let bit: i64 = c.getbit(&dst, 1).await.unwrap();
    assert_eq!(bit, 1);
});

matrix_test!(bitmap_wrong_type_errors, c, {
    let k = common::key("wt");
    let _: i64 = c.rpush(&k, &["x"]).await.unwrap();
    let res: redis::RedisResult<i64> = c.setbit(&k, 0, true).await;
    assert!(res.is_err());
});