2019-03-10 17:53:56 +00:00
|
|
|
//! Request extractors
|
2018-04-02 21:55:42 +00:00
|
|
|
|
2021-01-09 13:17:19 +00:00
|
|
|
use std::{
|
2021-06-22 16:32:03 +00:00
|
|
|
convert::Infallible,
|
2021-01-09 13:17:19 +00:00
|
|
|
future::Future,
|
|
|
|
pin::Pin,
|
|
|
|
task::{Context, Poll},
|
|
|
|
};
|
2018-04-02 21:55:42 +00:00
|
|
|
|
2021-12-05 14:37:20 +00:00
|
|
|
use actix_http::{Method, Uri};
|
2021-04-01 14:26:13 +00:00
|
|
|
use futures_core::ready;
|
2021-11-29 01:23:27 +00:00
|
|
|
use pin_project_lite::pin_project;
|
2021-01-09 13:17:19 +00:00
|
|
|
|
|
|
|
use crate::{dev::Payload, Error, HttpRequest};
|
2018-04-02 21:55:42 +00:00
|
|
|
|
2021-09-11 15:48:47 +00:00
|
|
|
/// A type that implements [`FromRequest`] is called an **extractor** and can extract data from
|
|
|
|
/// the request. Some types that implement this trait are: [`Json`], [`Header`], and [`Path`].
|
2019-03-03 21:53:31 +00:00
|
|
|
///
|
2022-04-02 18:46:26 +00:00
|
|
|
/// Check out [`ServiceRequest::extract`](crate::dev::ServiceRequest::extract) if you want to
|
|
|
|
/// leverage extractors when implementing middlewares.
|
|
|
|
///
|
2021-09-11 15:48:47 +00:00
|
|
|
/// # Configuration
|
2021-09-11 00:11:16 +00:00
|
|
|
/// An extractor can be customized by injecting the corresponding configuration with one of:
|
2021-09-11 15:48:47 +00:00
|
|
|
/// - [`App::app_data()`][crate::App::app_data]
|
|
|
|
/// - [`Scope::app_data()`][crate::Scope::app_data]
|
|
|
|
/// - [`Resource::app_data()`][crate::Resource::app_data]
|
2021-09-11 00:11:16 +00:00
|
|
|
///
|
|
|
|
/// Here are some built-in extractors and their corresponding configuration.
|
|
|
|
/// Please refer to the respective documentation for details.
|
|
|
|
///
|
|
|
|
/// | Extractor | Configuration |
|
|
|
|
/// |-------------|-------------------|
|
2021-09-11 15:48:47 +00:00
|
|
|
/// | [`Header`] | _None_ |
|
|
|
|
/// | [`Path`] | [`PathConfig`] |
|
2021-09-11 00:11:16 +00:00
|
|
|
/// | [`Json`] | [`JsonConfig`] |
|
|
|
|
/// | [`Form`] | [`FormConfig`] |
|
|
|
|
/// | [`Query`] | [`QueryConfig`] |
|
|
|
|
/// | [`Bytes`] | [`PayloadConfig`] |
|
2021-09-11 15:48:47 +00:00
|
|
|
/// | [`String`] | [`PayloadConfig`] |
|
|
|
|
/// | [`Payload`] | [`PayloadConfig`] |
|
|
|
|
///
|
|
|
|
/// # Implementing An Extractor
|
|
|
|
/// To reduce duplicate code in handlers where extracting certain parts of a request has a common
|
|
|
|
/// structure, you can implement `FromRequest` for your own types.
|
|
|
|
///
|
|
|
|
/// Note that the request payload can only be consumed by one extractor.
|
2021-09-11 00:11:16 +00:00
|
|
|
///
|
2021-09-11 15:48:47 +00:00
|
|
|
/// [`Header`]: crate::web::Header
|
2021-09-11 00:11:16 +00:00
|
|
|
/// [`Json`]: crate::web::Json
|
|
|
|
/// [`JsonConfig`]: crate::web::JsonConfig
|
|
|
|
/// [`Form`]: crate::web::Form
|
|
|
|
/// [`FormConfig`]: crate::web::FormConfig
|
|
|
|
/// [`Path`]: crate::web::Path
|
|
|
|
/// [`PathConfig`]: crate::web::PathConfig
|
|
|
|
/// [`Query`]: crate::web::Query
|
|
|
|
/// [`QueryConfig`]: crate::web::QueryConfig
|
|
|
|
/// [`Payload`]: crate::web::Payload
|
|
|
|
/// [`PayloadConfig`]: crate::web::PayloadConfig
|
|
|
|
/// [`String`]: FromRequest#impl-FromRequest-for-String
|
|
|
|
/// [`Bytes`]: crate::web::Bytes#impl-FromRequest
|
2021-09-11 15:48:47 +00:00
|
|
|
/// [`Either`]: crate::web::Either
|
|
|
|
#[doc(alias = "extract", alias = "extractor")]
|
2019-04-13 21:50:54 +00:00
|
|
|
pub trait FromRequest: Sized {
|
2019-03-03 21:53:31 +00:00
|
|
|
/// The associated error which can be returned.
|
|
|
|
type Error: Into<Error>;
|
|
|
|
|
2023-11-17 02:53:32 +00:00
|
|
|
/// Creates a `Self` from request parts asynchronously.
|
|
|
|
fn from_request(
|
|
|
|
req: &HttpRequest,
|
|
|
|
payload: &mut Payload,
|
|
|
|
) -> impl Future<Output = Result<Self, Self::Error>>;
|
2019-04-07 21:43:07 +00:00
|
|
|
|
2022-04-23 20:57:11 +00:00
|
|
|
/// Create a `Self` from request head asynchronously.
|
2019-04-07 21:43:07 +00:00
|
|
|
///
|
2021-01-09 13:17:19 +00:00
|
|
|
/// This method is short for `T::from_request(req, &mut Payload::None)`.
|
2023-11-17 02:53:32 +00:00
|
|
|
fn extract(req: &HttpRequest) -> impl Future<Output = Result<Self, Self::Error>> {
|
|
|
|
async { Self::from_request(req, &mut Payload::None).await }
|
2019-04-07 21:43:07 +00:00
|
|
|
}
|
2019-03-03 21:53:31 +00:00
|
|
|
}
|
|
|
|
|
2022-04-23 20:02:24 +00:00
|
|
|
/// Optionally extract from the request.
|
2018-07-23 13:19:04 +00:00
|
|
|
///
|
2022-04-23 20:02:24 +00:00
|
|
|
/// If the inner `T::from_request` returns an error, handler will receive `None` instead.
|
2018-07-23 13:19:04 +00:00
|
|
|
///
|
2021-06-17 16:57:58 +00:00
|
|
|
/// # Examples
|
2021-03-25 08:45:52 +00:00
|
|
|
/// ```
|
2019-04-07 21:43:07 +00:00
|
|
|
/// use actix_web::{web, dev, App, Error, HttpRequest, FromRequest};
|
2018-07-23 13:19:04 +00:00
|
|
|
/// use actix_web::error::ErrorBadRequest;
|
2020-05-18 02:47:20 +00:00
|
|
|
/// use futures_util::future::{ok, err, Ready};
|
2021-06-23 20:30:06 +00:00
|
|
|
/// use serde::Deserialize;
|
2019-03-03 21:53:31 +00:00
|
|
|
/// use rand;
|
2018-07-23 13:19:04 +00:00
|
|
|
///
|
|
|
|
/// #[derive(Debug, Deserialize)]
|
2019-03-03 21:53:31 +00:00
|
|
|
/// struct Thing {
|
|
|
|
/// name: String
|
|
|
|
/// }
|
2018-07-23 13:19:04 +00:00
|
|
|
///
|
2019-04-13 21:50:54 +00:00
|
|
|
/// impl FromRequest for Thing {
|
2019-03-03 21:53:31 +00:00
|
|
|
/// type Error = Error;
|
2019-11-20 17:33:22 +00:00
|
|
|
/// type Future = Ready<Result<Self, Self::Error>>;
|
2018-07-23 13:19:04 +00:00
|
|
|
///
|
2019-04-13 21:50:54 +00:00
|
|
|
/// fn from_request(req: &HttpRequest, payload: &mut dev::Payload) -> Self::Future {
|
2018-07-23 13:19:04 +00:00
|
|
|
/// if rand::random() {
|
2019-11-20 17:33:22 +00:00
|
|
|
/// ok(Thing { name: "thingy".into() })
|
2018-07-23 13:19:04 +00:00
|
|
|
/// } else {
|
2019-11-20 17:33:22 +00:00
|
|
|
/// err(ErrorBadRequest("no luck"))
|
2018-07-23 13:19:04 +00:00
|
|
|
/// }
|
|
|
|
///
|
|
|
|
/// }
|
|
|
|
/// }
|
|
|
|
///
|
2019-03-03 21:53:31 +00:00
|
|
|
/// /// extract `Thing` from request
|
2019-11-21 15:34:04 +00:00
|
|
|
/// async fn index(supplied_thing: Option<Thing>) -> String {
|
2018-07-23 13:19:04 +00:00
|
|
|
/// match supplied_thing {
|
|
|
|
/// // Puns not intended
|
2019-03-03 21:53:31 +00:00
|
|
|
/// Some(thing) => format!("Got something: {:?}", thing),
|
|
|
|
/// None => format!("No thing!")
|
2018-07-23 13:19:04 +00:00
|
|
|
/// }
|
|
|
|
/// }
|
|
|
|
///
|
2022-02-22 12:32:06 +00:00
|
|
|
/// let app = App::new().service(
|
|
|
|
/// web::resource("/users/:first").route(
|
|
|
|
/// web::post().to(index))
|
|
|
|
/// );
|
2018-07-23 13:19:04 +00:00
|
|
|
/// ```
|
2022-01-12 18:59:22 +00:00
|
|
|
impl<T> FromRequest for Option<T>
|
2018-07-24 21:52:56 +00:00
|
|
|
where
|
2019-04-13 21:50:54 +00:00
|
|
|
T: FromRequest,
|
2018-07-24 21:52:56 +00:00
|
|
|
{
|
2022-01-12 18:59:22 +00:00
|
|
|
type Error = Infallible;
|
2018-07-23 13:19:04 +00:00
|
|
|
|
|
|
|
#[inline]
|
2023-11-17 02:53:32 +00:00
|
|
|
async fn from_request(req: &HttpRequest, payload: &mut Payload) -> Result<Self, Self::Error> {
|
|
|
|
match T::from_request(req, payload).await {
|
|
|
|
Ok(t) => Ok(Some(t)),
|
|
|
|
Err(err) => {
|
|
|
|
log::debug!(
|
|
|
|
"Error from `Option<{}>` extractor: {}",
|
|
|
|
std::any::type_name::<T>(),
|
|
|
|
err.into()
|
|
|
|
);
|
|
|
|
Ok(None)
|
|
|
|
}
|
2020-12-16 18:34:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-11-29 01:23:27 +00:00
|
|
|
pin_project! {
|
|
|
|
pub struct FromRequestOptFuture<Fut> {
|
|
|
|
#[pin]
|
|
|
|
fut: Fut,
|
|
|
|
}
|
2020-12-16 18:34:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
impl<Fut, T, E> Future for FromRequestOptFuture<Fut>
|
|
|
|
where
|
|
|
|
Fut: Future<Output = Result<T, E>>,
|
|
|
|
E: Into<Error>,
|
|
|
|
{
|
2022-01-12 18:59:22 +00:00
|
|
|
type Output = Result<Option<T>, Infallible>;
|
2020-12-16 18:34:10 +00:00
|
|
|
|
|
|
|
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
|
|
|
|
let this = self.project();
|
|
|
|
let res = ready!(this.fut.poll(cx));
|
|
|
|
match res {
|
|
|
|
Ok(t) => Poll::Ready(Ok(Some(t))),
|
2023-09-03 18:09:42 +00:00
|
|
|
Err(err) => {
|
|
|
|
log::debug!("Error for Option<T> extractor: {}", err.into());
|
2020-12-16 18:34:10 +00:00
|
|
|
Poll::Ready(Ok(None))
|
|
|
|
}
|
|
|
|
}
|
2018-07-23 13:19:04 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-04-23 20:02:24 +00:00
|
|
|
/// Extract from the request, passing error type through to handler.
|
2018-07-23 13:19:04 +00:00
|
|
|
///
|
2022-04-23 20:02:24 +00:00
|
|
|
/// If the inner `T::from_request` returns an error, allow handler to receive the error rather than
|
|
|
|
/// immediately returning an error response.
|
2018-07-23 13:19:04 +00:00
|
|
|
///
|
2021-06-17 16:57:58 +00:00
|
|
|
/// # Examples
|
2021-03-25 08:45:52 +00:00
|
|
|
/// ```
|
2019-04-07 21:43:07 +00:00
|
|
|
/// use actix_web::{web, dev, App, Result, Error, HttpRequest, FromRequest};
|
2018-07-23 13:19:04 +00:00
|
|
|
/// use actix_web::error::ErrorBadRequest;
|
2020-05-18 02:47:20 +00:00
|
|
|
/// use futures_util::future::{ok, err, Ready};
|
2021-06-23 20:30:06 +00:00
|
|
|
/// use serde::Deserialize;
|
2019-03-03 21:53:31 +00:00
|
|
|
/// use rand;
|
2018-07-23 13:19:04 +00:00
|
|
|
///
|
|
|
|
/// #[derive(Debug, Deserialize)]
|
2019-03-03 21:53:31 +00:00
|
|
|
/// struct Thing {
|
|
|
|
/// name: String
|
|
|
|
/// }
|
2018-07-23 13:19:04 +00:00
|
|
|
///
|
2019-04-13 21:50:54 +00:00
|
|
|
/// impl FromRequest for Thing {
|
2019-03-03 21:53:31 +00:00
|
|
|
/// type Error = Error;
|
2018-07-23 13:19:04 +00:00
|
|
|
///
|
2023-11-17 02:53:32 +00:00
|
|
|
/// async fn from_request(
|
|
|
|
/// req: &HttpRequest,
|
|
|
|
/// payload: &mut dev::Payload,
|
|
|
|
/// ) -> Result<Self, Self::Error> {
|
2018-07-23 13:19:04 +00:00
|
|
|
/// if rand::random() {
|
2019-11-20 17:33:22 +00:00
|
|
|
/// ok(Thing { name: "thingy".into() })
|
2018-07-23 13:19:04 +00:00
|
|
|
/// } else {
|
2019-11-20 17:33:22 +00:00
|
|
|
/// err(ErrorBadRequest("no luck"))
|
2018-07-23 13:19:04 +00:00
|
|
|
/// }
|
|
|
|
/// }
|
|
|
|
/// }
|
|
|
|
///
|
2019-03-03 21:53:31 +00:00
|
|
|
/// /// extract `Thing` from request
|
2019-11-21 15:34:04 +00:00
|
|
|
/// async fn index(supplied_thing: Result<Thing>) -> String {
|
2018-07-23 13:19:04 +00:00
|
|
|
/// match supplied_thing {
|
2023-09-03 18:09:42 +00:00
|
|
|
/// Ok(thing) => format!("Got thing: {thing:?}"),
|
|
|
|
/// Err(err) => format!("Error extracting thing: {err}"),
|
2018-07-23 13:19:04 +00:00
|
|
|
/// }
|
|
|
|
/// }
|
|
|
|
///
|
2022-02-22 12:32:06 +00:00
|
|
|
/// let app = App::new().service(
|
|
|
|
/// web::resource("/users/:first").route(web::post().to(index))
|
|
|
|
/// );
|
2018-07-23 13:19:04 +00:00
|
|
|
/// ```
|
2022-01-12 18:59:22 +00:00
|
|
|
impl<T, E> FromRequest for Result<T, E>
|
2018-07-24 21:52:56 +00:00
|
|
|
where
|
2022-01-12 18:59:22 +00:00
|
|
|
T: FromRequest,
|
|
|
|
T::Error: Into<E>,
|
2018-07-24 21:52:56 +00:00
|
|
|
{
|
2022-01-12 18:59:22 +00:00
|
|
|
type Error = Infallible;
|
2018-07-23 13:19:04 +00:00
|
|
|
|
|
|
|
#[inline]
|
2023-11-17 02:53:32 +00:00
|
|
|
async fn from_request(req: &HttpRequest, payload: &mut Payload) -> Result<Self, Self::Error> {
|
|
|
|
Ok(T::from_request(req, payload).await.map_err(Into::into))
|
2018-07-23 13:19:04 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-06-22 16:32:03 +00:00
|
|
|
/// Extract the request's URI.
|
|
|
|
///
|
|
|
|
/// # Examples
|
|
|
|
/// ```
|
|
|
|
/// use actix_web::{http::Uri, web, App, Responder};
|
|
|
|
///
|
|
|
|
/// async fn handler(uri: Uri) -> impl Responder {
|
|
|
|
/// format!("Requested path: {}", uri.path())
|
|
|
|
/// }
|
|
|
|
///
|
|
|
|
/// let app = App::new().default_service(web::to(handler));
|
|
|
|
/// ```
|
|
|
|
impl FromRequest for Uri {
|
|
|
|
type Error = Infallible;
|
|
|
|
|
2023-11-17 02:53:32 +00:00
|
|
|
async fn from_request(req: &HttpRequest, _: &mut Payload) -> Result<Self, Self::Error> {
|
|
|
|
Ok(req.uri().clone())
|
2021-06-22 16:32:03 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Extract the request's method.
|
|
|
|
///
|
|
|
|
/// # Examples
|
|
|
|
/// ```
|
|
|
|
/// use actix_web::{http::Method, web, App, Responder};
|
|
|
|
///
|
|
|
|
/// async fn handler(method: Method) -> impl Responder {
|
|
|
|
/// format!("Request method: {}", method)
|
|
|
|
/// }
|
|
|
|
///
|
|
|
|
/// let app = App::new().default_service(web::to(handler));
|
|
|
|
/// ```
|
|
|
|
impl FromRequest for Method {
|
|
|
|
type Error = Infallible;
|
|
|
|
|
2023-11-17 02:53:32 +00:00
|
|
|
async fn from_request(req: &HttpRequest, _: &mut Payload) -> Result<Self, Self::Error> {
|
|
|
|
Ok(req.method().clone())
|
2021-06-22 16:32:03 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-11-29 01:23:27 +00:00
|
|
|
#[doc(hidden)]
|
|
|
|
#[allow(non_snake_case)]
|
|
|
|
mod tuple_from_req {
|
|
|
|
use super::*;
|
|
|
|
|
|
|
|
macro_rules! tuple_from_req {
|
|
|
|
($fut: ident; $($T: ident),*) => {
|
|
|
|
/// FromRequest implementation for tuple
|
|
|
|
#[allow(unused_parens)]
|
|
|
|
impl<$($T: FromRequest + 'static),+> FromRequest for ($($T,)+)
|
|
|
|
{
|
|
|
|
type Error = Error;
|
|
|
|
|
2023-11-17 02:53:32 +00:00
|
|
|
async fn from_request(req: &HttpRequest, payload: &mut Payload) -> Result<Self, Self::Error> {
|
2021-11-29 01:23:27 +00:00
|
|
|
$(
|
2023-11-17 02:53:32 +00:00
|
|
|
let $T = $T::from_request(req, payload).await.map_err(Into::into)?;
|
2021-11-29 01:23:27 +00:00
|
|
|
)+
|
|
|
|
|
2023-11-17 02:53:32 +00:00
|
|
|
Ok(($($T,)+))
|
2021-03-19 04:08:23 +00:00
|
|
|
}
|
2020-01-28 01:45:26 +00:00
|
|
|
}
|
2021-11-29 01:23:27 +00:00
|
|
|
};
|
2018-05-02 20:38:25 +00:00
|
|
|
}
|
|
|
|
|
2022-01-12 18:31:48 +00:00
|
|
|
impl FromRequest for () {
|
|
|
|
type Error = Infallible;
|
|
|
|
|
2023-11-17 02:53:32 +00:00
|
|
|
#[inline]
|
|
|
|
async fn from_request(_: &HttpRequest, _: &mut Payload) -> Result<Self, Self::Error> {
|
|
|
|
Ok(())
|
2022-01-12 18:31:48 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-11-29 01:23:27 +00:00
|
|
|
tuple_from_req! { TupleFromRequest1; A }
|
|
|
|
tuple_from_req! { TupleFromRequest2; A, B }
|
|
|
|
tuple_from_req! { TupleFromRequest3; A, B, C }
|
|
|
|
tuple_from_req! { TupleFromRequest4; A, B, C, D }
|
|
|
|
tuple_from_req! { TupleFromRequest5; A, B, C, D, E }
|
|
|
|
tuple_from_req! { TupleFromRequest6; A, B, C, D, E, F }
|
|
|
|
tuple_from_req! { TupleFromRequest7; A, B, C, D, E, F, G }
|
|
|
|
tuple_from_req! { TupleFromRequest8; A, B, C, D, E, F, G, H }
|
|
|
|
tuple_from_req! { TupleFromRequest9; A, B, C, D, E, F, G, H, I }
|
|
|
|
tuple_from_req! { TupleFromRequest10; A, B, C, D, E, F, G, H, I, J }
|
2022-01-12 18:31:48 +00:00
|
|
|
tuple_from_req! { TupleFromRequest11; A, B, C, D, E, F, G, H, I, J, K }
|
|
|
|
tuple_from_req! { TupleFromRequest12; A, B, C, D, E, F, G, H, I, J, K, L }
|
2023-03-12 04:29:22 +00:00
|
|
|
tuple_from_req! { TupleFromRequest13; A, B, C, D, E, F, G, H, I, J, K, L, M }
|
|
|
|
tuple_from_req! { TupleFromRequest14; A, B, C, D, E, F, G, H, I, J, K, L, M, N }
|
|
|
|
tuple_from_req! { TupleFromRequest15; A, B, C, D, E, F, G, H, I, J, K, L, M, N, O }
|
|
|
|
tuple_from_req! { TupleFromRequest16; A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P }
|
2019-03-03 06:11:24 +00:00
|
|
|
}
|
2018-05-02 20:38:25 +00:00
|
|
|
|
2019-03-03 06:03:45 +00:00
|
|
|
#[cfg(test)]
|
|
|
|
mod tests {
|
2021-12-05 14:37:20 +00:00
|
|
|
use actix_http::header;
|
2019-03-03 06:03:45 +00:00
|
|
|
use bytes::Bytes;
|
2021-06-23 20:30:06 +00:00
|
|
|
use serde::Deserialize;
|
2019-03-03 06:03:45 +00:00
|
|
|
|
|
|
|
use super::*;
|
2023-07-17 01:38:12 +00:00
|
|
|
use crate::{
|
|
|
|
test::TestRequest,
|
|
|
|
types::{Form, FormConfig},
|
|
|
|
};
|
2019-03-03 06:03:45 +00:00
|
|
|
|
|
|
|
#[derive(Deserialize, Debug, PartialEq)]
|
|
|
|
struct Info {
|
|
|
|
hello: String,
|
|
|
|
}
|
2019-03-02 06:51:32 +00:00
|
|
|
|
2019-11-26 05:25:50 +00:00
|
|
|
#[actix_rt::test]
|
|
|
|
async fn test_option() {
|
2021-01-15 02:11:10 +00:00
|
|
|
let (req, mut pl) = TestRequest::default()
|
|
|
|
.insert_header((header::CONTENT_TYPE, "application/x-www-form-urlencoded"))
|
|
|
|
.data(FormConfig::default().limit(4096))
|
|
|
|
.to_http_parts();
|
2019-03-03 23:32:47 +00:00
|
|
|
|
2019-11-26 05:25:50 +00:00
|
|
|
let r = Option::<Form<Info>>::from_request(&req, &mut pl)
|
|
|
|
.await
|
|
|
|
.unwrap();
|
2019-03-03 23:32:47 +00:00
|
|
|
assert_eq!(r, None);
|
|
|
|
|
2021-01-15 02:11:10 +00:00
|
|
|
let (req, mut pl) = TestRequest::default()
|
|
|
|
.insert_header((header::CONTENT_TYPE, "application/x-www-form-urlencoded"))
|
|
|
|
.insert_header((header::CONTENT_LENGTH, "9"))
|
|
|
|
.set_payload(Bytes::from_static(b"hello=world"))
|
|
|
|
.to_http_parts();
|
2019-03-03 23:32:47 +00:00
|
|
|
|
2019-11-26 05:25:50 +00:00
|
|
|
let r = Option::<Form<Info>>::from_request(&req, &mut pl)
|
|
|
|
.await
|
|
|
|
.unwrap();
|
2019-03-03 23:32:47 +00:00
|
|
|
assert_eq!(
|
|
|
|
r,
|
|
|
|
Some(Form(Info {
|
|
|
|
hello: "world".into()
|
|
|
|
}))
|
|
|
|
);
|
|
|
|
|
2021-01-15 02:11:10 +00:00
|
|
|
let (req, mut pl) = TestRequest::default()
|
|
|
|
.insert_header((header::CONTENT_TYPE, "application/x-www-form-urlencoded"))
|
|
|
|
.insert_header((header::CONTENT_LENGTH, "9"))
|
|
|
|
.set_payload(Bytes::from_static(b"bye=world"))
|
|
|
|
.to_http_parts();
|
2019-03-03 23:32:47 +00:00
|
|
|
|
2019-11-26 05:25:50 +00:00
|
|
|
let r = Option::<Form<Info>>::from_request(&req, &mut pl)
|
|
|
|
.await
|
|
|
|
.unwrap();
|
2019-03-03 23:32:47 +00:00
|
|
|
assert_eq!(r, None);
|
|
|
|
}
|
|
|
|
|
2019-11-26 05:25:50 +00:00
|
|
|
#[actix_rt::test]
|
|
|
|
async fn test_result() {
|
2021-01-15 02:11:10 +00:00
|
|
|
let (req, mut pl) = TestRequest::default()
|
|
|
|
.insert_header((header::CONTENT_TYPE, "application/x-www-form-urlencoded"))
|
|
|
|
.insert_header((header::CONTENT_LENGTH, "11"))
|
|
|
|
.set_payload(Bytes::from_static(b"hello=world"))
|
|
|
|
.to_http_parts();
|
2019-03-03 23:32:47 +00:00
|
|
|
|
2019-11-26 05:25:50 +00:00
|
|
|
let r = Result::<Form<Info>, Error>::from_request(&req, &mut pl)
|
|
|
|
.await
|
2019-03-03 23:32:47 +00:00
|
|
|
.unwrap()
|
|
|
|
.unwrap();
|
|
|
|
assert_eq!(
|
|
|
|
r,
|
|
|
|
Form(Info {
|
|
|
|
hello: "world".into()
|
|
|
|
})
|
|
|
|
);
|
|
|
|
|
2021-01-15 02:11:10 +00:00
|
|
|
let (req, mut pl) = TestRequest::default()
|
|
|
|
.insert_header((header::CONTENT_TYPE, "application/x-www-form-urlencoded"))
|
|
|
|
.insert_header((header::CONTENT_LENGTH, 9))
|
|
|
|
.set_payload(Bytes::from_static(b"bye=world"))
|
|
|
|
.to_http_parts();
|
2019-03-03 23:32:47 +00:00
|
|
|
|
2022-01-12 18:59:22 +00:00
|
|
|
struct MyError;
|
|
|
|
impl From<Error> for MyError {
|
|
|
|
fn from(_: Error) -> Self {
|
|
|
|
Self
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
let r = Result::<Form<Info>, MyError>::from_request(&req, &mut pl)
|
2019-11-26 05:25:50 +00:00
|
|
|
.await
|
|
|
|
.unwrap();
|
2019-03-03 23:32:47 +00:00
|
|
|
assert!(r.is_err());
|
|
|
|
}
|
2021-06-22 16:32:03 +00:00
|
|
|
|
|
|
|
#[actix_rt::test]
|
|
|
|
async fn test_uri() {
|
|
|
|
let req = TestRequest::default().uri("/foo/bar").to_http_request();
|
|
|
|
let uri = Uri::extract(&req).await.unwrap();
|
|
|
|
assert_eq!(uri.path(), "/foo/bar");
|
|
|
|
}
|
|
|
|
|
|
|
|
#[actix_rt::test]
|
|
|
|
async fn test_method() {
|
|
|
|
let req = TestRequest::default().method(Method::GET).to_http_request();
|
|
|
|
let method = Method::extract(&req).await.unwrap();
|
|
|
|
assert_eq!(method, Method::GET);
|
|
|
|
}
|
2021-11-29 01:23:27 +00:00
|
|
|
|
|
|
|
#[actix_rt::test]
|
|
|
|
async fn test_concurrent() {
|
|
|
|
let (req, mut pl) = TestRequest::default()
|
|
|
|
.uri("/foo/bar")
|
|
|
|
.method(Method::GET)
|
|
|
|
.insert_header((header::CONTENT_TYPE, "application/x-www-form-urlencoded"))
|
|
|
|
.insert_header((header::CONTENT_LENGTH, "11"))
|
|
|
|
.set_payload(Bytes::from_static(b"hello=world"))
|
|
|
|
.to_http_parts();
|
|
|
|
let (method, uri, form) = <(Method, Uri, Form<Info>)>::from_request(&req, &mut pl)
|
|
|
|
.await
|
|
|
|
.unwrap();
|
|
|
|
assert_eq!(method, Method::GET);
|
|
|
|
assert_eq!(uri.path(), "/foo/bar");
|
|
|
|
assert_eq!(
|
|
|
|
form,
|
|
|
|
Form(Info {
|
|
|
|
hello: "world".into()
|
|
|
|
})
|
|
|
|
);
|
|
|
|
}
|
2019-03-03 23:32:47 +00:00
|
|
|
}
|