beachcomber 0.4.0

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
101
102
103
104
105

use beachcomber::provider::{ProviderResult, Value};
use std::collections::HashMap;

#[test]
fn value_from_string() {
    let v = Value::String("hello".to_string());
    assert_eq!(v.as_text(), "hello", "String value should render as text");
}

#[test]
fn value_from_int() {
    let v = Value::Int(42);
    assert_eq!(v.as_text(), "42", "Int value should render as text");
}

#[test]
fn value_from_bool() {
    let v = Value::Bool(true);
    assert_eq!(v.as_text(), "true", "Bool value should render as text");
}

#[test]
fn value_from_float() {
    let v = Value::Float(1.5);
    assert_eq!(v.as_text(), "1.5", "Float value should render as text");
}

#[test]
fn value_serializes_to_json() {
    let v = Value::String("main".to_string());
    let json = serde_json::to_value(&v).unwrap();
    assert_eq!(
        json,
        serde_json::json!("main"),
        "String value should serialize as JSON string"
    );
}

#[test]
fn value_int_serializes_to_json() {
    let v = Value::Int(42);
    let json = serde_json::to_value(&v).unwrap();
    assert_eq!(
        json,
        serde_json::json!(42),
        "Int value should serialize as JSON number"
    );
}

#[test]
fn provider_result_single_field() {
    let mut fields = HashMap::new();
    fields.insert("name".to_string(), Value::String("myhost".to_string()));
    let result = ProviderResult { fields };
    assert_eq!(
        result.get("name").unwrap().as_text(),
        "myhost",
        "Should retrieve single field"
    );
}

#[test]
fn provider_result_missing_field() {
    let result = ProviderResult {
        fields: HashMap::new(),
    };
    assert!(
        result.get("missing").is_none(),
        "Missing field should return None"
    );
}

#[test]
fn provider_result_to_json_object() {
    let mut fields = HashMap::new();
    fields.insert("name".to_string(), Value::String("myhost".to_string()));
    fields.insert("short".to_string(), Value::String("myh".to_string()));
    let result = ProviderResult { fields };
    let json = result.to_json();
    assert_eq!(json["name"], serde_json::json!("myhost"));
    assert_eq!(json["short"], serde_json::json!("myh"));
}

#[test]
fn provider_result_to_kv_text() {
    let mut fields = HashMap::new();
    fields.insert("name".to_string(), Value::String("myhost".to_string()));
    let result = ProviderResult { fields };
    let text = result.to_kv_text();
    assert_eq!(text, "name=myhost\n", "Should format as key=value lines");
}

#[test]
fn provider_source_default_is_builtin() {
    use beachcomber::provider::ProviderSource;
    let source = ProviderSource::default();
    assert!(matches!(source, ProviderSource::Builtin));
}

#[test]
fn provider_source_ordering() {
    use beachcomber::provider::ProviderSource;
    assert!(ProviderSource::Builtin < ProviderSource::Script);
    assert!(ProviderSource::Script < ProviderSource::Virtual);
}