beachcomber 0.1.1

A centralized daemon that caches shell state (git, battery, hostname, etc.) so every consumer reads from one fast cache instead of independently forking shells
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

use beachcomber::protocol::{Format, Request, Response};

#[test]
fn parse_get_request_with_path() {
    let json = r#"{"op": "get", "key": "git.branch", "path": "/home/user/project"}"#;
    let req: Request = serde_json::from_str(json).unwrap();
    match req {
        Request::Get { key, path, format } => {
            assert_eq!(key, "git.branch");
            assert_eq!(path.as_deref(), Some("/home/user/project"));
            assert_eq!(format, Format::Json, "Default format should be Json");
        }
        _ => panic!("Expected Get request"),
    }
}

#[test]
fn parse_get_request_global() {
    let json = r#"{"op": "get", "key": "battery"}"#;
    let req: Request = serde_json::from_str(json).unwrap();
    match req {
        Request::Get { key, path, .. } => {
            assert_eq!(key, "battery");
            assert!(path.is_none(), "Global request should have no path");
        }
        _ => panic!("Expected Get request"),
    }
}

#[test]
fn parse_get_request_text_format() {
    let json = r#"{"op": "get", "key": "git.branch", "path": "/project", "format": "text"}"#;
    let req: Request = serde_json::from_str(json).unwrap();
    match req {
        Request::Get { format, .. } => {
            assert_eq!(format, Format::Text);
        }
        _ => panic!("Expected Get request"),
    }
}

#[test]
fn parse_poke_request() {
    let json = r#"{"op": "poke", "key": "git", "path": "/project"}"#;
    let req: Request = serde_json::from_str(json).unwrap();
    match req {
        Request::Poke { key, path } => {
            assert_eq!(key, "git");
            assert_eq!(path.as_deref(), Some("/project"));
        }
        _ => panic!("Expected Poke request"),
    }
}

#[test]
fn response_ok_serializes() {
    let response = Response::ok(serde_json::json!({"branch": "main"}), 50, false);
    let json = serde_json::to_value(&response).unwrap();
    assert_eq!(json["ok"], true);
    assert_eq!(json["data"]["branch"], "main");
    assert_eq!(json["age_ms"], 50);
    assert_eq!(json["stale"], false);
}

#[test]
fn response_error_serializes() {
    let response = Response::error("unknown provider");
    let json = serde_json::to_value(&response).unwrap();
    assert_eq!(json["ok"], false);
    assert_eq!(json["error"], "unknown provider");
}

#[test]
fn response_miss_serializes() {
    let response = Response::miss();
    let json = serde_json::to_value(&response).unwrap();
    assert_eq!(json["ok"], true);
    assert!(json["data"].is_null(), "Cache miss should have null data");
}

#[test]
fn key_splits_provider_and_field() {
    let (provider, field) = beachcomber::protocol::split_key("git.branch");
    assert_eq!(provider, "git");
    assert_eq!(field, Some("branch"));
}

#[test]
fn key_without_field() {
    let (provider, field) = beachcomber::protocol::split_key("battery");
    assert_eq!(provider, "battery");
    assert_eq!(field, None);
}

#[test]
fn key_with_dotted_field() {
    let (provider, field) = beachcomber::protocol::split_key("mise.tools");
    assert_eq!(provider, "mise");
    assert_eq!(field, Some("tools"));
}