chorus-core 0.1.0

Core traits and types for Chorus CPaaS
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

use thiserror::Error;

#[derive(Debug, Error)]
pub enum ChorusError {
    #[error("provider error ({provider}): {message}")]
    Provider { provider: String, message: String },

    #[error("all providers failed")]
    AllProvidersFailed,

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

    #[error("template not found: {0}")]
    TemplateNotFound(String),

    #[error("quota exceeded: {0}")]
    QuotaExceeded(String),

    #[error("invalid api key")]
    InvalidApiKey,

    #[error("rate limited")]
    RateLimited { retry_after_secs: u64 },

    #[error("internal error: {0}")]
    Internal(#[from] anyhow::Error),
}

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

    #[test]
    fn provider_error_display() {
        let err = ChorusError::Provider {
            provider: "twilio".into(),
            message: "timeout".into(),
        };
        assert_eq!(err.to_string(), "provider error (twilio): timeout");
    }

    #[test]
    fn all_providers_failed_display() {
        let err = ChorusError::AllProvidersFailed;
        assert_eq!(err.to_string(), "all providers failed");
    }

    #[test]
    fn validation_error_display() {
        let err = ChorusError::Validation("missing phone number".into());
        assert_eq!(err.to_string(), "validation error: missing phone number");
    }

    #[test]
    fn template_not_found_display() {
        let err = ChorusError::TemplateNotFound("welcome".into());
        assert_eq!(err.to_string(), "template not found: welcome");
    }

    #[test]
    fn quota_exceeded_display() {
        let err = ChorusError::QuotaExceeded("monthly limit reached".into());
        assert_eq!(err.to_string(), "quota exceeded: monthly limit reached");
    }

    #[test]
    fn invalid_api_key_display() {
        let err = ChorusError::InvalidApiKey;
        assert_eq!(err.to_string(), "invalid api key");
    }

    #[test]
    fn rate_limited_display() {
        let err = ChorusError::RateLimited {
            retry_after_secs: 30,
        };
        assert_eq!(err.to_string(), "rate limited");
    }

    #[test]
    fn internal_error_from_anyhow() {
        let anyhow_err = anyhow::anyhow!("something broke");
        let err = ChorusError::from(anyhow_err);
        assert!(err.to_string().contains("something broke"));
    }
}