kevy-embedded 3.17.0

Embedded mode for kevy — in-process Redis-compatible KV without the server/runtime.
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

//! Tests for keyspace cross-key ops in `ops_keyspace.rs`
//! (kevy-embedded 1.12.0).

use std::time::Duration;

use crate::Config;
use crate::store::Store;

fn s() -> Store {
    Store::open(Config::default().with_ttl_reaper_manual()).unwrap()
}

// ---- copy ---------------------------------------------------------------

#[test]
fn copy_absent_src_returns_false() {
    let s = s();
    assert!(!s.copy(b"absent", b"dst", false).unwrap());
}

#[test]
fn copy_to_new_dst_succeeds() {
    let s = s();
    s.set(b"src", b"value").unwrap();
    assert!(s.copy(b"src", b"dst", false).unwrap());
    assert_eq!(s.get(b"src").unwrap(), Some(b"value".to_vec()));
    assert_eq!(s.get(b"dst").unwrap(), Some(b"value".to_vec()));
}

#[test]
fn copy_to_existing_dst_vetoes_without_replace() {
    let s = s();
    s.set(b"src", b"v1").unwrap();
    s.set(b"dst", b"existing").unwrap();
    assert!(!s.copy(b"src", b"dst", false).unwrap());
    assert_eq!(s.get(b"dst").unwrap(), Some(b"existing".to_vec()));
}

#[test]
fn copy_with_replace_overwrites() {
    let s = s();
    s.set(b"src", b"v1").unwrap();
    s.set(b"dst", b"existing").unwrap();
    assert!(s.copy(b"src", b"dst", true).unwrap());
    assert_eq!(s.get(b"dst").unwrap(), Some(b"v1".to_vec()));
}

#[test]
fn copy_preserves_ttl_on_dst() {
    let s = s();
    s.set(b"src", b"v").unwrap();
    s.pexpire(b"src", 60_000).unwrap();
    assert!(s.copy(b"src", b"dst", false).unwrap());
    let ttl = s.ttl_ms(b"dst");
    assert!(
        (1..=60_000).contains(&ttl),
        "expected TTL preserved on dst, got {ttl}"
    );
}

// ---- randomkey ----------------------------------------------------------

#[test]
fn randomkey_empty_returns_none() {
    let s = s();
    assert_eq!(s.randomkey(), None);
}

#[test]
fn randomkey_picks_an_existing_key() {
    let s = s();
    s.set(b"a", b"1").unwrap();
    s.set(b"b", b"2").unwrap();
    s.set(b"c", b"3").unwrap();
    let k = s.randomkey().unwrap();
    assert!(
        matches!(k.as_slice(), b"a" | b"b" | b"c"),
        "got unexpected key: {:?}",
        String::from_utf8_lossy(&k)
    );
}

// ---- unlink -------------------------------------------------------------

#[test]
fn unlink_deletes_like_del() {
    let s = s();
    s.set(b"a", b"1").unwrap();
    s.set(b"b", b"2").unwrap();
    let removed = s.unlink(&[b"a", b"b", b"missing"]).unwrap();
    assert_eq!(removed, 2);
    assert_eq!(s.dbsize(), 0);
}

// ---- touch --------------------------------------------------------------

#[test]
fn touch_counts_existing_keys() {
    let s = s();
    s.set(b"a", b"1").unwrap();
    s.set(b"b", b"2").unwrap();
    let n = s.touch(&[b"a", b"missing", b"b"]).unwrap();
    assert_eq!(n, 2);
}

#[test]
fn touch_zero_for_all_missing() {
    let s = s();
    assert_eq!(s.touch(&[b"x", b"y"]).unwrap(), 0);
}

// ---- copy with sub-second TTL -----------------------------------------

#[test]
fn copy_short_ttl_survives() {
    let s = s();
    s.set_with_ttl(b"src", b"v", Duration::from_secs(2)).unwrap();
    assert!(s.copy(b"src", b"dst", false).unwrap());
    let ttl = s.ttl_ms(b"dst");
    assert!(ttl > 0 && ttl <= 2000, "got {ttl}");
}