scoutquest-rust 1.4.0

Rust SDK for ScoutQuest Service Discovery - Universal service discovery for microservices architectures
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 thiserror::Error;

/// Errors that can occur when using the ScoutQuest Rust SDK.
///
/// This enum covers all possible error conditions including network failures,
/// service discovery issues, and protocol-level errors.
#[derive(Error, Debug)]
pub enum ScoutQuestError {
    /// Network-related errors (connection failures, timeouts, etc.)
    #[error("Network error: {0}")]
    NetworkError(#[from] reqwest::Error),

    /// The requested service was not found in the discovery registry
    #[error("Service isn't found: {service_name}")]
    ServiceNotFound { service_name: String },

    /// A specific service instance was not found
    #[error("Instance isn't found: {instance_id}")]
    InstanceNotFound { instance_id: String },

    /// Service registration failed with the discovery server
    #[error("Registration failed: {status} - {message}")]
    RegistrationFailed { status: u16, message: String },

    /// JSON serialization/deserialization error
    #[error("Serialization error: {0}")]
    SerializationError(#[from] serde_json::Error),

    /// Invalid URL format provided
    #[error("Invalid URL: {0}")]
    InvalidUrl(#[from] url::ParseError),

    /// The ScoutQuest discovery server is not available
    #[error("ScoutQuest Server unavailable")]
    ServerUnavailable,

    /// Operation timed out
    #[error("Operation timeout")]
    Timeout,

    /// No healthy instances are available for the requested service
    #[error("No healthy instances available for service: {service_name}")]
    NoHealthyInstances { service_name: String },

    /// Internal error or unexpected condition
    #[error("Internal error: {0}")]
    InternalError(String),
}

/// Convenience type alias for Results in the ScoutQuest SDK.
pub type Result<T> = std::result::Result<T, ScoutQuestError>;

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

    #[test]
    fn test_error_display() {
        let error = ScoutQuestError::ServiceNotFound {
            service_name: "test-service".to_string(),
        };
        assert_eq!(error.to_string(), "Service isn't found: test-service");

        let error = ScoutQuestError::InstanceNotFound {
            instance_id: "instance-123".to_string(),
        };
        assert_eq!(error.to_string(), "Instance isn't found: instance-123");

        let error = ScoutQuestError::RegistrationFailed {
            status: 500,
            message: "Internal server error".to_string(),
        };
        assert_eq!(
            error.to_string(),
            "Registration failed: 500 - Internal server error"
        );

        let error = ScoutQuestError::NoHealthyInstances {
            service_name: "api-service".to_string(),
        };
        assert_eq!(
            error.to_string(),
            "No healthy instances available for service: api-service"
        );

        let error = ScoutQuestError::InternalError("Something went wrong".to_string());
        assert_eq!(error.to_string(), "Internal error: Something went wrong");

        let error = ScoutQuestError::ServerUnavailable;
        assert_eq!(error.to_string(), "ScoutQuest Server unavailable");

        let error = ScoutQuestError::Timeout;
        assert_eq!(error.to_string(), "Operation timeout");
    }

    #[test]
    fn test_error_debug() {
        let error = ScoutQuestError::ServiceNotFound {
            service_name: "test".to_string(),
        };
        let debug_str = format!("{:?}", error);
        assert!(debug_str.contains("ServiceNotFound"));
        assert!(debug_str.contains("test"));
    }
}