oxihuman-core 0.1.2

Core data structures, algorithms, and asset management for OxiHuman
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

// Copyright (C) 2026 COOLJAPAN OU (Team KitaSan)
// SPDX-License-Identifier: Apache-2.0
#![allow(dead_code)]

pub struct HealthMonitor {
    pub checks: Vec<(String, bool)>,
}

impl HealthMonitor {
    pub fn new() -> Self {
        HealthMonitor { checks: Vec::new() }
    }
}

impl Default for HealthMonitor {
    fn default() -> Self {
        Self::new()
    }
}

pub fn new_health_monitor() -> HealthMonitor {
    HealthMonitor::new()
}

pub fn health_register(m: &mut HealthMonitor, name: &str, healthy: bool) {
    m.checks.push((name.to_string(), healthy));
}

/// Update an existing check. Returns true if the check was found.
pub fn health_update(m: &mut HealthMonitor, name: &str, healthy: bool) -> bool {
    for (n, h) in &mut m.checks {
        if n == name {
            *h = healthy;
            return true;
        }
    }
    false
}

pub fn health_all_ok(m: &HealthMonitor) -> bool {
    m.checks.iter().all(|(_, h)| *h)
}

pub fn health_count(m: &HealthMonitor) -> usize {
    m.checks.len()
}

pub fn health_failing_count(m: &HealthMonitor) -> usize {
    m.checks.iter().filter(|(_, h)| !h).count()
}

pub fn health_summary(m: &HealthMonitor) -> String {
    let total = m.checks.len();
    let failing = health_failing_count(m);
    format!("checks={} failing={}", total, failing)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_new_empty() {
        /* new monitor has no checks */
        let m = new_health_monitor();
        assert_eq!(health_count(&m), 0);
    }

    #[test]
    fn test_register_healthy() {
        /* register adds a healthy check */
        let mut m = new_health_monitor();
        health_register(&mut m, "db", true);
        assert!(health_all_ok(&m));
    }

    #[test]
    fn test_register_failing() {
        /* register adds a failing check */
        let mut m = new_health_monitor();
        health_register(&mut m, "db", false);
        assert!(!health_all_ok(&m));
        assert_eq!(health_failing_count(&m), 1);
    }

    #[test]
    fn test_update_existing() {
        /* update changes check status */
        let mut m = new_health_monitor();
        health_register(&mut m, "svc", false);
        assert!(health_update(&mut m, "svc", true));
        assert!(health_all_ok(&m));
    }

    #[test]
    fn test_update_missing() {
        /* update returns false for unknown check */
        let mut m = new_health_monitor();
        assert!(!health_update(&mut m, "ghost", true));
    }

    #[test]
    fn test_failing_count() {
        /* failing count is correct */
        let mut m = new_health_monitor();
        health_register(&mut m, "a", true);
        health_register(&mut m, "b", false);
        health_register(&mut m, "c", false);
        assert_eq!(health_failing_count(&m), 2);
    }

    #[test]
    fn test_summary_format() {
        /* summary contains expected fields */
        let mut m = new_health_monitor();
        health_register(&mut m, "x", true);
        health_register(&mut m, "y", false);
        let s = health_summary(&m);
        assert!(s.contains("checks=2"));
        assert!(s.contains("failing=1"));
    }
}