herolib-mos 0.3.13

use std::io;
use thiserror::Error;

#[derive(Error, Debug)]
pub enum NetworkError {
    #[error("IO error: {0}")]
    Io(#[from] io::Error),

    #[error("System error: {0}")]
    System(#[from] nix::Error),

    #[error("Namespace error: {0}")]
    Namespace(String),

    #[error("Bridge error: {0}")]
    Bridge(String),

    #[error("Interface error: {0}")]
    Interface(String),

    #[error("Route error: {0}")]
    Route(String),

    #[error("Mycelium error: {0}")]
    Mycelium(String),

    #[error("Invalid parameter: {0}")]
    InvalidParameter(String),

    #[error("Resource not found: {0}")]
    NotFound(String),

    #[error("Resource already exists: {0}")]
    AlreadyExists(String),

    #[error("Command execution failed: {0}")]
    CommandFailed(String),

    #[error("Parse error: {0}")]
    Parse(String),

    #[error("Script error: {0}")]
    Script(String),
}

pub type Result<T> = std::result::Result<T, NetworkError>;

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

    #[test]
    fn test_namespace_error() {
        let err = NetworkError::Namespace("test error".to_string());
        assert_eq!(err.to_string(), "Namespace error: test error");
    }

    #[test]
    fn test_bridge_error() {
        let err = NetworkError::Bridge("bridge creation failed".to_string());
        assert_eq!(err.to_string(), "Bridge error: bridge creation failed");
    }

    #[test]
    fn test_interface_error() {
        let err = NetworkError::Interface("interface not found".to_string());
        assert_eq!(err.to_string(), "Interface error: interface not found");
    }

    #[test]
    fn test_route_error() {
        let err = NetworkError::Route("invalid route".to_string());
        assert_eq!(err.to_string(), "Route error: invalid route");
    }

    #[test]
    fn test_mycelium_error() {
        let err = NetworkError::Mycelium("mycelium setup failed".to_string());
        assert_eq!(err.to_string(), "Mycelium error: mycelium setup failed");
    }

    #[test]
    fn test_invalid_parameter_error() {
        let err = NetworkError::InvalidParameter("invalid input".to_string());
        assert_eq!(err.to_string(), "Invalid parameter: invalid input");
    }

    #[test]
    fn test_not_found_error() {
        let err = NetworkError::NotFound("resource missing".to_string());
        assert_eq!(err.to_string(), "Resource not found: resource missing");
    }

    #[test]
    fn test_already_exists_error() {
        let err = NetworkError::AlreadyExists("duplicate resource".to_string());
        assert_eq!(
            err.to_string(),
            "Resource already exists: duplicate resource"
        );
    }

    #[test]
    fn test_command_failed_error() {
        let err = NetworkError::CommandFailed("command returned non-zero".to_string());
        assert_eq!(
            err.to_string(),
            "Command execution failed: command returned non-zero"
        );
    }

    #[test]
    fn test_parse_error() {
        let err = NetworkError::Parse("invalid format".to_string());
        assert_eq!(err.to_string(), "Parse error: invalid format");
    }

    #[test]
    fn test_io_error_conversion() {
        let io_err = io::Error::new(io::ErrorKind::NotFound, "file not found");
        let net_err: NetworkError = io_err.into();
        assert!(matches!(net_err, NetworkError::Io(_)));
    }

    #[test]
    fn test_result_type() {
        let success: Result<i32> = Ok(42);
        assert_eq!(success.unwrap(), 42);

        let failure: Result<i32> = Err(NetworkError::NotFound("test".to_string()));
        assert!(failure.is_err());
    }
}