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
88
89
90
91
92
93
94
95
96
97
98
99
100
101

#![allow(missing_docs)]

use fraiseql_error::AuthError;

#[test]
fn invalid_credentials_error_code() {
    assert_eq!(AuthError::InvalidCredentials.error_code(), "invalid_credentials");
}

#[test]
fn invalid_credentials_display() {
    assert_eq!(AuthError::InvalidCredentials.to_string(), "Invalid credentials");
}

#[test]
fn token_expired_error_code() {
    assert_eq!(AuthError::TokenExpired.error_code(), "token_expired");
}

#[test]
fn token_expired_display() {
    assert_eq!(AuthError::TokenExpired.to_string(), "Token expired");
}

#[test]
fn invalid_token_error_code() {
    let err = AuthError::InvalidToken {
        reason: "malformed".into(),
    };
    assert_eq!(err.error_code(), "invalid_token");
}

#[test]
fn invalid_token_display_interpolates_reason() {
    let err = AuthError::InvalidToken {
        reason: "malformed JWT".into(),
    };
    assert_eq!(err.to_string(), "Invalid token: malformed JWT");
}

#[test]
fn provider_error_code_and_display() {
    let err = AuthError::ProviderError {
        provider: "google".into(),
        message:  "timeout".into(),
    };
    assert_eq!(err.error_code(), "auth_provider_error");
    assert_eq!(err.to_string(), "Provider error: google - timeout");
}

#[test]
fn invalid_state_error_code() {
    assert_eq!(AuthError::InvalidState.error_code(), "invalid_oauth_state");
}

#[test]
fn invalid_state_display() {
    assert_eq!(AuthError::InvalidState.to_string(), "Invalid OAuth state");
}

#[test]
fn user_denied_error_code_and_display() {
    assert_eq!(AuthError::UserDenied.error_code(), "user_denied");
    assert_eq!(AuthError::UserDenied.to_string(), "User denied authorization");
}

#[test]
fn session_not_found_error_code_and_display() {
    assert_eq!(AuthError::SessionNotFound.error_code(), "session_not_found");
    assert_eq!(AuthError::SessionNotFound.to_string(), "Session not found");
}

#[test]
fn session_expired_error_code_and_display() {
    assert_eq!(AuthError::SessionExpired.error_code(), "session_expired");
    assert_eq!(AuthError::SessionExpired.to_string(), "Session expired");
}

#[test]
fn insufficient_permissions_error_code_and_display() {
    let err = AuthError::InsufficientPermissions {
        required: "admin".into(),
    };
    assert_eq!(err.error_code(), "insufficient_permissions");
    assert_eq!(err.to_string(), "Insufficient permissions: requires admin");
}

#[test]
fn refresh_token_invalid_error_code_and_display() {
    assert_eq!(AuthError::RefreshTokenInvalid.error_code(), "refresh_token_invalid");
    assert_eq!(AuthError::RefreshTokenInvalid.to_string(), "Refresh token invalid or expired");
}

#[test]
fn account_locked_error_code_and_display() {
    let err = AuthError::AccountLocked {
        reason: "too many attempts".into(),
    };
    assert_eq!(err.error_code(), "account_locked");
    assert_eq!(err.to_string(), "Account locked: too many attempts");
}