muxtop-core 0.4.2

Core data collection engine for muxtop
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

use thiserror::Error;

use crate::cluster_engine::ClusterError;
use crate::container_engine::EngineError;

#[derive(Debug, Error)]
pub enum CoreError {
    #[error("collection failed: {0}")]
    Collection(String),

    #[error("process {pid} not found")]
    ProcessNotFound { pid: u32 },

    #[error("permission denied: {0}")]
    Permission(String),

    #[error("I/O error: {0}")]
    Io(#[from] std::io::Error),

    #[error("channel closed")]
    ChannelClosed,

    #[error("container engine: {0}")]
    Engine(#[from] EngineError),

    #[error("cluster engine: {0}")]
    Cluster(#[from] ClusterError),
}

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

    #[test]
    fn test_error_display() {
        let variants: Vec<CoreError> = vec![
            CoreError::Collection("test".into()),
            CoreError::ProcessNotFound { pid: 42 },
            CoreError::Permission("denied".into()),
            CoreError::Io(std::io::Error::other("io err")),
            CoreError::ChannelClosed,
            CoreError::Engine(EngineError::ConnectFailed("refused".into())),
            CoreError::Cluster(ClusterError::KubeconfigNotFound),
        ];
        for err in &variants {
            let msg = format!("{err}");
            assert!(!msg.is_empty(), "Display for {err:?} was empty");
        }
    }

    #[test]
    fn core_error_from_engine_error() {
        let eng = EngineError::ConnectFailed("refused".into());
        let core: CoreError = eng.into();
        assert!(matches!(
            core,
            CoreError::Engine(EngineError::ConnectFailed(_))
        ));
    }

    #[test]
    fn core_error_from_cluster_error() {
        let cluster = ClusterError::Unreachable("dns failed".into());
        let core: CoreError = cluster.into();
        assert!(matches!(
            core,
            CoreError::Cluster(ClusterError::Unreachable(_))
        ));
    }

    #[test]
    fn test_error_from_io() {
        let io_err = std::io::Error::new(std::io::ErrorKind::NotFound, "not found");
        let core_err: CoreError = io_err.into();
        assert!(matches!(core_err, CoreError::Io(_)));
    }

    #[test]
    fn test_error_is_send_sync() {
        fn assert_send_sync<T: Send + Sync>() {}
        assert_send_sync::<CoreError>();
    }

    #[test]
    fn test_error_is_std_error() {
        let err = CoreError::ChannelClosed;
        let _boxed: Box<dyn std::error::Error> = Box::new(err);
    }
}