brainwires-network 0.11.0

Agent-to-agent networking — IPC, remote bridge, mesh networking, routing, and discovery for Brainwires
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

use thiserror::Error;

/// Errors that can occur within the mesh networking layer.
#[derive(Debug, Clone, Error)]
pub enum MeshError {
    /// The requested node was not found in the mesh.
    #[error("node not found: {0}")]
    NodeNotFound(String),

    /// A message could not be routed to its destination.
    #[error("routing failed: {0}")]
    RoutingFailed(String),

    /// Peer discovery failed.
    #[error("discovery failed: {0}")]
    DiscoveryFailed(String),

    /// A federation request was denied by policy.
    #[error("federation denied: {0}")]
    FederationDenied(String),

    /// An error occurred while modifying the mesh topology.
    #[error("topology error: {0}")]
    TopologyError(String),

    /// A transport-level error occurred.
    #[error("transport error: {0}")]
    Transport(String),

    /// An internal or unexpected error.
    #[error("internal error: {0}")]
    Internal(String),
}

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

    #[test]
    fn node_not_found_display() {
        let err = MeshError::NodeNotFound("abc-123".into());
        assert_eq!(err.to_string(), "node not found: abc-123");
    }

    #[test]
    fn routing_failed_display() {
        let err = MeshError::RoutingFailed("no path".into());
        assert_eq!(err.to_string(), "routing failed: no path");
    }

    #[test]
    fn discovery_failed_display() {
        let err = MeshError::DiscoveryFailed("timeout".into());
        assert_eq!(err.to_string(), "discovery failed: timeout");
    }

    #[test]
    fn federation_denied_display() {
        let err = MeshError::FederationDenied("policy violation".into());
        assert_eq!(err.to_string(), "federation denied: policy violation");
    }

    #[test]
    fn topology_error_display() {
        let err = MeshError::TopologyError("cycle detected".into());
        assert_eq!(err.to_string(), "topology error: cycle detected");
    }

    #[test]
    fn transport_error_display() {
        let err = MeshError::Transport("connection refused".into());
        assert_eq!(err.to_string(), "transport error: connection refused");
    }

    #[test]
    fn internal_error_display() {
        let err = MeshError::Internal("unexpected state".into());
        assert_eq!(err.to_string(), "internal error: unexpected state");
    }

    #[test]
    fn error_is_std_error() {
        let err = MeshError::Internal("test".into());
        // Verify it implements std::error::Error via trait object coercion
        let _: &dyn std::error::Error = &err;
    }

    #[test]
    fn error_debug_format() {
        let err = MeshError::NodeNotFound("xyz".into());
        let debug = format!("{:?}", err);
        assert!(debug.contains("NodeNotFound"));
        assert!(debug.contains("xyz"));
    }

    #[test]
    fn error_clone() {
        let err = MeshError::RoutingFailed("no route".into());
        let cloned = err.clone();
        assert_eq!(err.to_string(), cloned.to_string());
    }
}