msrd0/deprecated-gotham-restful
1
0
Fork 0
mirror of https://gitlab.com/msrd0/gotham-restful.git synced 2025-02-23 21:12:28 +00:00
Code Issues Releases Activity Actions
deprecated-gotham-restful/gotham_restful/src/result.rs

588 lines
12 KiB
Rust
Raw Normal View History

Support File up/download
2019-10-20 14:49:53 +00:00
use crate::{ResponseBody, StatusCode};
openapi for read method
2019-10-01 00:23:34 +02:00
#[cfg(feature = "openapi")]
implement no-content response
2019-10-05 14:50:05 +02:00
use crate::{OpenapiSchema, OpenapiType};
Support File up/download
2019-10-20 14:49:53 +00:00
use hyper::Body;
add errorlog feature
2020-02-10 21:41:44 +01:00
use log::error;
Support File up/download
2019-10-20 14:49:53 +00:00
use mime::{Mime, APPLICATION_JSON, STAR_STAR};
#[cfg(feature = "openapi")]
use openapiv3::{SchemaKind, StringFormat, StringType, Type, VariantOrUnknownOrEmpty};
initial commit
2019-09-26 17:24:40 +02:00
use serde::Serialize;
attempt testing (doesn't work)
2019-09-27 15:35:02 +02:00
use serde_json::error::Error as SerdeJsonError;
add AuthResult resource result type
2020-01-25 15:59:37 +01:00
use std::{
error::Error,
fmt::Debug
};
initial commit
2019-09-26 17:24:40 +02:00
Support File up/download
2019-10-20 14:49:53 +00:00
/// A response, used to create the final gotham response from.
pub struct Response
{
pub status : StatusCode,
pub body : Body,
pub mime : Option<Mime>
}
impl Response
{
/// Create a new `Response` from raw data.
pub fn new<B : Into<Body>>(status : StatusCode, body : B, mime : Option<Mime>) -> Self
{
Self {
status,
body: body.into(),
mime
}
}
/// Create a `Response` with mime type json from already serialized data.
pub fn json<B : Into<Body>>(status : StatusCode, body : B) -> Self
{
Self {
status,
body: body.into(),
mime: Some(APPLICATION_JSON)
}
}
/// Create a _204 No Content_ `Response`.
pub fn no_content() -> Self
{
Self {
status: StatusCode::NO_CONTENT,
body: Body::empty(),
mime: None
}
}
add AuthResult resource result type
2020-01-25 15:59:37 +01:00
/// Create an empty _403 Forbidden_ `Response`.
pub fn forbidden() -> Self
{
Self {
status: StatusCode::FORBIDDEN,
body: Body::empty(),
mime: None
}
}
Support File up/download
2019-10-20 14:49:53 +00:00
#[cfg(test)]
fn full_body(self) -> Vec<u8>
{
use futures::{future::Future, stream::Stream};
let bytes : &[u8] = &self.body.concat2().wait().unwrap().into_bytes();
bytes.to_vec()
}
}
attempt testing (doesn't work)
2019-09-27 15:35:02 +02:00
/// A trait provided to convert a resource's result to json.
pub trait ResourceResult
initial commit
2019-09-26 17:24:40 +02:00
{
Support File up/download
2019-10-20 14:49:53 +00:00
/// Turn this into a response that can be returned to the browser. This api will likely
/// change in the future.
fn into_response(self) -> Result<Response, SerdeJsonError>;
/// Return a list of supported mime types.
fn accepted_types() -> Option<Vec<Mime>>
{
None
}
first valid openapi spec generated
2019-09-30 23:53:55 +02:00
#[cfg(feature = "openapi")]
apply clippy suggestions
2019-10-13 23:36:10 +02:00
fn schema() -> OpenapiSchema;
implement no-content response
2019-10-05 14:50:05 +02:00
#[cfg(feature = "openapi")]
fn default_status() -> StatusCode
{
StatusCode::OK
}
move security auth openapi stuff into the path
2020-02-10 21:17:49 +01:00
#[cfg(feature = "openapi")]
fn requires_auth() -> bool
{
false
}
initial commit
2019-09-26 17:24:40 +02:00
}
add request bodies to openapi
2019-10-01 00:49:13 +02:00
#[cfg(feature = "openapi")]
impl<Res : ResourceResult> crate::OpenapiType for Res
{
apply clippy suggestions
2019-10-13 23:36:10 +02:00
fn schema() -> OpenapiSchema
add request bodies to openapi
2019-10-01 00:49:13 +02:00
{
apply clippy suggestions
2019-10-13 23:36:10 +02:00
Self::schema()
add request bodies to openapi
2019-10-01 00:49:13 +02:00
}
}
attempt testing (doesn't work)
2019-09-27 15:35:02 +02:00
/// The default json returned on an 500 Internal Server Error.
initial commit
2019-09-26 17:24:40 +02:00
#[derive(Debug, Serialize)]
pub struct ResourceError
{
error : bool,
message : String
}
impl<T : ToString> From<T> for ResourceError
{
fn from(message : T) -> Self
{
Self {
error: true,
message: message.to_string()
}
}
}
Support File up/download
2019-10-20 14:49:53 +00:00
impl<R : ResponseBody, E : Error> ResourceResult for Result<R, E>
initial commit
2019-09-26 17:24:40 +02:00
{
Support File up/download
2019-10-20 14:49:53 +00:00
fn into_response(self) -> Result<Response, SerdeJsonError>
initial commit
2019-09-26 17:24:40 +02:00
{
attempt testing (doesn't work)
2019-09-27 15:35:02 +02:00
Ok(match self {
Support File up/download
2019-10-20 14:49:53 +00:00
Ok(r) => Response::json(StatusCode::OK, serde_json::to_string(&r)?),
attempt testing (doesn't work)
2019-09-27 15:35:02 +02:00
Err(e) => {
add errorlog feature
2020-02-10 21:41:44 +01:00
if cfg!(feature = "errorlog")
{
error!("The handler encountered an error: {}", e);
}
attempt testing (doesn't work)
2019-09-27 15:35:02 +02:00
let err : ResourceError = e.into();
Support File up/download
2019-10-20 14:49:53 +00:00
Response::json(StatusCode::INTERNAL_SERVER_ERROR, serde_json::to_string(&err)?)
attempt testing (doesn't work)
2019-09-27 15:35:02 +02:00
}
})
}
first valid openapi spec generated
2019-09-30 23:53:55 +02:00
Support File up/download
2019-10-20 14:49:53 +00:00
fn accepted_types() -> Option<Vec<Mime>>
{
Some(vec![APPLICATION_JSON])
}
first valid openapi spec generated
2019-09-30 23:53:55 +02:00
#[cfg(feature = "openapi")]
apply clippy suggestions
2019-10-13 23:36:10 +02:00
fn schema() -> OpenapiSchema
introduce openapitype
2019-09-30 20:58:15 +02:00
{
apply clippy suggestions
2019-10-13 23:36:10 +02:00
R::schema()
introduce openapitype
2019-09-30 20:58:15 +02:00
}
attempt testing (doesn't work)
2019-09-27 15:35:02 +02:00
}
documentation
2019-10-14 00:59:02 +02:00
/**
This can be returned from a resource when there is no cause of an error. For example:
```
# #[macro_use] extern crate gotham_restful_derive;
# use gotham::state::State;
weird proc macro issue
2019-10-14 02:37:50 +02:00
# use gotham_restful::*;
documentation
2019-10-14 00:59:02 +02:00
# use serde::{Deserialize, Serialize};
#
# #[derive(Resource)]
# struct MyResource;
#
#[derive(Deserialize, Serialize)]
# #[derive(OpenapiType)]
struct MyResponse {
message: String
}
#[rest_read_all(MyResource)]
fn read_all(_state: &mut State) -> Success<MyResponse> {
let res = MyResponse { message: "I'm always happy".to_string() };
res.into()
}
```
*/
attempt testing (doesn't work)
2019-09-27 15:35:02 +02:00
pub struct Success<T>(T);
impl<T> From<T> for Success<T>
{
fn from(t : T) -> Self
{
Self(t)
}
}
add AuthResult resource result type
2020-01-25 15:59:37 +01:00
impl<T : Clone> Clone for Success<T>
{
fn clone(&self) -> Self
{
Self(self.0.clone())
}
}
impl<T : Debug> Debug for Success<T>
{
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "Success({:?})", self.0)
}
}
Support File up/download
2019-10-20 14:49:53 +00:00
impl<T : ResponseBody> ResourceResult for Success<T>
attempt testing (doesn't work)
2019-09-27 15:35:02 +02:00
{
Support File up/download
2019-10-20 14:49:53 +00:00
fn into_response(self) -> Result<Response, SerdeJsonError>
attempt testing (doesn't work)
2019-09-27 15:35:02 +02:00
{
Support File up/download
2019-10-20 14:49:53 +00:00
Ok(Response::json(StatusCode::OK, serde_json::to_string(&self.0)?))
}
fn accepted_types() -> Option<Vec<Mime>>
{
Some(vec![APPLICATION_JSON])
initial commit
2019-09-26 17:24:40 +02:00
}
first valid openapi spec generated
2019-09-30 23:53:55 +02:00
#[cfg(feature = "openapi")]
apply clippy suggestions
2019-10-13 23:36:10 +02:00
fn schema() -> OpenapiSchema
introduce openapitype
2019-09-30 20:58:15 +02:00
{
apply clippy suggestions
2019-10-13 23:36:10 +02:00
T::schema()
introduce openapitype
2019-09-30 20:58:15 +02:00
}
initial commit
2019-09-26 17:24:40 +02:00
}
implement no-content response
2019-10-05 14:50:05 +02:00
add AuthResult resource result type
2020-01-25 15:59:37 +01:00
/**
This return type can be used to map another `ResourceResult` that can only be returned if the
client is authenticated. Otherwise, an empty _403 Forbidden_ response will be issued. Use can
look something like this (assuming the `auth` feature is enabled):
```
# #[macro_use] extern crate gotham_restful_derive;
# use gotham::state::State;
# use gotham_restful::*;
# use serde::Deserialize;
#
# #[derive(Resource)]
# struct MyResource;
#
# #[derive(Clone, Deserialize)]
# struct MyAuthData { exp : u64 }
#
#[rest_read_all(MyResource)]
fn read_all(auth : AuthStatus<MyAuthData>) -> AuthResult<NoContent> {
let auth_data = match auth {
AuthStatus::Authenticated(data) => data,
_ => return AuthErr
};
// do something
NoContent::default().into()
}
```
*/
pub enum AuthResult<T>
{
Ok(T),
AuthErr
}
add convenient methods for AuthResult
2020-02-08 13:44:46 +01:00
impl<T> AuthResult<T>
{
pub fn is_ok(&self) -> bool
{
match self {
Self::Ok(_) => true,
_ => false
}
}
pub fn unwrap(self) -> T
{
match self {
Self::Ok(data) => data,
_ => panic!()
}
}
}
add AuthResult resource result type
2020-01-25 15:59:37 +01:00
impl<T> From<T> for AuthResult<T>
{
fn from(t : T) -> Self
{
Self::Ok(t)
}
}
impl<T : Clone> Clone for AuthResult<T>
{
fn clone(&self) -> Self
{
match self {
Self::Ok(t) => Self::Ok(t.clone()),
Self::AuthErr => Self::AuthErr
}
}
}
impl<T : Debug> Debug for AuthResult<T>
{
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::Ok(t) => write!(f, "Ok({:?})", t),
Self::AuthErr => write!(f, "AuthErr")
}
}
}
impl<T : ResourceResult> ResourceResult for AuthResult<T>
{
fn into_response(self) -> Result<Response, SerdeJsonError>
{
match self
{
Self::Ok(res) => res.into_response(),
Self::AuthErr => Ok(Response::forbidden())
}
}
fn accepted_types() -> Option<Vec<Mime>>
{
T::accepted_types()
}
#[cfg(feature = "openapi")]
fn schema() -> OpenapiSchema
{
T::schema()
}
#[cfg(feature = "openapi")]
fn default_status() -> StatusCode
{
T::default_status()
}
move security auth openapi stuff into the path
2020-02-10 21:17:49 +01:00
#[cfg(feature = "openapi")]
fn requires_auth() -> bool
{
true
}
add AuthResult resource result type
2020-01-25 15:59:37 +01:00
}
documentation
2019-10-14 00:59:02 +02:00
/**
This is the return type of a resource that doesn't actually return something. It will result
in a _204 No Content_ answer by default. You don't need to use this type directly if using
the function attributes:
```
# #[macro_use] extern crate gotham_restful_derive;
# use gotham::state::State;
weird proc macro issue
2019-10-14 02:37:50 +02:00
# use gotham_restful::*;
documentation
2019-10-14 00:59:02 +02:00
#
# #[derive(Resource)]
# struct MyResource;
#
#[rest_read_all(MyResource)]
fn read_all(_state: &mut State) {
// do something
}
```
*/
apply clippy suggestions
2019-10-13 23:36:10 +02:00
#[derive(Default)]
implement no-content response
2019-10-05 14:50:05 +02:00
pub struct NoContent;
impl From<()> for NoContent
{
fn from(_ : ()) -> Self
{
Self {}
}
}
impl ResourceResult for NoContent
{
documentation
2019-10-14 00:59:02 +02:00
/// This will always be a _204 No Content_ together with an empty string.
Support File up/download
2019-10-20 14:49:53 +00:00
fn into_response(self) -> Result<Response, SerdeJsonError>
implement no-content response
2019-10-05 14:50:05 +02:00
{
Support File up/download
2019-10-20 14:49:53 +00:00
Ok(Response::no_content())
implement no-content response
2019-10-05 14:50:05 +02:00
}
documentation
2019-10-14 00:59:02 +02:00
/// Returns the schema of the `()` type.
implement no-content response
2019-10-05 14:50:05 +02:00
#[cfg(feature = "openapi")]
apply clippy suggestions
2019-10-13 23:36:10 +02:00
fn schema() -> OpenapiSchema
implement no-content response
2019-10-05 14:50:05 +02:00
{
apply clippy suggestions
2019-10-13 23:36:10 +02:00
<()>::schema()
implement no-content response
2019-10-05 14:50:05 +02:00
}
documentation
2019-10-14 00:59:02 +02:00
/// This will always be a _204 No Content_
implement no-content response
2019-10-05 14:50:05 +02:00
#[cfg(feature = "openapi")]
fn default_status() -> StatusCode
{
StatusCode::NO_CONTENT
}
}
allow Result<NoContent> responses
2019-10-05 16:06:08 +02:00
impl<E : Error> ResourceResult for Result<NoContent, E>
{
Support File up/download
2019-10-20 14:49:53 +00:00
fn into_response(self) -> Result<Response, SerdeJsonError>
allow Result<NoContent> responses
2019-10-05 16:06:08 +02:00
{
Support File up/download
2019-10-20 14:49:53 +00:00
match self {
Ok(nc) => nc.into_response(),
allow Result<NoContent> responses
2019-10-05 16:06:08 +02:00
Err(e) => {
let err : ResourceError = e.into();
Support File up/download
2019-10-20 14:49:53 +00:00
Ok(Response::json(StatusCode::INTERNAL_SERVER_ERROR, serde_json::to_string(&err)?))
allow Result<NoContent> responses
2019-10-05 16:06:08 +02:00
}
Support File up/download
2019-10-20 14:49:53 +00:00
}
allow Result<NoContent> responses
2019-10-05 16:06:08 +02:00
}
#[cfg(feature = "openapi")]
apply clippy suggestions
2019-10-13 23:36:10 +02:00
fn schema() -> OpenapiSchema
allow Result<NoContent> responses
2019-10-05 16:06:08 +02:00
{
add first tests
2019-10-14 02:17:25 +02:00
<NoContent as ResourceResult>::schema()
allow Result<NoContent> responses
2019-10-05 16:06:08 +02:00
}
#[cfg(feature = "openapi")]
fn default_status() -> StatusCode
{
add first tests
2019-10-14 02:17:25 +02:00
NoContent::default_status()
}
}
Support File up/download
2019-10-20 14:49:53 +00:00
pub struct Raw<T>
{
pub raw : T,
pub mime : Mime
}
impl<T> Raw<T>
{
pub fn new(raw : T, mime : Mime) -> Self
{
Self { raw, mime }
}
}
add AuthResult resource result type
2020-01-25 15:59:37 +01:00
impl<T : Clone> Clone for Raw<T>
{
fn clone(&self) -> Self
{
Self {
raw: self.raw.clone(),
mime: self.mime.clone()
}
}
}
impl<T : Debug> Debug for Raw<T>
{
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "Raw({:?}, {:?})", self.raw, self.mime)
}
}
Support File up/download
2019-10-20 14:49:53 +00:00
impl<T : Into<Body>> ResourceResult for Raw<T>
{
fn into_response(self) -> Result<Response, SerdeJsonError>
{
Ok(Response::new(StatusCode::OK, self.raw, Some(self.mime.clone())))
}
fn accepted_types() -> Option<Vec<Mime>>
{
Some(vec![STAR_STAR])
}
#[cfg(feature = "openapi")]
fn schema() -> OpenapiSchema
{
OpenapiSchema::new(SchemaKind::Type(Type::String(StringType {
format: VariantOrUnknownOrEmpty::Item(StringFormat::Binary),
openapiv3 upstream changed StringFormat: just use ..Default::default()
2020-01-17 21:37:41 +01:00
..Default::default()
Support File up/download
2019-10-20 14:49:53 +00:00
})))
}
}
impl<T, E : Error> ResourceResult for Result<Raw<T>, E>
where
Raw<T> : ResourceResult
{
fn into_response(self) -> Result<Response, SerdeJsonError>
{
match self {
Ok(raw) => raw.into_response(),
Err(e) => {
let err : ResourceError = e.into();
Ok(Response::json(StatusCode::INTERNAL_SERVER_ERROR, serde_json::to_string(&err)?))
}
}
}
fn accepted_types() -> Option<Vec<Mime>>
{
<Raw<T> as ResourceResult>::accepted_types()
}
#[cfg(feature = "openapi")]
fn schema() -> OpenapiSchema
{
<Raw<T> as ResourceResult>::schema()
}
}
add first tests
2019-10-14 02:17:25 +02:00
#[cfg(test)]
mod test
{
use super::*;
Support File up/download
2019-10-20 14:49:53 +00:00
use mime::TEXT_PLAIN;
add first tests
2019-10-14 02:17:25 +02:00
use thiserror::Error;
#[derive(Debug, Default, Deserialize, Serialize)]
#[cfg_attr(feature = "openapi", derive(OpenapiType))]
struct Msg
{
msg : String
}
#[derive(Debug, Default, Error)]
#[error("An Error")]
struct MsgError;
#[test]
fn resource_result_ok()
{
let ok : Result<Msg, MsgError> = Ok(Msg::default());
Support File up/download
2019-10-20 14:49:53 +00:00
let res = ok.into_response().expect("didn't expect error response");
assert_eq!(res.status, StatusCode::OK);
assert_eq!(res.mime, Some(APPLICATION_JSON));
assert_eq!(res.full_body(), r#"{"msg":""}"#.as_bytes());
add first tests
2019-10-14 02:17:25 +02:00
}
#[test]
fn resource_result_err()
{
let err : Result<Msg, MsgError> = Err(MsgError::default());
Support File up/download
2019-10-20 14:49:53 +00:00
let res = err.into_response().expect("didn't expect error response");
assert_eq!(res.status, StatusCode::INTERNAL_SERVER_ERROR);
assert_eq!(res.mime, Some(APPLICATION_JSON));
assert_eq!(res.full_body(), format!(r#"{{"error":true,"message":"{}"}}"#, MsgError::default()).as_bytes());
add first tests
2019-10-14 02:17:25 +02:00
}
#[test]
fn success_always_successfull()
{
let success : Success<Msg> = Msg::default().into();
Support File up/download
2019-10-20 14:49:53 +00:00
let res = success.into_response().expect("didn't expect error response");
assert_eq!(res.status, StatusCode::OK);
assert_eq!(res.mime, Some(APPLICATION_JSON));
assert_eq!(res.full_body(), r#"{"msg":""}"#.as_bytes());
add first tests
2019-10-14 02:17:25 +02:00
}
#[test]
Support File up/download
2019-10-20 14:49:53 +00:00
fn no_content_has_empty_response()
add first tests
2019-10-14 02:17:25 +02:00
{
let no_content = NoContent::default();
Support File up/download
2019-10-20 14:49:53 +00:00
let res = no_content.into_response().expect("didn't expect error response");
assert_eq!(res.status, StatusCode::NO_CONTENT);
assert_eq!(res.mime, None);
assert_eq!(res.full_body(), &[] as &[u8]);
add first tests
2019-10-14 02:17:25 +02:00
}
#[test]
fn no_content_result()
{
Support File up/download
2019-10-20 14:49:53 +00:00
let no_content : Result<NoContent, MsgError> = Ok(NoContent::default());
let res = no_content.into_response().expect("didn't expect error response");
assert_eq!(res.status, StatusCode::NO_CONTENT);
assert_eq!(res.mime, None);
assert_eq!(res.full_body(), &[] as &[u8]);
}
#[test]
fn raw_response()
{
let msg = "Test";
let raw = Raw::new(msg, TEXT_PLAIN);
let res = raw.into_response().expect("didn't expect error response");
assert_eq!(res.status, StatusCode::OK);
assert_eq!(res.mime, Some(TEXT_PLAIN));
assert_eq!(res.full_body(), msg.as_bytes());
allow Result<NoContent> responses
2019-10-05 16:06:08 +02:00
}
}
Reference in a new issue Copy permalink