1
0
mirror of https://github.com/fafhrd91/actix-web synced 2024-11-28 01:52:57 +01:00
actix-web/src/responder.rs

445 lines
13 KiB
Rust
Raw Normal View History

2019-12-05 18:35:43 +01:00
use std::convert::TryFrom;
2019-11-20 18:33:22 +01:00
2019-03-06 04:41:50 +01:00
use actix_http::error::InternalError;
use actix_http::http::{
2019-12-05 18:35:43 +01:00
header::IntoHeaderValue, Error as HttpError, HeaderMap, HeaderName, StatusCode,
};
use actix_http::ResponseBuilder;
2019-03-02 07:51:32 +01:00
use bytes::{Bytes, BytesMut};
use crate::{Error, HttpRequest, HttpResponse};
2019-03-02 07:51:32 +01:00
2019-03-02 18:05:07 +01:00
/// Trait implemented by types that can be converted to a http response.
2019-03-02 07:51:32 +01:00
///
/// Types that implement this trait can be used as the return type of a handler.
pub trait Responder {
/// Convert self to `HttpResponse`.
fn respond_to(self, req: &HttpRequest) -> HttpResponse;
2019-04-24 22:21:42 +02:00
/// Override a status code for a Responder.
///
/// ```rust
/// use actix_web::{HttpRequest, Responder, http::StatusCode};
///
/// fn index(req: HttpRequest) -> impl Responder {
/// "Welcome!".with_status(StatusCode::OK)
/// }
/// # fn main() {}
/// ```
fn with_status(self, status: StatusCode) -> CustomResponder<Self>
where
Self: Sized,
{
CustomResponder::new(self).with_status(status)
}
2019-04-24 22:21:42 +02:00
/// Add header to the Responder's response.
///
/// ```rust
/// use actix_web::{web, HttpRequest, Responder};
/// use serde::Serialize;
///
/// #[derive(Serialize)]
/// struct MyObj {
/// name: String,
/// }
///
/// fn index(req: HttpRequest) -> impl Responder {
/// web::Json(
/// MyObj{name: "Name".to_string()}
/// )
/// .with_header("x-version", "1.2.3")
/// }
/// # fn main() {}
/// ```
fn with_header<K, V>(self, key: K, value: V) -> CustomResponder<Self>
where
Self: Sized,
2019-12-05 18:35:43 +01:00
HeaderName: TryFrom<K>,
<HeaderName as TryFrom<K>>::Error: Into<HttpError>,
V: IntoHeaderValue,
{
CustomResponder::new(self).with_header(key, value)
}
2019-03-02 07:51:32 +01:00
}
impl Responder for HttpResponse {
2019-03-02 07:51:32 +01:00
#[inline]
fn respond_to(self, _: &HttpRequest) -> HttpResponse {
self
2019-03-02 07:51:32 +01:00
}
}
impl<T: Responder> Responder for Option<T> {
fn respond_to(self, req: &HttpRequest) -> HttpResponse {
2019-03-02 07:51:32 +01:00
match self {
Some(t) => t.respond_to(req),
None => HttpResponse::build(StatusCode::NOT_FOUND).finish(),
2019-03-02 07:51:32 +01:00
}
}
}
impl<T, E> Responder for Result<T, E>
where
T: Responder,
E: Into<Error>,
{
fn respond_to(self, req: &HttpRequest) -> HttpResponse {
2019-03-02 07:51:32 +01:00
match self {
Ok(val) => val.respond_to(req),
Err(e) => HttpResponse::from_error(e.into()),
2019-03-02 07:51:32 +01:00
}
}
}
impl Responder for ResponseBuilder {
#[inline]
fn respond_to(mut self, _: &HttpRequest) -> HttpResponse {
self.finish()
2019-03-02 07:51:32 +01:00
}
}
impl<T: Responder> Responder for (T, StatusCode) {
fn respond_to(self, req: &HttpRequest) -> HttpResponse {
let mut res = self.0.respond_to(req);
*res.status_mut() = self.1;
res
}
}
2019-03-02 07:51:32 +01:00
impl Responder for &'static str {
fn respond_to(self, _: &HttpRequest) -> HttpResponse {
HttpResponse::Ok()
.content_type(mime::TEXT_PLAIN_UTF_8)
.body(self)
2019-03-02 07:51:32 +01:00
}
}
impl Responder for &'static [u8] {
fn respond_to(self, _: &HttpRequest) -> HttpResponse {
HttpResponse::Ok()
.content_type(mime::APPLICATION_OCTET_STREAM)
.body(self)
2019-03-02 07:51:32 +01:00
}
}
impl Responder for String {
fn respond_to(self, _: &HttpRequest) -> HttpResponse {
HttpResponse::Ok()
.content_type(mime::TEXT_PLAIN_UTF_8)
.body(self)
2019-03-02 07:51:32 +01:00
}
}
impl<'a> Responder for &'a String {
fn respond_to(self, _: &HttpRequest) -> HttpResponse {
HttpResponse::Ok()
.content_type(mime::TEXT_PLAIN_UTF_8)
.body(self)
2019-03-02 07:51:32 +01:00
}
}
impl Responder for Bytes {
fn respond_to(self, _: &HttpRequest) -> HttpResponse {
HttpResponse::Ok()
.content_type(mime::APPLICATION_OCTET_STREAM)
.body(self)
2019-03-02 07:51:32 +01:00
}
}
impl Responder for BytesMut {
fn respond_to(self, _: &HttpRequest) -> HttpResponse {
HttpResponse::Ok()
.content_type(mime::APPLICATION_OCTET_STREAM)
.body(self)
2019-03-02 07:51:32 +01:00
}
}
/// Allows to override status code and headers for a responder.
pub struct CustomResponder<T> {
responder: T,
status: Option<StatusCode>,
headers: Option<HeaderMap>,
error: Option<HttpError>,
}
impl<T: Responder> CustomResponder<T> {
fn new(responder: T) -> Self {
CustomResponder {
responder,
status: None,
headers: None,
error: None,
}
}
2019-04-24 22:21:42 +02:00
/// Override a status code for the Responder's response.
///
/// ```rust
/// use actix_web::{HttpRequest, Responder, http::StatusCode};
///
/// fn index(req: HttpRequest) -> impl Responder {
/// "Welcome!".with_status(StatusCode::OK)
/// }
/// # fn main() {}
/// ```
pub fn with_status(mut self, status: StatusCode) -> Self {
self.status = Some(status);
self
}
2019-04-24 22:21:42 +02:00
/// Add header to the Responder's response.
///
/// ```rust
/// use actix_web::{web, HttpRequest, Responder};
/// use serde::Serialize;
///
/// #[derive(Serialize)]
/// struct MyObj {
/// name: String,
/// }
///
/// fn index(req: HttpRequest) -> impl Responder {
/// web::Json(
/// MyObj{name: "Name".to_string()}
/// )
/// .with_header("x-version", "1.2.3")
/// }
/// # fn main() {}
/// ```
pub fn with_header<K, V>(mut self, key: K, value: V) -> Self
where
2019-12-05 18:35:43 +01:00
HeaderName: TryFrom<K>,
<HeaderName as TryFrom<K>>::Error: Into<HttpError>,
V: IntoHeaderValue,
{
if self.headers.is_none() {
self.headers = Some(HeaderMap::new());
}
match HeaderName::try_from(key) {
Ok(key) => match value.try_into() {
Ok(value) => {
self.headers.as_mut().unwrap().append(key, value);
}
Err(e) => self.error = Some(e.into()),
},
Err(e) => self.error = Some(e.into()),
};
self
}
}
impl<T: Responder> Responder for CustomResponder<T> {
fn respond_to(self, req: &HttpRequest) -> HttpResponse {
let mut res = self.responder.respond_to(req);
if let Some(status) = self.status {
*res.status_mut() = status;
}
if let Some(ref headers) = self.headers {
for (k, v) in headers {
res.headers_mut().insert(k.clone(), v.clone());
}
}
res
}
}
2019-03-06 04:41:50 +01:00
impl<T> Responder for InternalError<T>
where
T: std::fmt::Debug + std::fmt::Display + 'static,
{
fn respond_to(self, _: &HttpRequest) -> HttpResponse {
HttpResponse::from_error(self.into())
2019-03-02 07:51:32 +01:00
}
}
#[cfg(test)]
2019-03-17 17:52:41 +01:00
pub(crate) mod tests {
use actix_service::Service;
2019-03-13 06:57:09 +01:00
use bytes::{Bytes, BytesMut};
2019-03-13 06:57:09 +01:00
use super::*;
2019-03-08 00:51:24 +01:00
use crate::dev::{Body, ResponseBody};
2019-03-13 06:57:09 +01:00
use crate::http::{header::CONTENT_TYPE, HeaderValue, StatusCode};
2019-11-26 06:25:50 +01:00
use crate::test::{init_service, TestRequest};
use crate::{error, web, App};
2019-11-26 06:25:50 +01:00
#[actix_rt::test]
async fn test_option_responder() {
let mut srv = init_service(
App::new()
.service(
web::resource("/none").to(|| async { Option::<&'static str>::None }),
)
.service(web::resource("/some").to(|| async { Some("some") })),
)
.await;
let req = TestRequest::with_uri("/none").to_request();
let resp = srv.call(req).await.unwrap();
assert_eq!(resp.status(), StatusCode::NOT_FOUND);
let req = TestRequest::with_uri("/some").to_request();
let resp = srv.call(req).await.unwrap();
assert_eq!(resp.status(), StatusCode::OK);
match resp.response().body() {
ResponseBody::Body(Body::Bytes(ref b)) => {
let bytes = b.clone();
2019-11-26 06:25:50 +01:00
assert_eq!(bytes, Bytes::from_static(b"some"));
}
2019-11-26 06:25:50 +01:00
_ => panic!(),
}
}
2019-03-13 06:57:09 +01:00
2019-03-17 17:52:41 +01:00
pub(crate) trait BodyTest {
2019-03-13 06:57:09 +01:00
fn bin_ref(&self) -> &[u8];
fn body(&self) -> &Body;
}
impl BodyTest for ResponseBody<Body> {
fn bin_ref(&self) -> &[u8] {
match self {
ResponseBody::Body(ref b) => match b {
Body::Bytes(ref bin) => &bin,
_ => panic!(),
},
ResponseBody::Other(ref b) => match b {
Body::Bytes(ref bin) => &bin,
_ => panic!(),
},
}
}
fn body(&self) -> &Body {
match self {
ResponseBody::Body(ref b) => b,
ResponseBody::Other(ref b) => b,
}
}
}
2019-11-26 06:25:50 +01:00
#[actix_rt::test]
async fn test_responder() {
let req = TestRequest::default().to_http_request();
let resp = "test".respond_to(&req);
2019-11-26 06:25:50 +01:00
assert_eq!(resp.status(), StatusCode::OK);
assert_eq!(resp.body().bin_ref(), b"test");
assert_eq!(
resp.headers().get(CONTENT_TYPE).unwrap(),
HeaderValue::from_static("text/plain; charset=utf-8")
);
let resp = b"test".respond_to(&req);
2019-11-26 06:25:50 +01:00
assert_eq!(resp.status(), StatusCode::OK);
assert_eq!(resp.body().bin_ref(), b"test");
assert_eq!(
resp.headers().get(CONTENT_TYPE).unwrap(),
HeaderValue::from_static("application/octet-stream")
);
let resp = "test".to_string().respond_to(&req);
2019-11-26 06:25:50 +01:00
assert_eq!(resp.status(), StatusCode::OK);
assert_eq!(resp.body().bin_ref(), b"test");
assert_eq!(
resp.headers().get(CONTENT_TYPE).unwrap(),
HeaderValue::from_static("text/plain; charset=utf-8")
);
let resp = (&"test".to_string()).respond_to(&req);
2019-11-26 06:25:50 +01:00
assert_eq!(resp.status(), StatusCode::OK);
assert_eq!(resp.body().bin_ref(), b"test");
assert_eq!(
resp.headers().get(CONTENT_TYPE).unwrap(),
HeaderValue::from_static("text/plain; charset=utf-8")
);
let resp = Bytes::from_static(b"test").respond_to(&req);
2019-11-26 06:25:50 +01:00
assert_eq!(resp.status(), StatusCode::OK);
assert_eq!(resp.body().bin_ref(), b"test");
assert_eq!(
resp.headers().get(CONTENT_TYPE).unwrap(),
HeaderValue::from_static("application/octet-stream")
);
let resp = BytesMut::from(b"test".as_ref()).respond_to(&req);
2019-11-26 06:25:50 +01:00
assert_eq!(resp.status(), StatusCode::OK);
assert_eq!(resp.body().bin_ref(), b"test");
assert_eq!(
resp.headers().get(CONTENT_TYPE).unwrap(),
HeaderValue::from_static("application/octet-stream")
);
// InternalError
let resp =
error::InternalError::new("err", StatusCode::BAD_REQUEST).respond_to(&req);
2019-11-26 06:25:50 +01:00
assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
2019-03-13 06:57:09 +01:00
}
2019-11-26 06:25:50 +01:00
#[actix_rt::test]
async fn test_result_responder() {
let req = TestRequest::default().to_http_request();
2019-11-20 18:33:22 +01:00
2019-11-26 06:25:50 +01:00
// Result<I, E>
let resp = Ok::<_, Error>("test".to_string()).respond_to(&req);
2019-11-26 06:25:50 +01:00
assert_eq!(resp.status(), StatusCode::OK);
assert_eq!(resp.body().bin_ref(), b"test");
assert_eq!(
resp.headers().get(CONTENT_TYPE).unwrap(),
HeaderValue::from_static("text/plain; charset=utf-8")
);
let res =
Err::<String, _>(error::InternalError::new("err", StatusCode::BAD_REQUEST))
.respond_to(&req);
assert_eq!(res.status(), StatusCode::BAD_REQUEST);
}
2019-11-26 06:25:50 +01:00
#[actix_rt::test]
async fn test_custom_responder() {
let req = TestRequest::default().to_http_request();
let res = "test"
.to_string()
.with_status(StatusCode::BAD_REQUEST)
.respond_to(&req);
2019-11-26 06:25:50 +01:00
assert_eq!(res.status(), StatusCode::BAD_REQUEST);
assert_eq!(res.body().bin_ref(), b"test");
let res = "test"
.to_string()
.with_header("content-type", "json")
.respond_to(&req);
2019-11-26 06:25:50 +01:00
assert_eq!(res.status(), StatusCode::OK);
assert_eq!(res.body().bin_ref(), b"test");
assert_eq!(
res.headers().get(CONTENT_TYPE).unwrap(),
HeaderValue::from_static("json")
);
}
2019-11-26 06:25:50 +01:00
#[actix_rt::test]
async fn test_tuple_responder_with_status_code() {
let req = TestRequest::default().to_http_request();
let res = ("test".to_string(), StatusCode::BAD_REQUEST).respond_to(&req);
2019-11-26 06:25:50 +01:00
assert_eq!(res.status(), StatusCode::BAD_REQUEST);
assert_eq!(res.body().bin_ref(), b"test");
let req = TestRequest::default().to_http_request();
let res = ("test".to_string(), StatusCode::OK)
.with_header("content-type", "json")
.respond_to(&req);
2019-11-26 06:25:50 +01:00
assert_eq!(res.status(), StatusCode::OK);
assert_eq!(res.body().bin_ref(), b"test");
assert_eq!(
res.headers().get(CONTENT_TYPE).unwrap(),
HeaderValue::from_static("json")
);
}
}