use std::any;
use std::error::Error;
use thiserror::Error;
use crate::api::PaginationError;
#[derive(Debug, Error)]
#[non_exhaustive]
pub enum BodyError {
#[error("failed to URL encode form parameters: {}", source)]
UrlEncoded {
#[from]
source: serde_urlencoded::ser::Error,
},
}
#[derive(Debug, Error)]
#[non_exhaustive]
pub enum ApiError<E>
where
E: Error + Send + Sync + 'static,
{
#[error("client error: {}", source)]
Client {
source: E,
},
#[error("failed to parse url: {}", source)]
UrlParse {
#[from]
source: url::ParseError,
},
#[error("failed to create form data: {}", source)]
Body {
#[from]
source: BodyError,
},
#[error("could not parse JSON response: {}", source)]
Json {
#[from]
source: serde_json::Error,
},
#[error("gitlab server error: {}", msg)]
Gitlab {
msg: String,
},
#[error("gitlab internal server error {}", status)]
GitlabService {
status: http::StatusCode,
data: Vec<u8>,
},
#[error("gitlab server error: {:?}", obj)]
GitlabObject {
obj: serde_json::Value,
},
#[error("gitlab server error: {:?}", obj)]
GitlabUnrecognized {
obj: serde_json::Value,
},
#[error("could not parse {} data from JSON: {}", typename, source)]
DataType {
source: serde_json::Error,
typename: &'static str,
},
#[error("failed to handle for pagination: {}", source)]
Pagination {
#[from]
source: PaginationError,
},
}
impl<E> ApiError<E>
where
E: Error + Send + Sync + 'static,
{
pub fn client(source: E) -> Self {
ApiError::Client {
source,
}
}
pub fn map_client<F, W>(self, f: F) -> ApiError<W>
where
F: FnOnce(E) -> W,
W: Error + Send + Sync + 'static,
{
match self {
Self::Client {
source,
} => ApiError::client(f(source)),
Self::UrlParse {
source,
} => {
ApiError::UrlParse {
source,
}
},
Self::Body {
source,
} => {
ApiError::Body {
source,
}
},
Self::Json {
source,
} => {
ApiError::Json {
source,
}
},
Self::Gitlab {
msg,
} => {
ApiError::Gitlab {
msg,
}
},
Self::GitlabService {
status,
data,
} => {
ApiError::GitlabService {
status,
data,
}
},
Self::GitlabObject {
obj,
} => {
ApiError::GitlabObject {
obj,
}
},
Self::GitlabUnrecognized {
obj,
} => {
ApiError::GitlabUnrecognized {
obj,
}
},
Self::DataType {
source,
typename,
} => {
ApiError::DataType {
source,
typename,
}
},
Self::Pagination {
source,
} => {
ApiError::Pagination {
source,
}
},
}
}
pub(crate) fn server_error(status: http::StatusCode, body: &bytes::Bytes) -> Self {
Self::GitlabService {
status,
data: body.into_iter().copied().collect(),
}
}
pub(crate) fn from_gitlab(value: serde_json::Value) -> Self {
let error_value = value
.pointer("/message")
.or_else(|| value.pointer("/error"));
if let Some(error_value) = error_value {
if let Some(msg) = error_value.as_str() {
ApiError::Gitlab {
msg: msg.into(),
}
} else {
ApiError::GitlabObject {
obj: error_value.clone(),
}
}
} else {
ApiError::GitlabUnrecognized {
obj: value,
}
}
}
pub(crate) fn data_type<T>(source: serde_json::Error) -> Self {
ApiError::DataType {
source,
typename: any::type_name::<T>(),
}
}
}
#[cfg(test)]
mod tests {
use serde_json::json;
use thiserror::Error;
use crate::api::ApiError;
#[derive(Debug, Error)]
#[error("my error")]
enum MyError {}
#[test]
fn gitlab_error_error() {
let obj = json!({
"error": "error contents",
});
let err: ApiError<MyError> = ApiError::from_gitlab(obj);
if let ApiError::Gitlab {
msg,
} = err
{
assert_eq!(msg, "error contents");
} else {
panic!("unexpected error: {}", err);
}
}
#[test]
fn gitlab_error_message_string() {
let obj = json!({
"message": "error contents",
});
let err: ApiError<MyError> = ApiError::from_gitlab(obj);
if let ApiError::Gitlab {
msg,
} = err
{
assert_eq!(msg, "error contents");
} else {
panic!("unexpected error: {}", err);
}
}
#[test]
fn gitlab_error_message_object() {
let err_obj = json!({
"blah": "foo",
});
let obj = json!({
"message": err_obj,
});
let err: ApiError<MyError> = ApiError::from_gitlab(obj);
if let ApiError::GitlabObject {
obj,
} = err
{
assert_eq!(obj, err_obj);
} else {
panic!("unexpected error: {}", err);
}
}
#[test]
fn gitlab_error_message_unrecognized() {
let err_obj = json!({
"some_weird_key": "an even weirder value",
});
let err: ApiError<MyError> = ApiError::from_gitlab(err_obj.clone());
if let ApiError::GitlabUnrecognized {
obj,
} = err
{
assert_eq!(obj, err_obj);
} else {
panic!("unexpected error: {}", err);
}
}
}