use std::borrow::Cow;
use async_trait::async_trait;
use http::{self, header, Method, Request};
use reqwest::Url;
use serde::de::DeserializeOwned;
use crate::api::{
query, ApiError, AsyncClient, AsyncQuery, BodyError, Client, Query, QueryParams, RestClient,
};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub enum UrlBase {
ApiV4,
Instance,
}
impl UrlBase {
pub fn endpoint_for<C>(&self, client: &C, endpoint: &str) -> Result<Url, ApiError<C::Error>>
where
C: RestClient,
{
match self {
UrlBase::ApiV4 => client.rest_endpoint(endpoint),
UrlBase::Instance => client.instance_endpoint(endpoint),
}
}
}
pub trait Endpoint {
fn method(&self) -> Method;
fn endpoint(&self) -> Cow<'static, str>;
fn url_base(&self) -> UrlBase {
UrlBase::ApiV4
}
fn parameters(&self) -> QueryParams {
QueryParams::default()
}
fn body(&self) -> Result<Option<(&'static str, Vec<u8>)>, BodyError> {
Ok(None)
}
}
impl<E> Endpoint for &E
where
E: Endpoint,
{
fn method(&self) -> Method {
(*self).method()
}
fn endpoint(&self) -> Cow<'static, str> {
(*self).endpoint()
}
fn url_base(&self) -> UrlBase {
(*self).url_base()
}
fn parameters(&self) -> QueryParams {
(*self).parameters()
}
fn body(&self) -> Result<Option<(&'static str, Vec<u8>)>, BodyError> {
(*self).body()
}
}
impl<E, T, C> Query<T, C> for E
where
E: Endpoint,
T: DeserializeOwned,
C: Client,
{
fn query(&self, client: &C) -> Result<T, ApiError<C::Error>> {
let mut url = self.url_base().endpoint_for(client, &self.endpoint())?;
self.parameters().add_to_url(&mut url);
let req = Request::builder()
.method(self.method())
.uri(query::url_to_http_uri(url));
let (req, data) = if let Some((mime, data)) = self.body()? {
let req = req.header(header::CONTENT_TYPE, mime);
(req, data)
} else {
(req, Vec::new())
};
let rsp = client.rest(req, data)?;
let status = rsp.status();
let v = if let Ok(v) = serde_json::from_slice(rsp.body()) {
v
} else {
return Err(ApiError::server_error(status, rsp.body()));
};
if !status.is_success() {
return Err(ApiError::from_gitlab(v));
} else if status == http::StatusCode::MOVED_PERMANENTLY {
return Err(ApiError::moved_permanently(
rsp.headers().get(http::header::LOCATION),
));
}
serde_json::from_value::<T>(v).map_err(ApiError::data_type::<T>)
}
}
#[async_trait]
impl<E, T, C> AsyncQuery<T, C> for E
where
E: Endpoint + Sync,
T: DeserializeOwned + 'static,
C: AsyncClient + Sync,
{
async fn query_async(&self, client: &C) -> Result<T, ApiError<C::Error>> {
let mut url = self.url_base().endpoint_for(client, &self.endpoint())?;
self.parameters().add_to_url(&mut url);
let req = Request::builder()
.method(self.method())
.uri(query::url_to_http_uri(url));
let (req, data) = if let Some((mime, data)) = self.body()? {
let req = req.header(header::CONTENT_TYPE, mime);
(req, data)
} else {
(req, Vec::new())
};
let rsp = client.rest_async(req, data).await?;
let status = rsp.status();
let v = if let Ok(v) = serde_json::from_slice(rsp.body()) {
v
} else {
return Err(ApiError::server_error(status, rsp.body()));
};
if !status.is_success() {
return Err(ApiError::from_gitlab(v));
} else if status == http::StatusCode::MOVED_PERMANENTLY {
return Err(ApiError::moved_permanently(
rsp.headers().get(http::header::LOCATION),
));
}
serde_json::from_value::<T>(v).map_err(ApiError::data_type::<T>)
}
}
#[cfg(test)]
mod tests {
use http::StatusCode;
use serde::Deserialize;
use serde_json::json;
use crate::api::endpoint_prelude::*;
use crate::api::{ApiError, AsyncQuery, Query};
use crate::test::client::{ExpectedUrl, SingleTestClient};
struct Dummy;
impl Endpoint for Dummy {
fn method(&self) -> Method {
Method::GET
}
fn endpoint(&self) -> Cow<'static, str> {
"dummy".into()
}
}
#[derive(Debug, Deserialize)]
struct DummyResult {
value: u8,
}
#[test]
fn test_gitlab_non_json_response() {
let endpoint = ExpectedUrl::builder().endpoint("dummy").build().unwrap();
let client = SingleTestClient::new_raw(endpoint, "not json");
let res: Result<DummyResult, _> = Dummy.query(&client);
let err = res.unwrap_err();
if let ApiError::GitlabService {
status, ..
} = err
{
assert_eq!(status, http::StatusCode::OK);
} else {
panic!("unexpected error: {}", err);
}
}
#[test]
fn test_gitlab_empty_response() {
let endpoint = ExpectedUrl::builder().endpoint("dummy").build().unwrap();
let client = SingleTestClient::new_raw(endpoint, "");
let res: Result<DummyResult, _> = Dummy.query(&client);
let err = res.unwrap_err();
if let ApiError::GitlabService {
status, ..
} = err
{
assert_eq!(status, http::StatusCode::OK);
} else {
panic!("unexpected error: {}", err);
}
}
#[test]
fn test_gitlab_error_bad_json() {
let endpoint = ExpectedUrl::builder()
.endpoint("dummy")
.status(StatusCode::NOT_FOUND)
.build()
.unwrap();
let client = SingleTestClient::new_raw(endpoint, "");
let res: Result<DummyResult, _> = Dummy.query(&client);
let err = res.unwrap_err();
if let ApiError::GitlabService {
status, ..
} = err
{
assert_eq!(status, http::StatusCode::NOT_FOUND);
} else {
panic!("unexpected error: {}", err);
}
}
#[test]
fn test_gitlab_error_detection() {
let endpoint = ExpectedUrl::builder()
.endpoint("dummy")
.status(StatusCode::NOT_FOUND)
.build()
.unwrap();
let client = SingleTestClient::new_json(
endpoint,
&json!({
"message": "dummy error message",
}),
);
let res: Result<DummyResult, _> = Dummy.query(&client);
let err = res.unwrap_err();
if let ApiError::Gitlab {
msg,
} = err
{
assert_eq!(msg, "dummy error message");
} else {
panic!("unexpected error: {}", err);
}
}
#[test]
fn test_gitlab_error_detection_legacy() {
let endpoint = ExpectedUrl::builder()
.endpoint("dummy")
.status(StatusCode::NOT_FOUND)
.build()
.unwrap();
let client = SingleTestClient::new_json(
endpoint,
&json!({
"error": "dummy error message",
}),
);
let res: Result<DummyResult, _> = Dummy.query(&client);
let err = res.unwrap_err();
if let ApiError::Gitlab {
msg,
} = err
{
assert_eq!(msg, "dummy error message");
} else {
panic!("unexpected error: {}", err);
}
}
#[test]
fn test_gitlab_error_detection_unknown() {
let endpoint = ExpectedUrl::builder()
.endpoint("dummy")
.status(StatusCode::NOT_FOUND)
.build()
.unwrap();
let err_obj = json!({
"bogus": "dummy error message",
});
let client = SingleTestClient::new_json(endpoint, &err_obj);
let res: Result<DummyResult, _> = Dummy.query(&client);
let err = res.unwrap_err();
if let ApiError::GitlabUnrecognized {
obj,
} = err
{
assert_eq!(obj, err_obj);
} else {
panic!("unexpected error: {}", err);
}
}
#[test]
fn test_bad_deserialization() {
let endpoint = ExpectedUrl::builder().endpoint("dummy").build().unwrap();
let client = SingleTestClient::new_json(
endpoint,
&json!({
"not_value": 0,
}),
);
let res: Result<DummyResult, _> = Dummy.query(&client);
let err = res.unwrap_err();
if let ApiError::DataType {
source,
typename,
} = err
{
assert_eq!(source.to_string(), "missing field `value`");
assert_eq!(typename, "gitlab::api::endpoint::tests::DummyResult");
} else {
panic!("unexpected error: {}", err);
}
}
#[test]
fn test_good_deserialization() {
let endpoint = ExpectedUrl::builder().endpoint("dummy").build().unwrap();
let client = SingleTestClient::new_json(
endpoint,
&json!({
"value": 0,
}),
);
let res: DummyResult = Dummy.query(&client).unwrap();
assert_eq!(res.value, 0);
}
#[tokio::test]
async fn test_good_deserialization_async() {
let endpoint = ExpectedUrl::builder().endpoint("dummy").build().unwrap();
let client = SingleTestClient::new_json(
endpoint,
&json!({
"value": 0,
}),
);
let res: DummyResult = Dummy.query_async(&client).await.unwrap();
assert_eq!(res.value, 0);
}
}