kevy-embedded 1.15.1

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

//! Tests for the bonus ops in `ops_bonus.rs`
//! (kevy-embedded 1.8.0).

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

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

// ---- setnx ---------------------------------------------------------------

#[test]
fn setnx_succeeds_on_absent_key() {
    let s = s();
    assert!(s.setnx(b"k", b"v").unwrap());
    assert_eq!(s.get(b"k").unwrap(), Some(b"v".to_vec()));
}

#[test]
fn setnx_vetoed_when_key_exists() {
    let s = s();
    s.set(b"k", b"existing").unwrap();
    assert!(!s.setnx(b"k", b"new").unwrap());
    assert_eq!(s.get(b"k").unwrap(), Some(b"existing".to_vec()));
}

// ---- incrbyfloat ---------------------------------------------------------

#[test]
fn incrbyfloat_initializes_at_zero() {
    let s = s();
    let v = s.incrbyfloat(b"k", 1.5).unwrap();
    assert!((v - 1.5).abs() < 1e-9, "got {v}");
}

#[test]
fn incrbyfloat_accumulates() {
    let s = s();
    s.incrbyfloat(b"k", 2.0).unwrap();
    let v = s.incrbyfloat(b"k", 3.5).unwrap();
    assert!((v - 5.5).abs() < 1e-9, "got {v}");
}

// ---- decr / decrby -------------------------------------------------------

#[test]
fn decr_initializes_negative_one() {
    let s = s();
    assert_eq!(s.decr(b"k").unwrap(), -1);
    assert_eq!(s.decr(b"k").unwrap(), -2);
}

#[test]
fn decrby_arbitrary_delta() {
    let s = s();
    assert_eq!(s.decrby(b"k", 5).unwrap(), -5);
    assert_eq!(s.decrby(b"k", -3).unwrap(), -2);
}

// ---- strlen + append -----------------------------------------------------

#[test]
fn strlen_basic_and_absent() {
    let s = s();
    assert_eq!(s.strlen(b"absent").unwrap(), 0);
    s.set(b"k", b"hello").unwrap();
    assert_eq!(s.strlen(b"k").unwrap(), 5);
}

#[test]
fn append_extends_and_returns_new_length() {
    let s = s();
    let n = s.append(b"k", b"abc").unwrap();
    assert_eq!(n, 3);
    let n = s.append(b"k", b"def").unwrap();
    assert_eq!(n, 6);
    assert_eq!(s.get(b"k").unwrap(), Some(b"abcdef".to_vec()));
}

// ---- hsetnx --------------------------------------------------------------

#[test]
fn hsetnx_succeeds_on_absent_field() {
    let s = s();
    assert!(s.hsetnx(b"h", b"f", b"v").unwrap());
    assert_eq!(s.hget(b"h", b"f").unwrap(), Some(b"v".to_vec()));
}

#[test]
fn hsetnx_vetoed_when_field_exists() {
    let s = s();
    s.hset(b"h", &[(b"f", b"existing")]).unwrap();
    assert!(!s.hsetnx(b"h", b"f", b"new").unwrap());
    assert_eq!(s.hget(b"h", b"f").unwrap(), Some(b"existing".to_vec()));
}

// ---- ttl_secs ------------------------------------------------------------

#[test]
fn ttl_secs_no_ttl_returns_negative_one() {
    let s = s();
    s.set(b"k", b"v").unwrap();
    assert_eq!(s.ttl_secs(b"k"), -1);
}

#[test]
fn ttl_secs_absent_returns_negative_two() {
    let s = s();
    assert_eq!(s.ttl_secs(b"absent"), -2);
}

#[test]
fn ttl_secs_after_pexpire() {
    let s = s();
    s.set(b"k", b"v").unwrap();
    s.pexpire(b"k", 30_000).unwrap();
    let t = s.ttl_secs(b"k");
    assert!((1..=30).contains(&t), "expected 1..=30s, got {t}");
}