1
0
Fork 0
mirror of https://github.com/actix/actix-web.git synced 2024-06-02 21:39:26 +00:00
actix-web/src/extractor.rs

986 lines
27 KiB
Rust
Raw Normal View History

use std::marker::PhantomData;
use std::ops::{Deref, DerefMut};
2018-06-12 21:47:47 +00:00
use std::rc::Rc;
2018-06-21 05:47:01 +00:00
use std::{fmt, str};
2018-04-02 23:19:18 +00:00
use bytes::Bytes;
use encoding::all::UTF_8;
2018-04-13 23:02:01 +00:00
use encoding::types::{DecoderTrap, Encoding};
2018-07-24 07:39:27 +00:00
use futures::{Async, Future, Poll, future};
2018-04-13 23:02:01 +00:00
use mime::Mime;
use serde::de::{self, DeserializeOwned};
use serde_urlencoded;
2018-04-13 23:02:01 +00:00
use de::PathDeserializer;
2018-06-12 21:47:47 +00:00
use error::{Error, ErrorBadRequest, ErrorNotFound, UrlencodedError};
2018-05-03 23:22:08 +00:00
use handler::{AsyncResult, FromRequest};
2018-04-02 23:19:18 +00:00
use httpmessage::{HttpMessage, MessageBody, UrlEncoded};
2018-04-13 23:02:01 +00:00
use httprequest::HttpRequest;
#[derive(PartialEq, Eq, PartialOrd, Ord)]
/// Extract typed information from the request's path.
///
/// ## Example
///
/// ```rust
/// # extern crate bytes;
/// # extern crate actix_web;
/// # extern crate futures;
2018-06-01 16:37:14 +00:00
/// use actix_web::{http, App, Path, Result};
///
2018-04-17 23:22:25 +00:00
/// /// extract path info from "/{username}/{count}/index.html" url
/// /// {username} - deserializes to a String
/// /// {count} - - deserializes to a u32
/// fn index(info: Path<(String, u32)>) -> Result<String> {
/// Ok(format!("Welcome {}! {}", info.0, info.1))
/// }
///
/// fn main() {
/// let app = App::new().resource(
2018-06-01 16:37:14 +00:00
/// "/{username}/{count}/index.html", // <- define path parameters
/// |r| r.method(http::Method::GET).with(index),
/// ); // <- use `with` extractor
/// }
/// ```
///
2018-04-13 23:02:01 +00:00
/// It is possible to extract path information to a specific type that
/// implements `Deserialize` trait from *serde*.
///
/// ```rust
/// # extern crate bytes;
/// # extern crate actix_web;
/// # extern crate futures;
/// #[macro_use] extern crate serde_derive;
2018-06-01 16:37:14 +00:00
/// use actix_web::{http, App, Path, Result};
///
/// #[derive(Deserialize)]
/// struct Info {
/// username: String,
/// }
///
/// /// extract path info using serde
/// fn index(info: Path<Info>) -> Result<String> {
/// Ok(format!("Welcome {}!", info.username))
/// }
///
/// fn main() {
/// let app = App::new().resource(
2018-06-01 16:37:14 +00:00
/// "/{username}/index.html", // <- define path parameters
/// |r| r.method(http::Method::GET).with(index),
/// ); // <- use `with` extractor
/// }
/// ```
2018-04-13 23:02:01 +00:00
pub struct Path<T> {
inner: T,
}
impl<T> AsRef<T> for Path<T> {
fn as_ref(&self) -> &T {
&self.inner
}
}
impl<T> Deref for Path<T> {
type Target = T;
fn deref(&self) -> &T {
&self.inner
}
}
impl<T> DerefMut for Path<T> {
fn deref_mut(&mut self) -> &mut T {
&mut self.inner
}
}
impl<T> Path<T> {
/// Deconstruct to an inner value
pub fn into_inner(self) -> T {
self.inner
}
}
impl<T, S> FromRequest<S> for Path<T>
2018-04-13 23:02:01 +00:00
where
T: DeserializeOwned,
{
2018-04-04 05:06:18 +00:00
type Config = ();
2018-05-02 00:19:15 +00:00
type Result = Result<Self, Error>;
#[inline]
fn from_request(req: &HttpRequest<S>, _: &Self::Config) -> Self::Result {
let req = req.clone();
2018-05-02 00:19:15 +00:00
de::Deserialize::deserialize(PathDeserializer::new(&req))
.map_err(ErrorNotFound)
2018-05-02 00:19:15 +00:00
.map(|inner| Path { inner })
}
}
impl<T: fmt::Debug> fmt::Debug for Path<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
self.inner.fmt(f)
}
}
impl<T: fmt::Display> fmt::Display for Path<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
self.inner.fmt(f)
}
}
#[derive(PartialEq, Eq, PartialOrd, Ord)]
/// Extract typed information from from the request's query.
///
/// ## Example
///
/// ```rust
2018-06-01 17:27:23 +00:00
/// # extern crate bytes;
/// # extern crate actix_web;
/// # extern crate futures;
/// #[macro_use] extern crate serde_derive;
/// use actix_web::{App, Query, http};
///
///
///#[derive(Debug, Deserialize)]
///pub enum ResponseType {
/// Token,
/// Code
///}
///
///#[derive(Deserialize)]
///pub struct AuthRequest {
/// id: u64,
/// response_type: ResponseType,
///}
///
/// // use `with` extractor for query info
/// // this handler get called only if request's query contains `username` field
/// // The correct request for this handler would be `/index.html?id=64&response_type=Code"`
/// fn index(info: Query<AuthRequest>) -> String {
/// format!("Authorization request for client with id={} and type={:?}!", info.id, info.response_type)
/// }
///
/// fn main() {
/// let app = App::new().resource(
/// "/index.html",
/// |r| r.method(http::Method::GET).with(index)); // <- use `with` extractor
/// }
/// ```
pub struct Query<T>(T);
impl<T> Deref for Query<T> {
type Target = T;
fn deref(&self) -> &T {
&self.0
}
}
impl<T> DerefMut for Query<T> {
fn deref_mut(&mut self) -> &mut T {
&mut self.0
}
}
impl<T> Query<T> {
/// Deconstruct to a inner value
pub fn into_inner(self) -> T {
self.0
}
}
impl<T, S> FromRequest<S> for Query<T>
2018-04-13 23:02:01 +00:00
where
T: de::DeserializeOwned,
{
2018-04-04 05:06:18 +00:00
type Config = ();
2018-05-02 00:19:15 +00:00
type Result = Result<Self, Error>;
#[inline]
fn from_request(req: &HttpRequest<S>, _: &Self::Config) -> Self::Result {
2018-05-02 00:19:15 +00:00
serde_urlencoded::from_str::<T>(req.query_string())
.map_err(|e| e.into())
.map(Query)
}
}
impl<T: fmt::Debug> fmt::Debug for Query<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
self.0.fmt(f)
}
}
impl<T: fmt::Display> fmt::Display for Query<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
self.0.fmt(f)
}
}
#[derive(PartialEq, Eq, PartialOrd, Ord)]
/// Extract typed information from the request's body.
///
2018-04-13 23:02:01 +00:00
/// To extract typed information from request's body, the type `T` must
/// implement the `Deserialize` trait from *serde*.
///
2018-04-06 17:24:57 +00:00
/// [**FormConfig**](dev/struct.FormConfig.html) allows to configure extraction
/// process.
///
/// ## Example
///
/// ```rust
/// # extern crate actix_web;
/// #[macro_use] extern crate serde_derive;
/// use actix_web::{App, Form, Result};
///
/// #[derive(Deserialize)]
/// struct FormData {
/// username: String,
/// }
///
/// /// extract form data using serde
2018-04-06 17:24:57 +00:00
/// /// this handler get called only if content type is *x-www-form-urlencoded*
/// /// and content of the request could be deserialized to a `FormData` struct
/// fn index(form: Form<FormData>) -> Result<String> {
/// Ok(format!("Welcome {}!", form.username))
/// }
/// # fn main() {}
/// ```
pub struct Form<T>(pub T);
impl<T> Form<T> {
/// Deconstruct to an inner value
pub fn into_inner(self) -> T {
self.0
}
}
impl<T> Deref for Form<T> {
type Target = T;
fn deref(&self) -> &T {
&self.0
}
}
impl<T> DerefMut for Form<T> {
fn deref_mut(&mut self) -> &mut T {
&mut self.0
}
}
impl<T, S> FromRequest<S> for Form<T>
2018-04-13 23:02:01 +00:00
where
T: DeserializeOwned + 'static,
S: 'static,
{
2018-06-12 21:47:47 +00:00
type Config = FormConfig<S>;
2018-04-13 23:02:01 +00:00
type Result = Box<Future<Item = Self, Error = Error>>;
#[inline]
fn from_request(req: &HttpRequest<S>, cfg: &Self::Config) -> Self::Result {
2018-06-25 04:58:04 +00:00
let req2 = req.clone();
2018-06-12 21:47:47 +00:00
let err = Rc::clone(&cfg.ehandler);
2018-04-29 16:09:08 +00:00
Box::new(
2018-06-25 04:58:04 +00:00
UrlEncoded::new(req)
2018-04-29 16:09:08 +00:00
.limit(cfg.limit)
2018-06-25 04:58:04 +00:00
.map_err(move |e| (*err)(e, &req2))
2018-04-29 16:09:08 +00:00
.map(Form),
)
2018-04-04 05:06:18 +00:00
}
}
impl<T: fmt::Debug> fmt::Debug for Form<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
self.0.fmt(f)
}
}
impl<T: fmt::Display> fmt::Display for Form<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
self.0.fmt(f)
}
}
2018-04-04 05:06:18 +00:00
/// Form extractor configuration
///
/// ```rust
/// # extern crate actix_web;
/// #[macro_use] extern crate serde_derive;
2018-06-01 16:37:14 +00:00
/// use actix_web::{http, App, Form, Result};
2018-04-04 05:06:18 +00:00
///
/// #[derive(Deserialize)]
/// struct FormData {
/// username: String,
/// }
///
2018-04-06 17:24:57 +00:00
/// /// extract form data using serde.
/// /// custom configuration is used for this handler, max payload size is 4k
2018-04-04 05:06:18 +00:00
/// fn index(form: Form<FormData>) -> Result<String> {
/// Ok(format!("Welcome {}!", form.username))
/// }
///
/// fn main() {
/// let app = App::new().resource(
2018-06-01 16:37:14 +00:00
/// "/index.html",
/// |r| {
2018-06-21 06:04:00 +00:00
/// r.method(http::Method::GET)
/// // register form handler and change form extractor configuration
/// .with_config(index, |cfg| {cfg.limit(4096);})
/// },
2018-04-04 05:06:18 +00:00
/// );
/// }
/// ```
2018-06-12 21:47:47 +00:00
pub struct FormConfig<S> {
2018-04-04 05:06:18 +00:00
limit: usize,
2018-06-25 04:58:04 +00:00
ehandler: Rc<Fn(UrlencodedError, &HttpRequest<S>) -> Error>,
2018-04-04 05:06:18 +00:00
}
2018-06-12 21:47:47 +00:00
impl<S> FormConfig<S> {
2018-04-04 05:06:18 +00:00
/// Change max size of payload. By default max size is 256Kb
pub fn limit(&mut self, limit: usize) -> &mut Self {
self.limit = limit;
self
}
2018-06-21 05:47:01 +00:00
2018-06-12 21:47:47 +00:00
/// Set custom error handler
pub fn error_handler<F>(&mut self, f: F) -> &mut Self
where
2018-06-25 04:58:04 +00:00
F: Fn(UrlencodedError, &HttpRequest<S>) -> Error + 'static,
2018-06-12 21:47:47 +00:00
{
self.ehandler = Rc::new(f);
self
}
2018-04-04 05:06:18 +00:00
}
2018-06-12 21:47:47 +00:00
impl<S> Default for FormConfig<S> {
2018-04-04 05:06:18 +00:00
fn default() -> Self {
2018-06-12 21:47:47 +00:00
FormConfig {
limit: 262_144,
ehandler: Rc::new(|e, _| e.into()),
}
}
}
2018-04-02 23:19:18 +00:00
/// Request payload extractor.
///
/// Loads request's payload and construct Bytes instance.
///
2018-04-13 23:02:01 +00:00
/// [**PayloadConfig**](dev/struct.PayloadConfig.html) allows to configure
/// extraction process.
2018-04-06 17:24:57 +00:00
///
2018-04-02 23:19:18 +00:00
/// ## Example
///
/// ```rust
/// extern crate bytes;
/// # extern crate actix_web;
2018-04-16 16:30:59 +00:00
/// use actix_web::{http, App, Result};
2018-04-02 23:19:18 +00:00
///
/// /// extract text data from request
/// fn index(body: bytes::Bytes) -> Result<String> {
/// Ok(format!("Body {:?}!", body))
/// }
2018-04-16 16:30:59 +00:00
///
/// fn main() {
2018-06-01 16:37:14 +00:00
/// let app = App::new()
/// .resource("/index.html", |r| r.method(http::Method::GET).with(index));
2018-04-16 16:30:59 +00:00
/// }
2018-04-02 23:19:18 +00:00
/// ```
2018-04-13 23:02:01 +00:00
impl<S: 'static> FromRequest<S> for Bytes {
2018-04-05 04:13:48 +00:00
type Config = PayloadConfig;
2018-05-02 00:19:15 +00:00
type Result = Result<Box<Future<Item = Self, Error = Error>>, Error>;
2018-04-02 23:19:18 +00:00
#[inline]
fn from_request(req: &HttpRequest<S>, cfg: &Self::Config) -> Self::Result {
2018-04-05 04:13:48 +00:00
// check content-type
2018-05-02 00:19:15 +00:00
cfg.check_mimetype(req)?;
2018-04-05 04:13:48 +00:00
2018-06-25 04:58:04 +00:00
Ok(Box::new(MessageBody::new(req).limit(cfg.limit).from_err()))
2018-04-02 23:19:18 +00:00
}
}
/// Extract text information from the request's body.
///
/// Text extractor automatically decode body according to the request's charset.
///
2018-04-06 17:24:57 +00:00
/// [**PayloadConfig**](dev/struct.PayloadConfig.html) allows to configure
/// extraction process.
///
2018-04-02 23:19:18 +00:00
/// ## Example
///
/// ```rust
/// # extern crate actix_web;
2018-04-16 16:30:59 +00:00
/// use actix_web::{http, App, Result};
2018-04-02 23:19:18 +00:00
///
/// /// extract text data from request
/// fn index(body: String) -> Result<String> {
/// Ok(format!("Body {}!", body))
/// }
2018-04-16 16:30:59 +00:00
///
/// fn main() {
2018-06-01 16:37:14 +00:00
/// let app = App::new().resource("/index.html", |r| {
/// r.method(http::Method::GET)
2018-06-21 05:47:01 +00:00
/// .with_config(index, |cfg| { // <- register handler with extractor params
/// cfg.limit(4096); // <- limit size of the payload
/// })
2018-06-01 16:37:14 +00:00
/// });
2018-04-16 16:30:59 +00:00
/// }
2018-04-02 23:19:18 +00:00
/// ```
2018-04-13 23:02:01 +00:00
impl<S: 'static> FromRequest<S> for String {
2018-04-05 04:13:48 +00:00
type Config = PayloadConfig;
2018-05-02 00:19:15 +00:00
type Result = Result<Box<Future<Item = String, Error = Error>>, Error>;
2018-04-02 23:19:18 +00:00
#[inline]
fn from_request(req: &HttpRequest<S>, cfg: &Self::Config) -> Self::Result {
2018-04-05 04:13:48 +00:00
// check content-type
2018-05-02 00:19:15 +00:00
cfg.check_mimetype(req)?;
2018-04-05 04:13:48 +00:00
// check charset
2018-05-02 00:19:15 +00:00
let encoding = req.encoding()?;
2018-04-02 23:19:18 +00:00
2018-05-02 00:19:15 +00:00
Ok(Box::new(
2018-06-25 04:58:04 +00:00
MessageBody::new(req)
2018-04-29 16:09:08 +00:00
.limit(cfg.limit)
.from_err()
.and_then(move |body| {
2018-04-02 23:19:18 +00:00
let enc: *const Encoding = encoding as *const Encoding;
if enc == UTF_8 {
Ok(str::from_utf8(body.as_ref())
2018-04-13 23:02:01 +00:00
.map_err(|_| ErrorBadRequest("Can not decode body"))?
.to_owned())
2018-04-02 23:19:18 +00:00
} else {
2018-04-13 23:02:01 +00:00
Ok(encoding
.decode(&body, DecoderTrap::Strict)
.map_err(|_| ErrorBadRequest("Can not decode body"))?)
2018-04-02 23:19:18 +00:00
}
2018-04-29 16:09:08 +00:00
}),
2018-04-13 23:02:01 +00:00
))
2018-04-02 23:19:18 +00:00
}
}
/// Optionally extract a field from the request
///
/// If the FromRequest for T fails, return None rather than returning an error response
///
/// ## Example
///
/// ```rust
/// # extern crate actix_web;
/// extern crate rand;
/// #[macro_use] extern crate serde_derive;
/// use actix_web::{http, App, Result, HttpRequest, Error, FromRequest};
/// use actix_web::error::ErrorBadRequest;
///
/// #[derive(Debug, Deserialize)]
/// struct Thing { name: String }
///
/// impl<S> FromRequest<S> for Thing {
/// type Config = ();
/// type Result = Result<Thing, Error>;
///
/// #[inline]
/// fn from_request(req: &HttpRequest<S>, _cfg: &Self::Config) -> Self::Result {
/// if rand::random() {
/// Ok(Thing { name: "thingy".into() })
/// } else {
/// Err(ErrorBadRequest("no luck"))
/// }
///
/// }
/// }
///
/// /// extract text data from request
/// fn index(supplied_thing: Option<Thing>) -> Result<String> {
/// match supplied_thing {
/// // Puns not intended
/// Some(thing) => Ok(format!("Got something: {:?}", thing)),
/// None => Ok(format!("No thing!"))
/// }
/// }
///
/// fn main() {
/// let app = App::new().resource("/users/:first", |r| {
/// r.method(http::Method::POST).with(index)
/// });
/// }
/// ```
impl<T: 'static, S: 'static> FromRequest<S> for Option<T> where T: FromRequest<S> {
type Config = T::Config;
type Result = Box<Future<Item = Option<T>, Error = Error>>;
#[inline]
fn from_request(req: &HttpRequest<S>, cfg: &Self::Config) -> Self::Result {
Box::new(T::from_request(req, cfg).into().then( |r| {
match r {
Ok(v) => future::ok(Some(v)),
Err(e) => {
future::ok(None)
}
}
}))
}
}
/// Optionally extract a field from the request or extract the Error if unsuccessful
///
/// If the FromRequest for T fails, inject Err into handler rather than returning an error response
///
/// ## Example
///
/// ```rust
/// # extern crate actix_web;
/// extern crate rand;
/// #[macro_use] extern crate serde_derive;
/// use actix_web::{http, App, Result, HttpRequest, Error, FromRequest};
/// use actix_web::error::ErrorBadRequest;
///
/// #[derive(Debug, Deserialize)]
/// struct Thing { name: String }
///
/// impl<S> FromRequest<S> for Thing {
/// type Config = ();
/// type Result = Result<Thing, Error>;
///
/// #[inline]
/// fn from_request(req: &HttpRequest<S>, _cfg: &Self::Config) -> Self::Result {
/// if rand::random() {
/// Ok(Thing { name: "thingy".into() })
/// } else {
/// Err(ErrorBadRequest("no luck"))
/// }
///
/// }
/// }
///
/// /// extract text data from request
/// fn index(supplied_thing: Result<Thing>) -> Result<String> {
/// match supplied_thing {
/// Ok(thing) => Ok(format!("Got thing: {:?}", thing)),
/// Err(e) => Ok(format!("Error extracting thing: {}", e))
/// }
/// }
///
/// fn main() {
/// let app = App::new().resource("/users/:first", |r| {
/// r.method(http::Method::POST).with(index)
/// });
/// }
/// ```
2018-07-24 07:39:27 +00:00
impl<T: 'static, S: 'static> FromRequest<S> for Result<T, Error> where T: FromRequest<S>{
type Config = T::Config;
2018-07-24 07:39:27 +00:00
type Result = Box<Future<Item = Result<T, Error>, Error = Error>>;
#[inline]
fn from_request(req: &HttpRequest<S>, cfg: &Self::Config) -> Self::Result {
Box::new(T::from_request(req, cfg).into().then( |r| { future::ok(r) }))
}
}
2018-04-05 04:13:48 +00:00
/// Payload configuration for request's payload.
pub struct PayloadConfig {
limit: usize,
mimetype: Option<Mime>,
}
impl PayloadConfig {
/// Change max size of payload. By default max size is 256Kb
pub fn limit(&mut self, limit: usize) -> &mut Self {
self.limit = limit;
self
}
2018-04-13 23:02:01 +00:00
/// Set required mime-type of the request. By default mime type is not
/// enforced.
2018-04-05 04:13:48 +00:00
pub fn mimetype(&mut self, mt: Mime) -> &mut Self {
self.mimetype = Some(mt);
self
}
fn check_mimetype<S>(&self, req: &HttpRequest<S>) -> Result<(), Error> {
// check content-type
if let Some(ref mt) = self.mimetype {
match req.mime_type() {
Ok(Some(ref req_mt)) => {
if mt != req_mt {
return Err(ErrorBadRequest("Unexpected Content-Type"));
}
2018-04-13 23:02:01 +00:00
}
2018-04-05 04:13:48 +00:00
Ok(None) => {
return Err(ErrorBadRequest("Content-Type is expected"));
2018-04-13 23:02:01 +00:00
}
2018-04-05 04:13:48 +00:00
Err(err) => {
return Err(err.into());
2018-04-13 23:02:01 +00:00
}
2018-04-05 04:13:48 +00:00
}
}
Ok(())
}
}
impl Default for PayloadConfig {
fn default() -> Self {
2018-04-13 23:02:01 +00:00
PayloadConfig {
limit: 262_144,
mimetype: None,
}
2018-04-05 04:13:48 +00:00
}
}
macro_rules! tuple_from_req ({$fut_type:ident, $(($n:tt, $T:ident)),+} => {
/// FromRequest implementation for tuple
impl<S, $($T: FromRequest<S> + 'static),+> FromRequest<S> for ($($T,)+)
where
S: 'static,
{
type Config = ($($T::Config,)+);
type Result = Box<Future<Item = ($($T,)+), Error = Error>>;
fn from_request(req: &HttpRequest<S>, cfg: &Self::Config) -> Self::Result {
Box::new($fut_type {
s: PhantomData,
items: <($(Option<$T>,)+)>::default(),
futs: ($(Some($T::from_request(req, &cfg.$n).into()),)+),
})
}
}
struct $fut_type<S, $($T: FromRequest<S>),+>
where
S: 'static,
{
s: PhantomData<S>,
items: ($(Option<$T>,)+),
2018-05-03 23:22:08 +00:00
futs: ($(Option<AsyncResult<$T>>,)+),
}
impl<S, $($T: FromRequest<S>),+> Future for $fut_type<S, $($T),+>
where
S: 'static,
{
type Item = ($($T,)+);
type Error = Error;
fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
let mut ready = true;
$(
if self.futs.$n.is_some() {
match self.futs.$n.as_mut().unwrap().poll() {
Ok(Async::Ready(item)) => {
self.items.$n = Some(item);
self.futs.$n.take();
}
Ok(Async::NotReady) => ready = false,
Err(e) => return Err(e),
}
}
)+
if ready {
Ok(Async::Ready(
($(self.items.$n.take().unwrap(),)+)
))
} else {
Ok(Async::NotReady)
}
}
}
});
tuple_from_req!(TupleFromRequest1, (0, A));
tuple_from_req!(TupleFromRequest2, (0, A), (1, B));
tuple_from_req!(TupleFromRequest3, (0, A), (1, B), (2, C));
tuple_from_req!(TupleFromRequest4, (0, A), (1, B), (2, C), (3, D));
2018-05-17 19:20:20 +00:00
tuple_from_req!(TupleFromRequest5, (0, A), (1, B), (2, C), (3, D), (4, E));
tuple_from_req!(
TupleFromRequest6,
(0, A),
(1, B),
(2, C),
(3, D),
(4, E),
(5, F)
);
tuple_from_req!(
TupleFromRequest7,
(0, A),
(1, B),
(2, C),
(3, D),
(4, E),
(5, F),
(6, G)
);
tuple_from_req!(
TupleFromRequest8,
(0, A),
(1, B),
(2, C),
(3, D),
(4, E),
(5, F),
(6, G),
(7, H)
);
tuple_from_req!(
TupleFromRequest9,
(0, A),
(1, B),
(2, C),
(3, D),
(4, E),
(5, F),
(6, G),
(7, H),
(8, I)
);
#[cfg(test)]
mod tests {
use super::*;
use bytes::Bytes;
use futures::{Async, Future};
use http::header;
2018-04-13 23:02:01 +00:00
use mime;
2018-07-12 09:30:01 +00:00
use resource::Resource;
use router::{ResourceDef, Router};
2018-04-13 23:02:01 +00:00
use test::TestRequest;
#[derive(Deserialize, Debug, PartialEq)]
struct Info {
hello: String,
}
#[test]
2018-04-02 23:19:18 +00:00
fn test_bytes() {
2018-04-05 04:13:48 +00:00
let cfg = PayloadConfig::default();
2018-06-25 04:58:04 +00:00
let req = TestRequest::with_header(header::CONTENT_LENGTH, "11")
.set_payload(Bytes::from_static(b"hello=world"))
.finish();
2018-04-02 23:19:18 +00:00
2018-05-17 19:20:20 +00:00
match Bytes::from_request(&req, &cfg).unwrap().poll().unwrap() {
2018-04-02 23:19:18 +00:00
Async::Ready(s) => {
assert_eq!(s, Bytes::from_static(b"hello=world"));
2018-04-13 23:02:01 +00:00
}
2018-04-02 23:19:18 +00:00
_ => unreachable!(),
}
}
#[test]
fn test_string() {
2018-04-05 04:13:48 +00:00
let cfg = PayloadConfig::default();
2018-06-25 04:58:04 +00:00
let req = TestRequest::with_header(header::CONTENT_LENGTH, "11")
.set_payload(Bytes::from_static(b"hello=world"))
.finish();
2018-05-17 19:20:20 +00:00
match String::from_request(&req, &cfg).unwrap().poll().unwrap() {
Async::Ready(s) => {
2018-04-02 23:19:18 +00:00
assert_eq!(s, "hello=world");
2018-04-13 23:02:01 +00:00
}
_ => unreachable!(),
}
}
#[test]
fn test_form() {
2018-06-25 04:58:04 +00:00
let req = TestRequest::with_header(
2018-04-13 23:02:01 +00:00
header::CONTENT_TYPE,
"application/x-www-form-urlencoded",
).header(header::CONTENT_LENGTH, "11")
2018-06-25 04:58:04 +00:00
.set_payload(Bytes::from_static(b"hello=world"))
.finish();
2018-04-04 05:06:18 +00:00
let mut cfg = FormConfig::default();
cfg.limit(4096);
match Form::<Info>::from_request(&req, &cfg).poll().unwrap() {
Async::Ready(s) => {
assert_eq!(s.hello, "world");
2018-04-13 23:02:01 +00:00
}
_ => unreachable!(),
}
}
#[test]
fn test_option() {
let req = TestRequest::with_header(
header::CONTENT_TYPE,
"application/x-www-form-urlencoded",
).finish();
let mut cfg = FormConfig::default();
cfg.limit(4096);
match Option::<Form<Info>>::from_request(&req, &cfg).poll().unwrap() {
Async::Ready(r) => assert_eq!(r, None),
_ => unreachable!(),
}
let req = TestRequest::with_header(
header::CONTENT_TYPE,
"application/x-www-form-urlencoded",
).header(header::CONTENT_LENGTH, "9")
.set_payload(Bytes::from_static(b"hello=world"))
.finish();
match Option::<Form<Info>>::from_request(&req, &cfg).poll().unwrap() {
Async::Ready(r) => assert_eq!(r, Some(Form(Info { hello: "world".into() }))),
_ => unreachable!(),
}
let req = TestRequest::with_header(
header::CONTENT_TYPE,
"application/x-www-form-urlencoded",
).header(header::CONTENT_LENGTH, "9")
.set_payload(Bytes::from_static(b"bye=world"))
.finish();
match Option::<Form<Info>>::from_request(&req, &cfg).poll().unwrap() {
Async::Ready(r) => assert_eq!(r, None),
_ => unreachable!(),
}
}
#[test]
fn test_result() {
let req = TestRequest::with_header(
header::CONTENT_TYPE,
"application/x-www-form-urlencoded",
).header(header::CONTENT_LENGTH, "11")
.set_payload(Bytes::from_static(b"hello=world"))
.finish();
2018-07-24 07:39:27 +00:00
match Result::<Form<Info>, Error>::from_request(&req, &FormConfig::default()).poll().unwrap() {
Async::Ready(Ok(r)) => assert_eq!(r, Form(Info { hello: "world".into() })),
_ => unreachable!(),
}
let req = TestRequest::with_header(
header::CONTENT_TYPE,
"application/x-www-form-urlencoded",
).header(header::CONTENT_LENGTH, "9")
.set_payload(Bytes::from_static(b"bye=world"))
.finish();
2018-07-24 07:39:27 +00:00
match Result::<Form<Info>, Error>::from_request(&req, &FormConfig::default()).poll().unwrap() {
Async::Ready(r) => assert!(r.is_err()),
_ => unreachable!(),
}
}
2018-04-05 04:13:48 +00:00
#[test]
fn test_payload_config() {
2018-06-25 04:58:04 +00:00
let req = TestRequest::default().finish();
2018-04-05 04:13:48 +00:00
let mut cfg = PayloadConfig::default();
cfg.mimetype(mime::APPLICATION_JSON);
assert!(cfg.check_mimetype(&req).is_err());
let req = TestRequest::with_header(
2018-04-13 23:02:01 +00:00
header::CONTENT_TYPE,
"application/x-www-form-urlencoded",
).finish();
2018-04-05 04:13:48 +00:00
assert!(cfg.check_mimetype(&req).is_err());
2018-04-13 23:02:01 +00:00
let req =
TestRequest::with_header(header::CONTENT_TYPE, "application/json").finish();
2018-04-05 04:13:48 +00:00
assert!(cfg.check_mimetype(&req).is_ok());
}
#[derive(Deserialize)]
struct MyStruct {
key: String,
value: String,
}
#[derive(Deserialize)]
struct Id {
id: String,
}
#[derive(Deserialize)]
struct Test2 {
key: String,
value: u32,
}
#[test]
fn test_request_extract() {
2018-06-25 04:58:04 +00:00
let req = TestRequest::with_uri("/name/user1/?id=test").finish();
2018-07-15 09:12:21 +00:00
let mut router = Router::<()>::new();
router.register_resource(Resource::new(ResourceDef::new("/{key}/{value}/")));
let info = router.recognize(&req, &(), 0);
2018-06-25 04:58:04 +00:00
let req = req.with_route_info(info);
let s = Path::<MyStruct>::from_request(&req, &()).unwrap();
2018-05-02 00:19:15 +00:00
assert_eq!(s.key, "name");
assert_eq!(s.value, "user1");
let s = Path::<(String, String)>::from_request(&req, &()).unwrap();
2018-05-02 00:19:15 +00:00
assert_eq!(s.0, "name");
assert_eq!(s.1, "user1");
let s = Query::<Id>::from_request(&req, &()).unwrap();
2018-05-02 00:19:15 +00:00
assert_eq!(s.id, "test");
2018-07-15 09:12:21 +00:00
let mut router = Router::<()>::new();
router.register_resource(Resource::new(ResourceDef::new("/{key}/{value}/")));
let req = TestRequest::with_uri("/name/32/").finish();
let info = router.recognize(&req, &(), 0);
2018-06-25 04:58:04 +00:00
let req = req.with_route_info(info);
let s = Path::<Test2>::from_request(&req, &()).unwrap();
2018-05-02 00:19:15 +00:00
assert_eq!(s.as_ref().key, "name");
assert_eq!(s.value, 32);
let s = Path::<(String, u8)>::from_request(&req, &()).unwrap();
2018-05-02 00:19:15 +00:00
assert_eq!(s.0, "name");
assert_eq!(s.1, 32);
2018-05-02 13:09:50 +00:00
let res = Path::<Vec<String>>::extract(&req).unwrap();
2018-05-02 00:19:15 +00:00
assert_eq!(res[0], "name".to_owned());
assert_eq!(res[1], "32".to_owned());
}
#[test]
2018-05-06 16:07:30 +00:00
fn test_extract_path_single() {
2018-07-15 09:12:21 +00:00
let mut router = Router::<()>::new();
router.register_resource(Resource::new(ResourceDef::new("/{value}/")));
let req = TestRequest::with_uri("/32/").finish();
let info = router.recognize(&req, &(), 0);
2018-06-25 04:58:04 +00:00
let req = req.with_route_info(info);
assert_eq!(*Path::<i8>::from_request(&req, &()).unwrap(), 32);
}
#[test]
fn test_tuple_extract() {
2018-07-15 09:12:21 +00:00
let mut router = Router::<()>::new();
router.register_resource(Resource::new(ResourceDef::new("/{key}/{value}/")));
let req = TestRequest::with_uri("/name/user1/?id=test").finish();
let info = router.recognize(&req, &(), 0);
2018-06-25 04:58:04 +00:00
let req = req.with_route_info(info);
let res = match <(Path<(String, String)>,)>::extract(&req).poll() {
Ok(Async::Ready(res)) => res,
_ => panic!("error"),
};
assert_eq!((res.0).0, "name");
assert_eq!((res.0).1, "user1");
let res = match <(Path<(String, String)>, Path<(String, String)>)>::extract(&req)
.poll()
{
Ok(Async::Ready(res)) => res,
_ => panic!("error"),
};
assert_eq!((res.0).0, "name");
assert_eq!((res.0).1, "user1");
assert_eq!((res.1).0, "name");
assert_eq!((res.1).1, "user1");
}
}