orcid 0.2.2

A wrapper around the ORCID API
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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

use std::error::Error;
use std::fmt;

/// Custom error type for the ORCID library
#[derive(Debug)]
pub enum OrcidError {
    /// Invalid ORCID ID format or checksum
    InvalidOrcidId(String),

    /// Network request failed
    NetworkError(reqwest::Error),

    /// Failed to parse JSON response
    JsonError(serde_json::Error),

    /// API returned an error
    ApiError {
        orcid_id: String,
        error_code: String,
        developer_message: String,
    },

    /// API returned a response that could not be parsed
    BadApiResponse(serde_json::Value),
}

impl fmt::Display for OrcidError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            OrcidError::InvalidOrcidId(id) => {
                write!(f, "{} is not a valid ORCID ID", id)
            }
            OrcidError::NetworkError(e) => {
                write!(f, "Network request failed: {}", e)
            }
            OrcidError::JsonError(e) => {
                write!(f, "Failed to parse JSON: {}", e)
            }
            OrcidError::ApiError {
                orcid_id,
                error_code,
                developer_message,
            } => {
                write!(
                    f,
                    "API error for ORCID {}: {} - {}",
                    orcid_id, error_code, developer_message
                )
            }
            OrcidError::BadApiResponse(json) => {
                write!(f, "Unexpected API response: {}", json)
            }
        }
    }
}

impl Error for OrcidError {
    fn source(&self) -> Option<&(dyn Error + 'static)> {
        match self {
            OrcidError::NetworkError(e) => Some(e),
            OrcidError::JsonError(e) => Some(e),
            _ => None,
        }
    }
}

impl From<reqwest::Error> for OrcidError {
    fn from(err: reqwest::Error) -> Self {
        OrcidError::NetworkError(err)
    }
}

impl From<serde_json::Error> for OrcidError {
    fn from(err: serde_json::Error) -> Self {
        OrcidError::JsonError(err)
    }
}

/// Result type alias for ORCID operations
pub type Result<T> = std::result::Result<T, OrcidError>;

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

    #[test]
    fn test_invalid_orcid_id_display() {
        let error = OrcidError::InvalidOrcidId("1234-5678".to_string());
        assert_eq!(error.to_string(), "1234-5678 is not a valid ORCID ID");
    }

    #[test]
    fn test_api_error_display() {
        let error = OrcidError::ApiError {
            orcid_id: "0000-0001-2345-6789".to_string(),
            error_code: "404".to_string(),
            developer_message: "ORCID not found".to_string(),
        };
        assert_eq!(
            error.to_string(),
            "API error for ORCID 0000-0001-2345-6789: 404 - ORCID not found"
        );
    }

    #[test]
    fn test_bad_api_response_display() {
        let json = serde_json::json!({ "unexpected": "payload" });
        let error = OrcidError::BadApiResponse(json);
        assert!(error.to_string().contains("Unexpected API response"));
        assert!(error.to_string().contains("unexpected"));
    }

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

    #[test]
    fn test_from_reqwest_error() {
        // We can't easily create a real reqwest::Error, so we'll test the trait implementation exists
        fn _takes_reqwest_error(e: reqwest::Error) -> OrcidError {
            // Exercises the From conversion directly
            OrcidError::from(e)
        }
    }

    #[test]
    fn test_from_json_error() {
        let json_err = serde_json::from_str::<String>("invalid json").unwrap_err();
        let orcid_err: OrcidError = json_err.into();
        match orcid_err {
            OrcidError::JsonError(_) => (),
            _ => panic!("Expected JsonError variant"),
        }
    }
}