kevy 2.1.0

kevy — a pure-Rust, zero-dependency, Redis-compatible KV server.
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
122
123
124
125
126
127
128
129
130
131
132

//! v2.0.16 — `CLIENT SETNAME` / `CLIENT GETNAME` per-conn persistence
//! (closes v1.52.x finding).
//!
//! Validates the reactor-level intercept in
//! `crates/kevy-rt/src/exec_client_intercept.rs`:
//! - `SETNAME` persists the name on the conn;
//! - `GETNAME` returns the persisted name (not the v1.x stub `$0`);
//! - Per-connection isolation (one conn's name doesn't leak to another);
//! - Invalid names (whitespace / control chars) rejected with -ERR;
//! - Empty `SETNAME` is allowed (clears the name);
//! - `CLIENT` LIST / INFO / KILL / NO-EVICT etc. still work via the
//!   standard dispatch (interception is SETNAME/GETNAME-only).
//!
//! Gated `#[ignore]`. Run with:
//!
//! ```text
//! cargo build --release -p kevy
//! cargo test -p kevy --test client_setname_persistence --release -- --ignored --nocapture
//! ```

use std::io::{Read, Write};
use std::net::TcpStream;
use std::path::PathBuf;
use std::time::Duration;

use kevy_chaos::{Harness, HarnessConfig, pick_free_port};

#[test]
#[ignore = "chaos test — opt-in via --ignored"]
fn client_setname_persists_per_connection() {
    let bin_path = resolve_kevy_bin();
    let port = pick_free_port().expect("free port");
    let tmp = std::env::temp_dir().join(format!("kevy-chaos-setname-{port}"));
    let _ = std::fs::remove_dir_all(&tmp);

    let mut cfg = HarnessConfig::new(tmp.clone(), port).with_fsync("everysec");
    cfg.kevy_bin = bin_path;
    cfg.threads = 1;
    let _h = Harness::spawn(cfg).expect("spawn kevy");
    std::thread::sleep(Duration::from_millis(200));

    // PHASE 1: Single-conn round-trip.
    let mut a = connect(port);
    let r = send(&mut a, b"*3\r\n$6\r\nCLIENT\r\n$7\r\nSETNAME\r\n$5\r\nconn1\r\n");
    assert!(r.starts_with("+OK"), "SETNAME got: {r:?}");
    let r = send(&mut a, b"*2\r\n$6\r\nCLIENT\r\n$7\r\nGETNAME\r\n");
    assert!(
        r == "$5\r\nconn1\r\n",
        "GETNAME round-trip failed: {r:?}"
    );

    // PHASE 2: Per-connection isolation. A second connection's
    // GETNAME must return empty bulk (not conn1's name).
    let mut b = connect(port);
    let r = send(&mut b, b"*2\r\n$6\r\nCLIENT\r\n$7\r\nGETNAME\r\n");
    assert_eq!(r, "$0\r\n\r\n", "fresh conn must have empty name, got {r:?}");

    // PHASE 3: Rename on a fresh conn (overwrite semantics).
    let mut a2 = connect(port);
    let r = send(&mut a2, b"*3\r\n$6\r\nCLIENT\r\n$7\r\nSETNAME\r\n$4\r\nfoo1\r\n");
    assert!(r.starts_with("+OK"));
    let r = send(&mut a2, b"*2\r\n$6\r\nCLIENT\r\n$7\r\nGETNAME\r\n");
    assert_eq!(r, "$4\r\nfoo1\r\n");
    let r = send(&mut a2, b"*3\r\n$6\r\nCLIENT\r\n$7\r\nSETNAME\r\n$4\r\nbar2\r\n");
    assert!(r.starts_with("+OK"));
    let r = send(&mut a2, b"*2\r\n$6\r\nCLIENT\r\n$7\r\nGETNAME\r\n");
    assert_eq!(r, "$4\r\nbar2\r\n", "rename should overwrite");

    // PHASE 4: Whitespace rejected per Redis spec.
    let mut c = connect(port);
    let r = send(&mut c, b"*3\r\n$6\r\nCLIENT\r\n$7\r\nSETNAME\r\n$6\r\nha ck1\r\n");
    assert!(
        r.starts_with("-ERR"),
        "SETNAME with whitespace should reject, got {r:?}"
    );
    // After reject, name stays empty.
    let r = send(&mut c, b"*2\r\n$6\r\nCLIENT\r\n$7\r\nGETNAME\r\n");
    assert_eq!(r, "$0\r\n\r\n");

    // PHASE 5: Empty SETNAME allowed — clears the name.
    let r = send(&mut a, b"*3\r\n$6\r\nCLIENT\r\n$7\r\nSETNAME\r\n$0\r\n\r\n");
    assert!(r.starts_with("+OK"));
    let r = send(&mut a, b"*2\r\n$6\r\nCLIENT\r\n$7\r\nGETNAME\r\n");
    assert_eq!(r, "$0\r\n\r\n");

    // PHASE 6: Other CLIENT subcommands still work via the standard
    // dispatch (interception is SETNAME/GETNAME-only).
    let r = send(&mut a, b"*2\r\n$6\r\nCLIENT\r\n$2\r\nID\r\n");
    assert!(r.starts_with(':'), "CLIENT ID still works: {r:?}");
    let r = send(&mut a, b"*3\r\n$6\r\nCLIENT\r\n$8\r\nNO-EVICT\r\n$2\r\nON\r\n");
    assert!(r.starts_with("+OK"), "CLIENT NO-EVICT still works: {r:?}");

    eprintln!("client_setname: 6 phases passed — per-conn name persists, isolated, validated");
    drop(a);
    drop(a2);
    drop(b);
    drop(c);
    let _ = std::fs::remove_dir_all(&tmp);
}

fn connect(port: u16) -> TcpStream {
    let s = TcpStream::connect(format!("127.0.0.1:{port}")).expect("conn");
    let _ = s.set_read_timeout(Some(Duration::from_secs(2)));
    s
}

fn send(s: &mut TcpStream, cmd: &[u8]) -> String {
    s.write_all(cmd).expect("write");
    let mut buf = vec![0u8; 256];
    let n = s.read(&mut buf).expect("read");
    String::from_utf8_lossy(&buf[..n]).into_owned()
}

fn resolve_kevy_bin() -> PathBuf {
    if let Ok(p) = std::env::var("KEVY_BIN") {
        return PathBuf::from(p);
    }
    let here = std::env::current_dir().unwrap();
    let mut p = here.clone();
    loop {
        let candidate = p.join("target/release/kevy");
        if candidate.exists() {
            return candidate;
        }
        if !p.pop() {
            panic!(
                "kevy release binary not found above {}; run `cargo build --release -p kevy`",
                here.display()
            );
        }
    }
}