fraiseql-error 2.0.0-beta.2

Error types for FraiseQL v2
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

#![allow(missing_docs)]

use std::time::Duration;

use fraiseql_error::NotificationError;

#[test]
fn configuration_error_code_and_display() {
    let err = NotificationError::Configuration {
        message: "missing API key".into(),
    };
    assert_eq!(err.error_code(), "notification_config_error");
    assert_eq!(err.to_string(), "Configuration error: missing API key");
}

#[test]
fn provider_error_code_and_display() {
    let err = NotificationError::Provider {
        provider: "sendgrid".into(),
        message:  "rate limited".into(),
    };
    assert_eq!(err.error_code(), "notification_provider_error");
    assert_eq!(err.to_string(), "Provider error: sendgrid - rate limited");
}

#[test]
fn provider_unavailable_error_code_and_display() {
    let err = NotificationError::ProviderUnavailable {
        provider:    "twilio".into(),
        retry_after: Some(Duration::from_secs(30)),
    };
    assert_eq!(err.error_code(), "notification_provider_unavailable");
    assert_eq!(err.to_string(), "Provider unavailable: twilio");
}

#[test]
fn provider_unavailable_without_retry_after() {
    let err = NotificationError::ProviderUnavailable {
        provider:    "twilio".into(),
        retry_after: None,
    };
    assert_eq!(err.error_code(), "notification_provider_unavailable");
}

#[test]
fn invalid_input_error_code_and_display() {
    let err = NotificationError::InvalidInput {
        message: "empty recipient".into(),
    };
    assert_eq!(err.error_code(), "notification_invalid_input");
    assert_eq!(err.to_string(), "Invalid input: empty recipient");
}

#[test]
fn template_error_code_and_display() {
    let err = NotificationError::Template {
        message: "missing variable".into(),
    };
    assert_eq!(err.error_code(), "notification_template_error");
    assert_eq!(err.to_string(), "Template error: missing variable");
}

#[test]
fn provider_rate_limited_error_code_and_display() {
    let err = NotificationError::ProviderRateLimited {
        provider: "sns".into(),
        seconds:  60,
    };
    assert_eq!(err.error_code(), "notification_rate_limited");
    assert_eq!(err.to_string(), "Rate limited by provider: retry after 60 seconds");
}

#[test]
fn circuit_open_error_code_and_display() {
    let err = NotificationError::CircuitOpen {
        provider:    "ses".into(),
        retry_after: Duration::from_secs(120),
    };
    assert_eq!(err.error_code(), "notification_circuit_open");
    assert_eq!(err.to_string(), "Circuit breaker open for provider: ses");
}

#[test]
fn timeout_error_code_and_display() {
    assert_eq!(NotificationError::Timeout.error_code(), "notification_timeout");
    assert_eq!(NotificationError::Timeout.to_string(), "Timeout sending notification");
}