mirror of
https://github.com/fafhrd91/actix-web
synced 2025-03-28 17:48:39 +01:00
636 lines
22 KiB
Rust
636 lines
22 KiB
Rust
//! For middleware documentation, see [`ErrorHandlers`].
|
|
|
|
use std::{
|
|
future::Future,
|
|
pin::Pin,
|
|
rc::Rc,
|
|
task::{Context, Poll},
|
|
};
|
|
|
|
use actix_service::{Service, Transform};
|
|
use ahash::AHashMap;
|
|
use futures_core::{future::LocalBoxFuture, ready};
|
|
use pin_project_lite::pin_project;
|
|
|
|
use crate::{
|
|
body::EitherBody,
|
|
dev::{ServiceRequest, ServiceResponse},
|
|
http::StatusCode,
|
|
Error, Result,
|
|
};
|
|
|
|
/// Return type for [`ErrorHandlers`] custom handlers.
|
|
pub enum ErrorHandlerResponse<B> {
|
|
/// Immediate HTTP response.
|
|
Response(ServiceResponse<EitherBody<B>>),
|
|
|
|
/// A future that resolves to an HTTP response.
|
|
Future(LocalBoxFuture<'static, Result<ServiceResponse<EitherBody<B>>, Error>>),
|
|
}
|
|
|
|
type ErrorHandler<B> = dyn Fn(ServiceResponse<B>) -> Result<ErrorHandlerResponse<B>>;
|
|
|
|
type DefaultHandler<B> = Option<Rc<ErrorHandler<B>>>;
|
|
|
|
/// Middleware for registering custom status code based error handlers.
|
|
///
|
|
/// Register handlers with the [`ErrorHandlers::handler()`] method to register a custom error handler
|
|
/// for a given status code. Handlers can modify existing responses or create completely new ones.
|
|
///
|
|
/// To register a default handler, use the [`ErrorHandlers::default_handler()`] method. This
|
|
/// handler will be used only if a response has an error status code (400-599) that isn't covered by
|
|
/// a more specific handler (set with the [`handler()`][ErrorHandlers::handler] method). See examples
|
|
/// below.
|
|
///
|
|
/// To register a default for only client errors (400-499) or only server errors (500-599), use the
|
|
/// [`ErrorHandlers::default_handler_client()`] and [`ErrorHandlers::default_handler_server()`]
|
|
/// methods, respectively.
|
|
///
|
|
/// Any response with a status code that isn't covered by a specific handler or a default handler
|
|
/// will pass by unchanged by this middleware.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// Adding a header:
|
|
///
|
|
/// ```
|
|
/// use actix_web::{
|
|
/// dev::ServiceResponse,
|
|
/// http::{header, StatusCode},
|
|
/// middleware::{ErrorHandlerResponse, ErrorHandlers},
|
|
/// web, App, HttpResponse, Result,
|
|
/// };
|
|
///
|
|
/// fn add_error_header<B>(mut res: ServiceResponse<B>) -> Result<ErrorHandlerResponse<B>> {
|
|
/// res.response_mut().headers_mut().insert(
|
|
/// header::CONTENT_TYPE,
|
|
/// header::HeaderValue::from_static("Error"),
|
|
/// );
|
|
///
|
|
/// // body is unchanged, map to "left" slot
|
|
/// Ok(ErrorHandlerResponse::Response(res.map_into_left_body()))
|
|
/// }
|
|
///
|
|
/// let app = App::new()
|
|
/// .wrap(ErrorHandlers::new().handler(StatusCode::INTERNAL_SERVER_ERROR, add_error_header))
|
|
/// .service(web::resource("/").route(web::get().to(HttpResponse::InternalServerError)));
|
|
/// ```
|
|
///
|
|
/// Modifying response body:
|
|
///
|
|
/// ```
|
|
/// use actix_web::{
|
|
/// dev::ServiceResponse,
|
|
/// http::{header, StatusCode},
|
|
/// middleware::{ErrorHandlerResponse, ErrorHandlers},
|
|
/// web, App, HttpResponse, Result,
|
|
/// };
|
|
///
|
|
/// fn add_error_body<B>(res: ServiceResponse<B>) -> Result<ErrorHandlerResponse<B>> {
|
|
/// // split service response into request and response components
|
|
/// let (req, res) = res.into_parts();
|
|
///
|
|
/// // set body of response to modified body
|
|
/// let res = res.set_body("An error occurred.");
|
|
///
|
|
/// // modified bodies need to be boxed and placed in the "right" slot
|
|
/// let res = ServiceResponse::new(req, res)
|
|
/// .map_into_boxed_body()
|
|
/// .map_into_right_body();
|
|
///
|
|
/// Ok(ErrorHandlerResponse::Response(res))
|
|
/// }
|
|
///
|
|
/// let app = App::new()
|
|
/// .wrap(ErrorHandlers::new().handler(StatusCode::INTERNAL_SERVER_ERROR, add_error_body))
|
|
/// .service(web::resource("/").route(web::get().to(HttpResponse::InternalServerError)));
|
|
/// ```
|
|
///
|
|
/// Registering default handler:
|
|
///
|
|
/// ```
|
|
/// # use actix_web::{
|
|
/// # dev::ServiceResponse,
|
|
/// # http::{header, StatusCode},
|
|
/// # middleware::{ErrorHandlerResponse, ErrorHandlers},
|
|
/// # web, App, HttpResponse, Result,
|
|
/// # };
|
|
/// fn add_error_header<B>(mut res: ServiceResponse<B>) -> Result<ErrorHandlerResponse<B>> {
|
|
/// res.response_mut().headers_mut().insert(
|
|
/// header::CONTENT_TYPE,
|
|
/// header::HeaderValue::from_static("Error"),
|
|
/// );
|
|
///
|
|
/// // body is unchanged, map to "left" slot
|
|
/// Ok(ErrorHandlerResponse::Response(res.map_into_left_body()))
|
|
/// }
|
|
///
|
|
/// fn handle_bad_request<B>(mut res: ServiceResponse<B>) -> Result<ErrorHandlerResponse<B>> {
|
|
/// res.response_mut().headers_mut().insert(
|
|
/// header::CONTENT_TYPE,
|
|
/// header::HeaderValue::from_static("Bad Request Error"),
|
|
/// );
|
|
///
|
|
/// // body is unchanged, map to "left" slot
|
|
/// Ok(ErrorHandlerResponse::Response(res.map_into_left_body()))
|
|
/// }
|
|
///
|
|
/// // Bad Request errors will hit `handle_bad_request()`, while all other errors will hit
|
|
/// // `add_error_header()`. The order in which the methods are called is not meaningful.
|
|
/// let app = App::new()
|
|
/// .wrap(
|
|
/// ErrorHandlers::new()
|
|
/// .default_handler(add_error_header)
|
|
/// .handler(StatusCode::BAD_REQUEST, handle_bad_request)
|
|
/// )
|
|
/// .service(web::resource("/").route(web::get().to(HttpResponse::InternalServerError)));
|
|
/// ```
|
|
///
|
|
/// You can set default handlers for all client (4xx) or all server (5xx) errors:
|
|
///
|
|
/// ```
|
|
/// # use actix_web::{
|
|
/// # dev::ServiceResponse,
|
|
/// # http::{header, StatusCode},
|
|
/// # middleware::{ErrorHandlerResponse, ErrorHandlers},
|
|
/// # web, App, HttpResponse, Result,
|
|
/// # };
|
|
/// # fn add_error_header<B>(mut res: ServiceResponse<B>) -> Result<ErrorHandlerResponse<B>> {
|
|
/// # res.response_mut().headers_mut().insert(
|
|
/// # header::CONTENT_TYPE,
|
|
/// # header::HeaderValue::from_static("Error"),
|
|
/// # );
|
|
/// # Ok(ErrorHandlerResponse::Response(res.map_into_left_body()))
|
|
/// # }
|
|
/// # fn handle_bad_request<B>(mut res: ServiceResponse<B>) -> Result<ErrorHandlerResponse<B>> {
|
|
/// # res.response_mut().headers_mut().insert(
|
|
/// # header::CONTENT_TYPE,
|
|
/// # header::HeaderValue::from_static("Bad Request Error"),
|
|
/// # );
|
|
/// # Ok(ErrorHandlerResponse::Response(res.map_into_left_body()))
|
|
/// # }
|
|
/// // Bad request errors will hit `handle_bad_request()`, other client errors will hit
|
|
/// // `add_error_header()`, and server errors will pass through unchanged
|
|
/// let app = App::new()
|
|
/// .wrap(
|
|
/// ErrorHandlers::new()
|
|
/// .default_handler_client(add_error_header) // or .default_handler_server
|
|
/// .handler(StatusCode::BAD_REQUEST, handle_bad_request)
|
|
/// )
|
|
/// .service(web::resource("/").route(web::get().to(HttpResponse::InternalServerError)));
|
|
/// ```
|
|
pub struct ErrorHandlers<B> {
|
|
default_client: DefaultHandler<B>,
|
|
default_server: DefaultHandler<B>,
|
|
handlers: Handlers<B>,
|
|
}
|
|
|
|
type Handlers<B> = Rc<AHashMap<StatusCode, Box<ErrorHandler<B>>>>;
|
|
|
|
impl<B> Default for ErrorHandlers<B> {
|
|
fn default() -> Self {
|
|
ErrorHandlers {
|
|
default_client: Default::default(),
|
|
default_server: Default::default(),
|
|
handlers: Default::default(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<B> ErrorHandlers<B> {
|
|
/// Construct new `ErrorHandlers` instance.
|
|
pub fn new() -> Self {
|
|
ErrorHandlers::default()
|
|
}
|
|
|
|
/// Register error handler for specified status code.
|
|
pub fn handler<F>(mut self, status: StatusCode, handler: F) -> Self
|
|
where
|
|
F: Fn(ServiceResponse<B>) -> Result<ErrorHandlerResponse<B>> + 'static,
|
|
{
|
|
Rc::get_mut(&mut self.handlers)
|
|
.unwrap()
|
|
.insert(status, Box::new(handler));
|
|
self
|
|
}
|
|
|
|
/// Register a default error handler.
|
|
///
|
|
/// Any request with a status code that hasn't been given a specific other handler (by calling
|
|
/// [`.handler()`][ErrorHandlers::handler]) will fall back on this.
|
|
///
|
|
/// Note that this will overwrite any default handlers previously set by calling
|
|
/// [`.default_handler_client()`][ErrorHandlers::default_handler_client] or
|
|
/// [`.default_handler_server()`][ErrorHandlers::default_handler_server], but not any set by
|
|
/// calling [`.handler()`][ErrorHandlers::handler].
|
|
pub fn default_handler<F>(self, handler: F) -> Self
|
|
where
|
|
F: Fn(ServiceResponse<B>) -> Result<ErrorHandlerResponse<B>> + 'static,
|
|
{
|
|
let handler = Rc::new(handler);
|
|
Self {
|
|
default_server: Some(handler.clone()),
|
|
default_client: Some(handler),
|
|
..self
|
|
}
|
|
}
|
|
|
|
/// Register a handler on which to fall back for client error status codes (400-499).
|
|
pub fn default_handler_client<F>(self, handler: F) -> Self
|
|
where
|
|
F: Fn(ServiceResponse<B>) -> Result<ErrorHandlerResponse<B>> + 'static,
|
|
{
|
|
Self {
|
|
default_client: Some(Rc::new(handler)),
|
|
..self
|
|
}
|
|
}
|
|
|
|
/// Register a handler on which to fall back for server error status codes (500-599).
|
|
pub fn default_handler_server<F>(self, handler: F) -> Self
|
|
where
|
|
F: Fn(ServiceResponse<B>) -> Result<ErrorHandlerResponse<B>> + 'static,
|
|
{
|
|
Self {
|
|
default_server: Some(Rc::new(handler)),
|
|
..self
|
|
}
|
|
}
|
|
|
|
/// Selects the most appropriate handler for the given status code.
|
|
///
|
|
/// If the `handlers` map has an entry for that status code, that handler is returned.
|
|
/// Otherwise, fall back on the appropriate default handler.
|
|
fn get_handler<'a>(
|
|
status: &StatusCode,
|
|
default_client: Option<&'a ErrorHandler<B>>,
|
|
default_server: Option<&'a ErrorHandler<B>>,
|
|
handlers: &'a Handlers<B>,
|
|
) -> Option<&'a ErrorHandler<B>> {
|
|
handlers
|
|
.get(status)
|
|
.map(|h| h.as_ref())
|
|
.or_else(|| status.is_client_error().then_some(default_client).flatten())
|
|
.or_else(|| status.is_server_error().then_some(default_server).flatten())
|
|
}
|
|
}
|
|
|
|
impl<S, B> Transform<S, ServiceRequest> for ErrorHandlers<B>
|
|
where
|
|
S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error> + 'static,
|
|
S::Future: 'static,
|
|
B: 'static,
|
|
{
|
|
type Response = ServiceResponse<EitherBody<B>>;
|
|
type Error = Error;
|
|
type Transform = ErrorHandlersMiddleware<S, B>;
|
|
type InitError = ();
|
|
type Future = LocalBoxFuture<'static, Result<Self::Transform, Self::InitError>>;
|
|
|
|
fn new_transform(&self, service: S) -> Self::Future {
|
|
let handlers = self.handlers.clone();
|
|
let default_client = self.default_client.clone();
|
|
let default_server = self.default_server.clone();
|
|
Box::pin(async move {
|
|
Ok(ErrorHandlersMiddleware {
|
|
service,
|
|
default_client,
|
|
default_server,
|
|
handlers,
|
|
})
|
|
})
|
|
}
|
|
}
|
|
|
|
#[doc(hidden)]
|
|
pub struct ErrorHandlersMiddleware<S, B> {
|
|
service: S,
|
|
default_client: DefaultHandler<B>,
|
|
default_server: DefaultHandler<B>,
|
|
handlers: Handlers<B>,
|
|
}
|
|
|
|
impl<S, B> Service<ServiceRequest> for ErrorHandlersMiddleware<S, B>
|
|
where
|
|
S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
|
|
S::Future: 'static,
|
|
B: 'static,
|
|
{
|
|
type Response = ServiceResponse<EitherBody<B>>;
|
|
type Error = Error;
|
|
type Future = ErrorHandlersFuture<S::Future, B>;
|
|
|
|
actix_service::forward_ready!(service);
|
|
|
|
fn call(&self, req: ServiceRequest) -> Self::Future {
|
|
let handlers = self.handlers.clone();
|
|
let default_client = self.default_client.clone();
|
|
let default_server = self.default_server.clone();
|
|
let fut = self.service.call(req);
|
|
ErrorHandlersFuture::ServiceFuture {
|
|
fut,
|
|
default_client,
|
|
default_server,
|
|
handlers,
|
|
}
|
|
}
|
|
}
|
|
|
|
pin_project! {
|
|
#[project = ErrorHandlersProj]
|
|
pub enum ErrorHandlersFuture<Fut, B>
|
|
where
|
|
Fut: Future,
|
|
{
|
|
ServiceFuture {
|
|
#[pin]
|
|
fut: Fut,
|
|
default_client: DefaultHandler<B>,
|
|
default_server: DefaultHandler<B>,
|
|
handlers: Handlers<B>,
|
|
},
|
|
ErrorHandlerFuture {
|
|
fut: LocalBoxFuture<'static, Result<ServiceResponse<EitherBody<B>>, Error>>,
|
|
},
|
|
}
|
|
}
|
|
|
|
impl<Fut, B> Future for ErrorHandlersFuture<Fut, B>
|
|
where
|
|
Fut: Future<Output = Result<ServiceResponse<B>, Error>>,
|
|
{
|
|
type Output = Result<ServiceResponse<EitherBody<B>>, Error>;
|
|
|
|
fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
|
|
match self.as_mut().project() {
|
|
ErrorHandlersProj::ServiceFuture {
|
|
fut,
|
|
default_client,
|
|
default_server,
|
|
handlers,
|
|
} => {
|
|
let res = ready!(fut.poll(cx))?;
|
|
let status = res.status();
|
|
|
|
let handler = ErrorHandlers::get_handler(
|
|
&status,
|
|
default_client.as_mut().map(|f| Rc::as_ref(f)),
|
|
default_server.as_mut().map(|f| Rc::as_ref(f)),
|
|
handlers,
|
|
);
|
|
match handler {
|
|
Some(handler) => match handler(res)? {
|
|
ErrorHandlerResponse::Response(res) => Poll::Ready(Ok(res)),
|
|
ErrorHandlerResponse::Future(fut) => {
|
|
self.as_mut()
|
|
.set(ErrorHandlersFuture::ErrorHandlerFuture { fut });
|
|
|
|
self.poll(cx)
|
|
}
|
|
},
|
|
None => Poll::Ready(Ok(res.map_into_left_body())),
|
|
}
|
|
}
|
|
|
|
ErrorHandlersProj::ErrorHandlerFuture { fut } => fut.as_mut().poll(cx),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use actix_service::IntoService;
|
|
use actix_utils::future::ok;
|
|
use bytes::Bytes;
|
|
use futures_util::FutureExt as _;
|
|
|
|
use super::*;
|
|
use crate::{
|
|
body,
|
|
http::{
|
|
header::{HeaderValue, CONTENT_TYPE},
|
|
StatusCode,
|
|
},
|
|
test::{self, TestRequest},
|
|
};
|
|
|
|
#[actix_rt::test]
|
|
async fn add_header_error_handler() {
|
|
#[allow(clippy::unnecessary_wraps)]
|
|
fn error_handler<B>(mut res: ServiceResponse<B>) -> Result<ErrorHandlerResponse<B>> {
|
|
res.response_mut()
|
|
.headers_mut()
|
|
.insert(CONTENT_TYPE, HeaderValue::from_static("0001"));
|
|
|
|
Ok(ErrorHandlerResponse::Response(res.map_into_left_body()))
|
|
}
|
|
|
|
let srv = test::status_service(StatusCode::INTERNAL_SERVER_ERROR);
|
|
|
|
let mw = ErrorHandlers::new()
|
|
.handler(StatusCode::INTERNAL_SERVER_ERROR, error_handler)
|
|
.new_transform(srv.into_service())
|
|
.await
|
|
.unwrap();
|
|
|
|
let resp = test::call_service(&mw, TestRequest::default().to_srv_request()).await;
|
|
assert_eq!(resp.headers().get(CONTENT_TYPE).unwrap(), "0001");
|
|
}
|
|
|
|
#[actix_rt::test]
|
|
async fn add_header_error_handler_async() {
|
|
#[allow(clippy::unnecessary_wraps)]
|
|
fn error_handler<B: 'static>(
|
|
mut res: ServiceResponse<B>,
|
|
) -> Result<ErrorHandlerResponse<B>> {
|
|
res.response_mut()
|
|
.headers_mut()
|
|
.insert(CONTENT_TYPE, HeaderValue::from_static("0001"));
|
|
|
|
Ok(ErrorHandlerResponse::Future(
|
|
ok(res.map_into_left_body()).boxed_local(),
|
|
))
|
|
}
|
|
|
|
let srv = test::status_service(StatusCode::INTERNAL_SERVER_ERROR);
|
|
|
|
let mw = ErrorHandlers::new()
|
|
.handler(StatusCode::INTERNAL_SERVER_ERROR, error_handler)
|
|
.new_transform(srv.into_service())
|
|
.await
|
|
.unwrap();
|
|
|
|
let resp = test::call_service(&mw, TestRequest::default().to_srv_request()).await;
|
|
assert_eq!(resp.headers().get(CONTENT_TYPE).unwrap(), "0001");
|
|
}
|
|
|
|
#[actix_rt::test]
|
|
async fn changes_body_type() {
|
|
#[allow(clippy::unnecessary_wraps)]
|
|
fn error_handler<B>(res: ServiceResponse<B>) -> Result<ErrorHandlerResponse<B>> {
|
|
let (req, res) = res.into_parts();
|
|
let res = res.set_body(Bytes::from("sorry, that's no bueno"));
|
|
|
|
let res = ServiceResponse::new(req, res)
|
|
.map_into_boxed_body()
|
|
.map_into_right_body();
|
|
|
|
Ok(ErrorHandlerResponse::Response(res))
|
|
}
|
|
|
|
let srv = test::status_service(StatusCode::INTERNAL_SERVER_ERROR);
|
|
|
|
let mw = ErrorHandlers::new()
|
|
.handler(StatusCode::INTERNAL_SERVER_ERROR, error_handler)
|
|
.new_transform(srv.into_service())
|
|
.await
|
|
.unwrap();
|
|
|
|
let res = test::call_service(&mw, TestRequest::default().to_srv_request()).await;
|
|
assert_eq!(test::read_body(res).await, "sorry, that's no bueno");
|
|
}
|
|
|
|
#[actix_rt::test]
|
|
async fn error_thrown() {
|
|
#[allow(clippy::unnecessary_wraps)]
|
|
fn error_handler<B>(_res: ServiceResponse<B>) -> Result<ErrorHandlerResponse<B>> {
|
|
Err(crate::error::ErrorInternalServerError(
|
|
"error in error handler",
|
|
))
|
|
}
|
|
|
|
let srv = test::status_service(StatusCode::BAD_REQUEST);
|
|
|
|
let mw = ErrorHandlers::new()
|
|
.handler(StatusCode::BAD_REQUEST, error_handler)
|
|
.new_transform(srv.into_service())
|
|
.await
|
|
.unwrap();
|
|
|
|
let err = mw
|
|
.call(TestRequest::default().to_srv_request())
|
|
.await
|
|
.unwrap_err();
|
|
let res = err.error_response();
|
|
|
|
assert_eq!(res.status(), StatusCode::INTERNAL_SERVER_ERROR);
|
|
assert_eq!(
|
|
body::to_bytes(res.into_body()).await.unwrap(),
|
|
"error in error handler"
|
|
);
|
|
}
|
|
|
|
#[actix_rt::test]
|
|
async fn default_error_handler() {
|
|
#[allow(clippy::unnecessary_wraps)]
|
|
fn error_handler<B>(mut res: ServiceResponse<B>) -> Result<ErrorHandlerResponse<B>> {
|
|
res.response_mut()
|
|
.headers_mut()
|
|
.insert(CONTENT_TYPE, HeaderValue::from_static("0001"));
|
|
Ok(ErrorHandlerResponse::Response(res.map_into_left_body()))
|
|
}
|
|
|
|
let make_mw = |status| async move {
|
|
ErrorHandlers::new()
|
|
.default_handler(error_handler)
|
|
.new_transform(test::status_service(status).into_service())
|
|
.await
|
|
.unwrap()
|
|
};
|
|
let mw_server = make_mw(StatusCode::INTERNAL_SERVER_ERROR).await;
|
|
let mw_client = make_mw(StatusCode::BAD_REQUEST).await;
|
|
|
|
let resp =
|
|
test::call_service(&mw_client, TestRequest::default().to_srv_request()).await;
|
|
assert_eq!(resp.headers().get(CONTENT_TYPE).unwrap(), "0001");
|
|
|
|
let resp =
|
|
test::call_service(&mw_server, TestRequest::default().to_srv_request()).await;
|
|
assert_eq!(resp.headers().get(CONTENT_TYPE).unwrap(), "0001");
|
|
}
|
|
|
|
#[actix_rt::test]
|
|
async fn default_handlers_separate_client_server() {
|
|
#[allow(clippy::unnecessary_wraps)]
|
|
fn error_handler_client<B>(
|
|
mut res: ServiceResponse<B>,
|
|
) -> Result<ErrorHandlerResponse<B>> {
|
|
res.response_mut()
|
|
.headers_mut()
|
|
.insert(CONTENT_TYPE, HeaderValue::from_static("0001"));
|
|
Ok(ErrorHandlerResponse::Response(res.map_into_left_body()))
|
|
}
|
|
|
|
#[allow(clippy::unnecessary_wraps)]
|
|
fn error_handler_server<B>(
|
|
mut res: ServiceResponse<B>,
|
|
) -> Result<ErrorHandlerResponse<B>> {
|
|
res.response_mut()
|
|
.headers_mut()
|
|
.insert(CONTENT_TYPE, HeaderValue::from_static("0002"));
|
|
Ok(ErrorHandlerResponse::Response(res.map_into_left_body()))
|
|
}
|
|
|
|
let make_mw = |status| async move {
|
|
ErrorHandlers::new()
|
|
.default_handler_server(error_handler_server)
|
|
.default_handler_client(error_handler_client)
|
|
.new_transform(test::status_service(status).into_service())
|
|
.await
|
|
.unwrap()
|
|
};
|
|
let mw_server = make_mw(StatusCode::INTERNAL_SERVER_ERROR).await;
|
|
let mw_client = make_mw(StatusCode::BAD_REQUEST).await;
|
|
|
|
let resp =
|
|
test::call_service(&mw_client, TestRequest::default().to_srv_request()).await;
|
|
assert_eq!(resp.headers().get(CONTENT_TYPE).unwrap(), "0001");
|
|
|
|
let resp =
|
|
test::call_service(&mw_server, TestRequest::default().to_srv_request()).await;
|
|
assert_eq!(resp.headers().get(CONTENT_TYPE).unwrap(), "0002");
|
|
}
|
|
|
|
#[actix_rt::test]
|
|
async fn default_handlers_specialization() {
|
|
#[allow(clippy::unnecessary_wraps)]
|
|
fn error_handler_client<B>(
|
|
mut res: ServiceResponse<B>,
|
|
) -> Result<ErrorHandlerResponse<B>> {
|
|
res.response_mut()
|
|
.headers_mut()
|
|
.insert(CONTENT_TYPE, HeaderValue::from_static("0001"));
|
|
Ok(ErrorHandlerResponse::Response(res.map_into_left_body()))
|
|
}
|
|
|
|
#[allow(clippy::unnecessary_wraps)]
|
|
fn error_handler_specific<B>(
|
|
mut res: ServiceResponse<B>,
|
|
) -> Result<ErrorHandlerResponse<B>> {
|
|
res.response_mut()
|
|
.headers_mut()
|
|
.insert(CONTENT_TYPE, HeaderValue::from_static("0003"));
|
|
Ok(ErrorHandlerResponse::Response(res.map_into_left_body()))
|
|
}
|
|
|
|
let make_mw = |status| async move {
|
|
ErrorHandlers::new()
|
|
.default_handler_client(error_handler_client)
|
|
.handler(StatusCode::UNPROCESSABLE_ENTITY, error_handler_specific)
|
|
.new_transform(test::status_service(status).into_service())
|
|
.await
|
|
.unwrap()
|
|
};
|
|
let mw_client = make_mw(StatusCode::BAD_REQUEST).await;
|
|
let mw_specific = make_mw(StatusCode::UNPROCESSABLE_ENTITY).await;
|
|
|
|
let resp =
|
|
test::call_service(&mw_client, TestRequest::default().to_srv_request()).await;
|
|
assert_eq!(resp.headers().get(CONTENT_TYPE).unwrap(), "0001");
|
|
|
|
let resp =
|
|
test::call_service(&mw_specific, TestRequest::default().to_srv_request()).await;
|
|
assert_eq!(resp.headers().get(CONTENT_TYPE).unwrap(), "0003");
|
|
}
|
|
}
|