409/axum-valid
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

build(deps): update axum requirement from 0.6.x to 0.7.x

Browse Source
This commit is contained in:
gengteng
2023-11-28 16:38:58 +08:00
parent 27d42b35e4
commit e8888c75e9
23 changed files with 289 additions and 927 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
src/extra.rs
View File

@@ -123,14 +123,16 @@
//!
//! # #[tokio::main]
//! # async fn main() -> anyhow::Result<()> {
//! # use std::net::SocketAddr;
//! # use axum::Router;
//! # use tokio::net::TcpListener;
//! # let router = Router::new();
//! # #[cfg(feature = "validator")]
//! # let router = router.nest("/validator", validator_example::router());
//! # #[cfg(feature = "garde")]
//! # let router = router.nest("/garde", garde_example::router());
//! # axum::Server::bind(&([0u8, 0, 0, 0], 8080).into())
//! # .serve(router.into_make_service())
//! # let listener = TcpListener::bind(&SocketAddr::from(([0u8, 0, 0, 0], 0u16))).await?;
//! # axum::serve(listener, router.into_make_service())
//! # .await?;
//! # Ok(())
//! # }
@@ -255,14 +257,16 @@
//!
//! # #[tokio::main]
//! # async fn main() -> anyhow::Result<()> {
//! # use std::net::SocketAddr;
//! # use axum::Router;
//! # use tokio::net::TcpListener;
//! # let router = Router::new();
//! # #[cfg(feature = "validator")]
//! # let router = router.nest("/validator", validator_example::router());
//! # #[cfg(feature = "garde")]
//! # let router = router.nest("/garde", garde_example::router());
//! # axum::Server::bind(&([0u8, 0, 0, 0], 8080).into())
//! # .serve(router.into_make_service())
//! # let listener = TcpListener::bind(&SocketAddr::from(([0u8, 0, 0, 0], 0u16))).await?;
//! # axum::serve(listener, router.into_make_service())
//! # .await?;
//! # Ok(())
//! # }

9
src/extra/form.rs
View File

@@ -70,14 +70,16 @@
//!
//! # #[tokio::main]
//! # async fn main() -> anyhow::Result<()> {
//! # use std::net::SocketAddr;
//! # use axum::Router;
//! # use tokio::net::TcpListener;
//! # let router = Router::new();
//! # #[cfg(feature = "validator")]
//! # let router = router.nest("/validator", validator_example::router());
//! # #[cfg(feature = "garde")]
//! # let router = router.nest("/garde", garde_example::router());
//! # axum::Server::bind(&([0u8, 0, 0, 0], 8080).into())
//! # .serve(router.into_make_service())
//! # let listener = TcpListener::bind(&SocketAddr::from(([0u8, 0, 0, 0], 0u16))).await?;
//! # axum::serve(listener, router.into_make_service())
//! # .await?;
//! # Ok(())
//! # }
@@ -135,8 +137,9 @@ impl<T: validify::Validify> crate::HasValidify for Form<T> {
#[cfg(test)]
mod tests {
use crate::tests::{ValidTest, ValidTestParameter};
use axum::http::StatusCode;
use axum_extra::extract::Form;
use reqwest::{RequestBuilder, StatusCode};
use reqwest::RequestBuilder;
use serde::Serialize;
impl<T: ValidTestParameter + Serialize> ValidTest for Form<T> {

6
src/extra/protobuf.rs
View File

@@ -74,14 +74,16 @@
//!
//! # #[tokio::main]
//! # async fn main() -> anyhow::Result<()> {
//! # use std::net::SocketAddr;
//! # use axum::Router;
//! # use tokio::net::TcpListener;
//! # let router = Router::new();
//! # #[cfg(feature = "validator")]
//! # let router = router.nest("/validator", validator_example::router());
//! # #[cfg(feature = "garde")]
//! # let router = router.nest("/garde", garde_example::router());
//! # axum::Server::bind(&([0u8, 0, 0, 0], 8080).into())
//! # .serve(router.into_make_service())
//! # let listener = TcpListener::bind(&SocketAddr::from(([0u8, 0, 0, 0], 0u16))).await?;
//! # axum::serve(listener, router.into_make_service())
//! # .await?;
//! # Ok(())
//! # }

6
src/extra/query.rs
View File

@@ -70,14 +70,16 @@
//!
//! # #[tokio::main]
//! # async fn main() -> anyhow::Result<()> {
//! # use std::net::SocketAddr;
//! # use axum::Router;
//! # use tokio::net::TcpListener;
//! # let router = Router::new();
//! # #[cfg(feature = "validator")]
//! # let router = router.nest("/validator", validator_example::router());
//! # #[cfg(feature = "garde")]
//! # let router = router.nest("/garde", garde_example::router());
//! # axum::Server::bind(&([0u8, 0, 0, 0], 8080).into())
//! # .serve(router.into_make_service())
//! # let listener = TcpListener::bind(&SocketAddr::from(([0u8, 0, 0, 0], 0u16))).await?;
//! # axum::serve(listener, router.into_make_service())
//! # .await?;
//! # Ok(())
//! # }

6
src/extra/typed_path.rs
View File

@@ -82,14 +82,16 @@
//!
//! # #[tokio::main]
//! # async fn main() -> anyhow::Result<()> {
//! # use std::net::SocketAddr;
//! # use axum::Router;
//! # use tokio::net::TcpListener;
//! # let router = Router::new();
//! # #[cfg(feature = "validator")]
//! # let router = router.nest("/validator", validator_example::router());
//! # #[cfg(feature = "garde")]
//! # let router = router.nest("/garde", garde_example::router());
//! # axum::Server::bind(&([0u8, 0, 0, 0], 8080).into())
//! # .serve(router.into_make_service())
//! # let listener = TcpListener::bind(&SocketAddr::from(([0u8, 0, 0, 0], 0u16))).await?;
//! # axum::serve(listener, router.into_make_service())
//! # .await?;
//! # Ok(())
//! # }

6
src/form.rs
View File

@@ -70,14 +70,16 @@
//!
//! # #[tokio::main]
//! # async fn main() -> anyhow::Result<()> {
//! # use std::net::SocketAddr;
//! # use axum::Router;
//! # use tokio::net::TcpListener;
//! # let router = Router::new();
//! # #[cfg(feature = "validator")]
//! # let router = router.nest("/validator", validator_example::router());
//! # #[cfg(feature = "garde")]
//! # let router = router.nest("/garde", garde_example::router());
//! # axum::Server::bind(&([0u8, 0, 0, 0], 8080).into())
//! # .serve(router.into_make_service())
//! # let listener = TcpListener::bind(&SocketAddr::from(([0u8, 0, 0, 0], 0u16))).await?;
//! # axum::serve(listener, router.into_make_service())
//! # .await?;
//! # Ok(())
//! # }

12
src/garde.rs
View File

@@ -10,9 +10,8 @@ pub mod test;
use crate::{HasValidate, ValidationRejection};
use axum::async_trait;
use axum::extract::{FromRef, FromRequest, FromRequestParts};
use axum::extract::{FromRef, FromRequest, FromRequestParts, Request};
use axum::http::request::Parts;
use axum::http::Request;
use garde::{Report, Validate};
use std::fmt::{Display, Formatter};
use std::ops::{Deref, DerefMut};
@@ -69,17 +68,16 @@ impl<E> From<Report> for GardeRejection<E> {
}
#[async_trait]
impl<State, Body, Extractor, Context> FromRequest<State, Body> for Garde<Extractor>
impl<State, Extractor, Context> FromRequest<State> for Garde<Extractor>
where
State: Send + Sync,
Body: Send + Sync + 'static,
Context: Send + Sync + FromRef<State>,
Extractor: HasValidate + FromRequest<State, Body>,
Extractor: HasValidate + FromRequest<State>,
<Extractor as HasValidate>::Validate: garde::Validate<Context = Context>,
{
type Rejection = GardeRejection<<Extractor as FromRequest<State, Body>>::Rejection>;
type Rejection = GardeRejection<<Extractor as FromRequest<State>>::Rejection>;
async fn from_request(req: Request<Body>, state: &State) -> Result<Self, Self::Rejection> {
async fn from_request(req: Request, state: &State) -> Result<Self, Self::Rejection> {
let context: Context = FromRef::from_ref(state);
let inner = Extractor::from_request(req, state)
.await

65
src/garde/test.rs
View File

@@ -3,16 +3,18 @@
use crate::tests::{ValidTest, ValidTestParameter};
use crate::{Garde, HasValidate, VALIDATION_ERROR_STATUS};
use axum::extract::{FromRef, Path, Query};
use axum::http::StatusCode;
use axum::routing::{get, post};
use axum::{Form, Json, Router};
use garde::Validate;
use hyper::Method;
use once_cell::sync::Lazy;
use reqwest::{StatusCode, Url};
use reqwest::Url;
use serde::{Deserialize, Serialize};
use std::any::type_name;
use std::net::SocketAddr;
use std::ops::Deref;
use tokio::net::TcpListener;
#[derive(Clone, Deserialize, Serialize, Validate, Eq, PartialEq)]
#[cfg_attr(feature = "extra_protobuf", derive(prost::Message))]
@@ -140,15 +142,14 @@ async fn test_main() -> anyhow::Result<()> {
let router = router.with_state(MyState::default());
let server = axum::Server::bind(&SocketAddr::from(([0u8, 0, 0, 0], 0u16)))
.serve(router.into_make_service());
let server_addr = server.local_addr();
let listener = TcpListener::bind(&SocketAddr::from(([0u8, 0, 0, 0], 0u16))).await?;
let server_addr = listener.local_addr()?;
let server = axum::serve(listener, router.into_make_service());
println!("Axum server address: {}.", server_addr);
let (server_guard, close) = tokio::sync::oneshot::channel::<()>();
let server_handle = tokio::spawn(server.with_graceful_shutdown(async move {
let _ = close.await;
}));
tokio::spawn(async move {
let _ = server.await;
});
let server_url = format!("http://{}", server_addr);
let test_executor = TestExecutor::from(Url::parse(&format!("http://{}", server_addr))?);
@@ -168,8 +169,8 @@ async fn test_main() -> anyhow::Result<()> {
.send()
.await?;
assert_eq!(
valid_path_response.status(),
StatusCode::OK,
valid_path_response.status().as_u16(),
StatusCode::OK.as_u16(),
"Valid '{}' test failed.",
path_type_name
);
@@ -180,8 +181,8 @@ async fn test_main() -> anyhow::Result<()> {
.send()
.await?;
assert_eq!(
error_path_response.status(),
StatusCode::BAD_REQUEST,
error_path_response.status().as_u16(),
StatusCode::BAD_REQUEST.as_u16(),
"Error '{}' test failed.",
path_type_name
);
@@ -195,8 +196,8 @@ async fn test_main() -> anyhow::Result<()> {
.send()
.await?;
assert_eq!(
invalid_path_response.status(),
VALIDATION_ERROR_STATUS,
invalid_path_response.status().as_u16(),
VALIDATION_ERROR_STATUS.as_u16(),
"Invalid '{}' test failed.",
path_type_name
);
@@ -225,7 +226,7 @@ async fn test_main() -> anyhow::Result<()> {
#[cfg(feature = "typed_header")]
{
use axum::TypedHeader;
use axum_extra::typed_header::TypedHeader;
// Garde
test_executor
.execute::<TypedHeader<ParametersGarde>>(
@@ -296,8 +297,8 @@ async fn test_main() -> anyhow::Result<()> {
.send()
.await?;
assert_eq!(
valid_extra_typed_path_response.status(),
StatusCode::OK,
valid_extra_typed_path_response.status().as_u16(),
StatusCode::OK.as_u16(),
"Garde '{}' test failed.",
extra_typed_path_type_name
);
@@ -308,8 +309,8 @@ async fn test_main() -> anyhow::Result<()> {
.send()
.await?;
assert_eq!(
error_extra_typed_path_response.status(),
StatusCode::BAD_REQUEST,
error_extra_typed_path_response.status().as_u16(),
StatusCode::BAD_REQUEST.as_u16(),
"Error '{}' test failed.",
extra_typed_path_type_name
);
@@ -323,8 +324,8 @@ async fn test_main() -> anyhow::Result<()> {
.send()
.await?;
assert_eq!(
invalid_extra_typed_path_response.status(),
VALIDATION_ERROR_STATUS,
invalid_extra_typed_path_response.status().as_u16(),
VALIDATION_ERROR_STATUS.as_u16(),
"Invalid '{}' test failed.",
extra_typed_path_type_name
);
@@ -387,8 +388,6 @@ async fn test_main() -> anyhow::Result<()> {
.await?;
}
drop(server_guard);
server_handle.await??;
Ok(())
}
@@ -421,8 +420,8 @@ impl TestExecutor {
let valid_builder = self.client.request(method.clone(), url.clone());
let valid_response = T::set_valid_request(valid_builder).send().await?;
assert_eq!(
valid_response.status(),
StatusCode::OK,
valid_response.status().as_u16(),
StatusCode::OK.as_u16(),
"Garde '{}' test failed.",
type_name
);
@@ -430,8 +429,8 @@ impl TestExecutor {
let error_builder = self.client.request(method.clone(), url.clone());
let error_response = T::set_error_request(error_builder).send().await?;
assert_eq!(
error_response.status(),
T::ERROR_STATUS_CODE,
error_response.status().as_u16(),
T::ERROR_STATUS_CODE.as_u16(),
"Error '{}' test failed.",
type_name
);
@@ -439,8 +438,8 @@ impl TestExecutor {
let invalid_builder = self.client.request(method, url);
let invalid_response = T::set_invalid_request(invalid_builder).send().await?;
assert_eq!(
invalid_response.status(),
T::INVALID_STATUS_CODE,
invalid_response.status().as_u16(),
T::INVALID_STATUS_CODE.as_u16(),
"Invalid '{}' test failed.",
type_name
);
@@ -463,8 +462,8 @@ impl TestExecutor {
#[cfg(feature = "into_json")]
pub async fn check_json(type_name: &'static str, response: reqwest::Response) {
assert_eq!(
response.headers()[axum::http::header::CONTENT_TYPE],
axum::http::HeaderValue::from_static(mime::APPLICATION_JSON.as_ref()),
response.headers()[reqwest::header::CONTENT_TYPE],
reqwest::header::HeaderValue::from_static(mime::APPLICATION_JSON.as_ref()),
"'{}' rejection into json test failed",
type_name
);
@@ -514,9 +513,9 @@ mod typed_header {
use super::{validate_again, ParametersGarde};
use crate::Garde;
use axum::headers::{Error, Header, HeaderName, HeaderValue};
use axum::http::StatusCode;
use axum::TypedHeader;
use axum_extra::headers::{Error, Header, HeaderName, HeaderValue};
use axum_extra::typed_header::TypedHeader;
pub static AXUM_VALID_PARAMETERS: HeaderName = HeaderName::from_static("axum-valid-parameters");

6
src/json.rs
View File

@@ -70,14 +70,16 @@
//!
//! # #[tokio::main]
//! # async fn main() -> anyhow::Result<()> {
//! # use std::net::SocketAddr;
//! # use axum::Router;
//! # use tokio::net::TcpListener;
//! # let router = Router::new();
//! # #[cfg(feature = "validator")]
//! # let router = router.nest("/validator", validator_example::router());
//! # #[cfg(feature = "garde")]
//! # let router = router.nest("/garde", garde_example::router());
//! # axum::Server::bind(&([0u8, 0, 0, 0], 8080).into())
//! # .serve(router.into_make_service())
//! # let listener = TcpListener::bind(&SocketAddr::from(([0u8, 0, 0, 0], 0u16))).await?;
//! # axum::serve(listener, router.into_make_service())
//! # .await?;
//! # Ok(())
//! # }

9
src/lib.rs
View File

@@ -9,21 +9,15 @@ pub mod form;
pub mod garde;
#[cfg(feature = "json")]
pub mod json;
#[cfg(feature = "msgpack")]
pub mod msgpack;
pub mod path;
#[cfg(feature = "query")]
pub mod query;
#[cfg(feature = "typed_header")]
pub mod typed_header;
#[cfg(feature = "typed_multipart")]
pub mod typed_multipart;
#[cfg(feature = "validator")]
pub mod validator;
#[cfg(feature = "validify")]
pub mod validify;
#[cfg(feature = "yaml")]
pub mod yaml;
use axum::http::StatusCode;
use axum::response::{IntoResponse, Response};
@@ -117,7 +111,8 @@ impl<V: Display, E: IntoResponse> IntoResponse for ValidationRejection<V, E> {
#[cfg(test)]
mod tests {
use reqwest::{RequestBuilder, StatusCode};
use axum::http::StatusCode;
use reqwest::RequestBuilder;
/// # Valid test parameter
pub trait ValidTestParameter: 'static {

263
src/msgpack.rs
View File

@@ -1,263 +0,0 @@
//! # Support for `MsgPack<T>` and `MsgPackRaw<T>` from `axum-msgpack`
//!
//! ## Feature
//!
//! Enable the `msgpack` feature to use `Valid<MsgPack<T>>` and `Valid<MsgPackRaw<T>>`.
//!
//! ## Usage
//!
//! 1. Implement `Deserialize` and `Validate` for your data type `T`.
//! 2. In your handler function, use `Valid<MsgPack<T>>` or `Valid<MsgPackRaw<T>>` as some parameter's type.
//!
//! ## Example
//!
//! ```no_run
//! #[cfg(feature = "validator")]
//! mod validator_example {
//! use axum::routing::post;
//! use axum::Json;
//! use axum::Router;
//! use axum_msgpack::{MsgPack, MsgPackRaw};
//! use axum_valid::Valid;
//! use serde::Deserialize;
//! use validator::Validate;
//!
//! pub fn router() -> Router {
//! Router::new()
//! .route("/msgpack", post(handler))
//! .route("/msgpackraw", post(raw_handler))
//! }
//! async fn handler(Valid(MsgPack(parameter)): Valid<MsgPack<Parameter>>) {
//! assert!(parameter.validate().is_ok());
//! }
//!
//! async fn raw_handler(Valid(MsgPackRaw(parameter)): Valid<MsgPackRaw<Parameter>>) {
//! assert!(parameter.validate().is_ok());
//! }
//! #[derive(Validate, Deserialize)]
//! pub struct Parameter {
//! #[validate(range(min = 5, max = 10))]
//! pub v0: i32,
//! #[validate(length(min = 1, max = 10))]
//! pub v1: String,
//! }
//! }
//!
//! #[cfg(feature = "garde")]
//! mod garde_example {
//! use axum::routing::post;
//! use axum::Router;
//! use axum_msgpack::{MsgPack, MsgPackRaw};
//! use axum_valid::Garde;
//! use serde::Deserialize;
//! use garde::Validate;
//!
//! pub fn router() -> Router {
//! Router::new()
//! .route("/msgpack", post(handler))
//! .route("/msgpackraw", post(raw_handler))
//! }
//!
//! async fn handler(Garde(MsgPack(parameter)): Garde<MsgPack<Parameter>>) {
//! assert!(parameter.validate(&()).is_ok());
//! }
//!
//! async fn raw_handler(Garde(MsgPackRaw(parameter)): Garde<MsgPackRaw<Parameter>>) {
//! assert!(parameter.validate(&()).is_ok());
//! }
//! #[derive(Validate, Deserialize)]
//! pub struct Parameter {
//! #[garde(range(min = 5, max = 10))]
//! pub v0: i32,
//! #[garde(length(min = 1, max = 10))]
//! pub v1: String,
//! }
//! }
//!
//! # #[tokio::main]
//! # async fn main() -> anyhow::Result<()> {
//! # use axum::Router;
//! # let router = Router::new();
//! # #[cfg(feature = "validator")]
//! # let router = router.nest("/validator", validator_example::router());
//! # #[cfg(feature = "garde")]
//! # let router = router.nest("/garde", garde_example::router());
//! # axum::Server::bind(&([0u8, 0, 0, 0], 8080).into())
//! # .serve(router.into_make_service())
//! # .await?;
//! # Ok(())
//! # }
//! ```
//!
use crate::HasValidate;
#[cfg(feature = "validator")]
use crate::HasValidateArgs;
use axum_msgpack::{MsgPack, MsgPackRaw};
#[cfg(feature = "validator")]
use validator::ValidateArgs;
impl<T> HasValidate for MsgPack<T> {
type Validate = T;
fn get_validate(&self) -> &T {
&self.0
}
}
#[cfg(feature = "validator")]
impl<'v, T: ValidateArgs<'v>> HasValidateArgs<'v> for MsgPack<T> {
type ValidateArgs = T;
fn get_validate_args(&self) -> &Self::ValidateArgs {
&self.0
}
}
#[cfg(feature = "validify")]
impl<T: validify::Modify> crate::HasModify for MsgPack<T> {
type Modify = T;
fn get_modify(&mut self) -> &mut Self::Modify {
&mut self.0
}
}
#[cfg(feature = "validify")]
impl<T> crate::PayloadExtractor for MsgPack<T> {
type Payload = T;
fn get_payload(self) -> Self::Payload {
self.0
}
}
#[cfg(feature = "validify")]
impl<T: validify::Validify> crate::HasValidify for MsgPack<T> {
type Validify = T;
type PayloadExtractor = MsgPack<T::Payload>;
fn from_validified(v: Self::Validify) -> Self {
MsgPack(v)
}
}
impl<T> HasValidate for MsgPackRaw<T> {
type Validate = T;
fn get_validate(&self) -> &T {
&self.0
}
}
#[cfg(feature = "validator")]
impl<'v, T: ValidateArgs<'v>> HasValidateArgs<'v> for MsgPackRaw<T> {
type ValidateArgs = T;
fn get_validate_args(&self) -> &Self::ValidateArgs {
&self.0
}
}
#[cfg(feature = "validify")]
impl<T: validify::Modify> crate::HasModify for MsgPackRaw<T> {
type Modify = T;
fn get_modify(&mut self) -> &mut Self::Modify {
&mut self.0
}
}
#[cfg(feature = "validify")]
impl<T> crate::PayloadExtractor for MsgPackRaw<T> {
type Payload = T;
fn get_payload(self) -> Self::Payload {
self.0
}
}
#[cfg(feature = "validify")]
impl<T: validify::Validify> crate::HasValidify for MsgPackRaw<T> {
type Validify = T;
type PayloadExtractor = MsgPackRaw<T::Payload>;
fn from_validified(v: Self::Validify) -> Self {
MsgPackRaw(v)
}
}
#[cfg(test)]
mod tests {
use crate::tests::{ValidTest, ValidTestParameter};
use axum::http::StatusCode;
use axum_msgpack::{MsgPack, MsgPackRaw};
use reqwest::RequestBuilder;
use serde::Serialize;
impl<T: ValidTestParameter + Serialize> ValidTest for MsgPack<T> {
const ERROR_STATUS_CODE: StatusCode = StatusCode::BAD_REQUEST;
fn set_valid_request(builder: RequestBuilder) -> RequestBuilder {
builder
.header(reqwest::header::CONTENT_TYPE, "application/msgpack")
.body(
rmp_serde::to_vec_named(T::valid())
.expect("Failed to serialize parameters to msgpack"),
)
}
fn set_error_request(builder: RequestBuilder) -> RequestBuilder {
#[derive(Serialize, Default)]
struct ErrorData {
error_field0: i32,
error_field1: Option<String>,
}
builder
.header(reqwest::header::CONTENT_TYPE, "application/msgpack")
.body(
rmp_serde::to_vec(&ErrorData::default())
.expect("Failed to serialize parameters to msgpack"),
)
}
fn set_invalid_request(builder: RequestBuilder) -> RequestBuilder {
builder
.header(reqwest::header::CONTENT_TYPE, "application/msgpack")
.body(
rmp_serde::to_vec_named(T::invalid())
.expect("Failed to serialize parameters to msgpack"),
)
}
}
impl<T: ValidTestParameter + Serialize> ValidTest for MsgPackRaw<T> {
const ERROR_STATUS_CODE: StatusCode = StatusCode::BAD_REQUEST;
fn set_valid_request(builder: RequestBuilder) -> RequestBuilder {
builder
.header(reqwest::header::CONTENT_TYPE, "application/msgpack")
.body(
rmp_serde::to_vec(T::valid())
.expect("Failed to serialize parameters to msgpack"),
)
}
fn set_error_request(builder: RequestBuilder) -> RequestBuilder {
#[derive(Serialize, Default)]
struct ErrorData {
error_field0: i32,
error_field1: Option<String>,
}
builder
.header(reqwest::header::CONTENT_TYPE, "application/msgpack")
.body(
rmp_serde::to_vec(&ErrorData::default())
.expect("Failed to serialize parameters to msgpack"),
)
}
fn set_invalid_request(builder: RequestBuilder) -> RequestBuilder {
builder
.header(reqwest::header::CONTENT_TYPE, "application/msgpack")
.body(
rmp_serde::to_vec(T::invalid())
.expect("Failed to serialize parameters to msgpack"),
)
}
}
}

6
src/path.rs
View File

@@ -66,14 +66,16 @@
//!
//! # #[tokio::main]
//! # async fn main() -> anyhow::Result<()> {
//! # use std::net::SocketAddr;
//! # use axum::Router;
//! # use tokio::net::TcpListener;
//! # let router = Router::new();
//! # #[cfg(feature = "validator")]
//! # let router = router.nest("/validator", validator_example::router());
//! # #[cfg(feature = "garde")]
//! # let router = router.nest("/garde", garde_example::router());
//! # axum::Server::bind(&([0u8, 0, 0, 0], 8080).into())
//! # .serve(router.into_make_service())
//! # let listener = TcpListener::bind(&SocketAddr::from(([0u8, 0, 0, 0], 0u16))).await?;
//! # axum::serve(listener, router.into_make_service())
//! # .await?;
//! # Ok(())
//! # }

6
src/query.rs
View File

@@ -70,14 +70,16 @@
//!
//! # #[tokio::main]
//! # async fn main() -> anyhow::Result<()> {
//! # use std::net::SocketAddr;
//! # use axum::Router;
//! # use tokio::net::TcpListener;
//! # let router = Router::new();
//! # #[cfg(feature = "validator")]
//! # let router = router.nest("/validator", validator_example::router());
//! # #[cfg(feature = "garde")]
//! # let router = router.nest("/garde", garde_example::router());
//! # axum::Server::bind(&([0u8, 0, 0, 0], 8080).into())
//! # .serve(router.into_make_service())
//! # let listener = TcpListener::bind(&SocketAddr::from(([0u8, 0, 0, 0], 0u16))).await?;
//! # axum::serve(listener, router.into_make_service())
//! # .await?;
//! # Ok(())
//! # }

40
src/typed_header.rs
View File

@@ -14,10 +14,11 @@
//! ```no_run
//! #[cfg(feature = "validator")]
//! mod validator_example {
//! use axum::headers::{Error, Header, HeaderValue};
//! use axum_extra::headers::{Error, Header, HeaderValue};
//! use axum_extra::typed_header::TypedHeader;
//! use axum::http::HeaderName;
//! use axum::routing::post;
//! use axum::{Router, TypedHeader};
//! use axum::Router;
//! use axum_valid::Valid;
//! use validator::Validate;
//!
@@ -60,10 +61,11 @@
//!
//! #[cfg(feature = "garde")]
//! mod garde_example {
//! use axum::headers::{Error, Header, HeaderValue};
//! use axum_extra::headers::{Error, Header, HeaderValue};
//! use axum_extra::typed_header::TypedHeader;
//! use axum::http::HeaderName;
//! use axum::routing::post;
//! use axum::{Router, TypedHeader};
//! use axum::Router;
//! use axum_valid::Garde;
//! use garde::Validate;
//!
@@ -106,14 +108,16 @@
//!
//! # #[tokio::main]
//! # async fn main() -> anyhow::Result<()> {
//! # use std::net::SocketAddr;
//! # use axum::Router;
//! # use tokio::net::TcpListener;
//! # let router = Router::new();
//! # #[cfg(feature = "validator")]
//! # let router = router.nest("/validator", validator_example::router());
//! # #[cfg(feature = "garde")]
//! # let router = router.nest("/garde", garde_example::router());
//! # axum::Server::bind(&([0u8, 0, 0, 0], 8080).into())
//! # .serve(router.into_make_service())
//! # let listener = TcpListener::bind(&SocketAddr::from(([0u8, 0, 0, 0], 0u16))).await?;
//! # axum::serve(listener, router.into_make_service())
//! # .await?;
//! # Ok(())
//! # }
@@ -122,7 +126,7 @@
use crate::HasValidate;
#[cfg(feature = "validator")]
use crate::HasValidateArgs;
use axum::TypedHeader;
use axum_extra::typed_header::TypedHeader;
#[cfg(feature = "validator")]
use validator::ValidateArgs;
@@ -153,18 +157,24 @@ impl<T: validify::Modify> crate::HasModify for TypedHeader<T> {
#[cfg(test)]
mod tests {
use crate::tests::{ValidTest, ValidTestParameter};
use axum::headers::{Header, HeaderMapExt};
use axum::http::StatusCode;
use axum::TypedHeader;
use reqwest::header::HeaderMap;
use axum_extra::headers::Header;
use axum_extra::typed_header::TypedHeader;
use reqwest::header::{HeaderMap, HeaderValue};
use reqwest::RequestBuilder;
impl<T: ValidTestParameter + Header + Clone> ValidTest for TypedHeader<T> {
const ERROR_STATUS_CODE: StatusCode = StatusCode::BAD_REQUEST;
fn set_valid_request(builder: RequestBuilder) -> RequestBuilder {
let mut vec = Vec::new();
T::valid().encode(&mut vec);
let hv = vec.pop().unwrap();
let mut headers = HeaderMap::default();
headers.typed_insert(T::valid().clone());
headers.insert(
T::name().as_str(),
HeaderValue::from_bytes(hv.as_bytes()).unwrap(),
);
builder.headers(headers)
}
@@ -173,8 +183,14 @@ mod tests {
}
fn set_invalid_request(builder: RequestBuilder) -> RequestBuilder {
let mut vec = Vec::new();
T::invalid().encode(&mut vec);
let hv = vec.pop().unwrap();
let mut headers = HeaderMap::default();
headers.typed_insert(T::invalid().clone());
headers.insert(
T::name().as_str(),
HeaderValue::from_bytes(hv.as_bytes()).unwrap(),
);
builder.headers(headers)
}
}

205
src/typed_multipart.rs
View File

@@ -1,205 +0,0 @@
//! # Support for `TypedMultipart<T>` and `BaseMultipart<T, R>` from `axum_typed_multipart`
//!
//! ## Feature
//!
//! Enable the `typed_multipart` feature to use `Valid<TypedMultipart<T>>` and `Valid<BaseMultipart<T, R>>`.
//!
//! ## Usage
//!
//! 1. Implement `TryFromMultipart` and `Validate` for your data type `T`.
//! 2. In your handler function, use `Valid<TypedMultipart<T>>` or `Valid<BaseMultipart<T, E>` as some parameter's type.
//!
//! ## Example
//!
//! ```no_run
//! #[cfg(feature = "validator")]
//! mod validator_example {
//! use axum::routing::post;
//! use axum::Router;
//! use axum_typed_multipart::{BaseMultipart, TryFromMultipart, TypedMultipart, TypedMultipartError};
//! use axum_valid::Valid;
//! use validator::Validate;
//!
//! pub fn router() -> Router {
//! Router::new()
//! .route("/typed_multipart", post(handler))
//! .route("/base_multipart", post(base_handler))
//! }
//!
//! async fn handler(Valid(TypedMultipart(parameter)): Valid<TypedMultipart<Parameter>>) {
//! assert!(parameter.validate().is_ok());
//! // Support automatic dereferencing
//! println!("v0 = {}, v1 = {}", parameter.v0, parameter.v1);
//! }
//!
//! async fn base_handler(
//! Valid(BaseMultipart {
//! data: parameter, ..
//! }): Valid<BaseMultipart<Parameter, TypedMultipartError>>,
//! ) {
//! assert!(parameter.validate().is_ok());
//! }
//!
//! #[derive(TryFromMultipart, Validate)]
//! struct Parameter {
//! #[validate(range(min = 5, max = 10))]
//! v0: i32,
//! #[validate(length(min = 1, max = 10))]
//! v1: String,
//! }
//! }
//!
//! #[cfg(feature = "garde")]
//! mod garde_example {
//! use axum::routing::post;
//! use axum::Router;
//! use axum_typed_multipart::{BaseMultipart, TryFromMultipart, TypedMultipart, TypedMultipartError};
//! use axum_valid::Garde;
//! use serde::Deserialize;
//! use garde::Validate;
//!
//! pub fn router() -> Router {
//! Router::new()
//! .route("/typed_multipart", post(handler))
//! .route("/base_multipart", post(base_handler))
//! }
//!
//! async fn handler(Garde(TypedMultipart(parameter)): Garde<TypedMultipart<Parameter>>) {
//! assert!(parameter.validate(&()).is_ok());
//! // Support automatic dereferencing
//! println!("v0 = {}, v1 = {}", parameter.v0, parameter.v1);
//! }
//!
//! async fn base_handler(
//! Garde(BaseMultipart {
//! data: parameter, ..
//! }): Garde<BaseMultipart<Parameter, TypedMultipartError>>,
//! ) {
//! assert!(parameter.validate(&()).is_ok());
//! }
//!
//! #[derive(TryFromMultipart, Validate)]
//! pub struct Parameter {
//! #[garde(range(min = 5, max = 10))]
//! pub v0: i32,
//! #[garde(length(min = 1, max = 10))]
//! pub v1: String,
//! }
//! }
//!
//! # #[tokio::main]
//! # async fn main() -> anyhow::Result<()> {
//! # use axum::Router;
//! # let router = Router::new();
//! # #[cfg(feature = "validator")]
//! # let router = router.nest("/validator", validator_example::router());
//! # #[cfg(feature = "garde")]
//! # let router = router.nest("/garde", garde_example::router());
//! # axum::Server::bind(&([0u8, 0, 0, 0], 8080).into())
//! # .serve(router.into_make_service())
//! # .await?;
//! # Ok(())
//! # }
//! ```
use crate::HasValidate;
#[cfg(feature = "validator")]
use crate::HasValidateArgs;
use axum_typed_multipart::{BaseMultipart, TypedMultipart};
#[cfg(feature = "validator")]
use validator::ValidateArgs;
impl<T, R> HasValidate for BaseMultipart<T, R> {
type Validate = T;
fn get_validate(&self) -> &T {
&self.data
}
}
#[cfg(feature = "validator")]
impl<'v, T: ValidateArgs<'v>, R> HasValidateArgs<'v> for BaseMultipart<T, R> {
type ValidateArgs = T;
fn get_validate_args(&self) -> &Self::ValidateArgs {
&self.data
}
}
#[cfg(feature = "validify")]
impl<T: validify::Modify, R> crate::HasModify for BaseMultipart<T, R> {
type Modify = T;
fn get_modify(&mut self) -> &mut Self::Modify {
&mut self.data
}
}
impl<T> HasValidate for TypedMultipart<T> {
type Validate = T;
fn get_validate(&self) -> &T {
&self.0
}
}
#[cfg(feature = "validator")]
impl<'v, T: ValidateArgs<'v>> HasValidateArgs<'v> for TypedMultipart<T> {
type ValidateArgs = T;
fn get_validate_args(&self) -> &Self::ValidateArgs {
&self.0
}
}
#[cfg(feature = "validify")]
impl<T: validify::Modify> crate::HasModify for TypedMultipart<T> {
type Modify = T;
fn get_modify(&mut self) -> &mut Self::Modify {
&mut self.0
}
}
#[cfg(test)]
mod tests {
use crate::tests::{ValidTest, ValidTestParameter};
use axum::http::StatusCode;
use axum_typed_multipart::{BaseMultipart, TypedMultipart};
use reqwest::multipart::Form;
use reqwest::RequestBuilder;
impl<T: ValidTestParameter, R> ValidTest for BaseMultipart<T, R>
where
Form: From<&'static T>,
{
const ERROR_STATUS_CODE: StatusCode = StatusCode::BAD_REQUEST;
fn set_valid_request(builder: RequestBuilder) -> RequestBuilder {
builder.multipart(Form::from(T::valid()))
}
fn set_error_request(builder: RequestBuilder) -> RequestBuilder {
builder.multipart(Form::new())
}
fn set_invalid_request(builder: RequestBuilder) -> RequestBuilder {
builder.multipart(Form::from(T::invalid()))
}
}
impl<T: ValidTestParameter> ValidTest for TypedMultipart<T>
where
Form: From<&'static T>,
{
const ERROR_STATUS_CODE: StatusCode = StatusCode::BAD_REQUEST;
fn set_valid_request(builder: RequestBuilder) -> RequestBuilder {
builder.multipart(Form::from(T::valid()))
}
fn set_error_request(builder: RequestBuilder) -> RequestBuilder {
builder.multipart(Form::new())
}
fn set_invalid_request(builder: RequestBuilder) -> RequestBuilder {
builder.multipart(Form::from(T::invalid()))
}
}
}

21
src/validator.rs
View File

@@ -10,9 +10,8 @@ pub mod test;
use crate::{HasValidate, ValidationRejection};
use axum::async_trait;
use axum::extract::{FromRef, FromRequest, FromRequestParts};
use axum::extract::{FromRef, FromRequest, FromRequestParts, Request};
use axum::http::request::Parts;
use axum::http::Request;
use std::fmt::Display;
use std::ops::{Deref, DerefMut};
use validator::{Validate, ValidateArgs, ValidationErrors};
@@ -155,16 +154,15 @@ pub trait HasValidateArgs<'v> {
}
#[async_trait]
impl<State, Body, Extractor> FromRequest<State, Body> for Valid<Extractor>
impl<State, Extractor> FromRequest<State> for Valid<Extractor>
where
State: Send + Sync,
Body: Send + Sync + 'static,
Extractor: HasValidate + FromRequest<State, Body>,
Extractor: HasValidate + FromRequest<State>,
Extractor::Validate: Validate,
{
type Rejection = ValidRejection<<Extractor as FromRequest<State, Body>>::Rejection>;
type Rejection = ValidRejection<<Extractor as FromRequest<State>>::Rejection>;
async fn from_request(req: Request<Body>, state: &State) -> Result<Self, Self::Rejection> {
async fn from_request(req: Request, state: &State) -> Result<Self, Self::Rejection> {
let inner = Extractor::from_request(req, state)
.await
.map_err(ValidRejection::Inner)?;
@@ -192,19 +190,18 @@ where
}
#[async_trait]
impl<State, Body, Extractor, Args> FromRequest<State, Body> for ValidEx<Extractor, Args>
impl<State, Extractor, Args> FromRequest<State> for ValidEx<Extractor, Args>
where
State: Send + Sync,
Body: Send + Sync + 'static,
Args: Send
+ Sync
+ FromRef<State>
+ for<'a> Arguments<'a, T = <Extractor as HasValidateArgs<'a>>::ValidateArgs>,
Extractor: for<'v> HasValidateArgs<'v> + FromRequest<State, Body>,
Extractor: for<'v> HasValidateArgs<'v> + FromRequest<State>,
{
type Rejection = ValidRejection<<Extractor as FromRequest<State, Body>>::Rejection>;
type Rejection = ValidRejection<<Extractor as FromRequest<State>>::Rejection>;
async fn from_request(req: Request<Body>, state: &State) -> Result<Self, Self::Rejection> {
async fn from_request(req: Request, state: &State) -> Result<Self, Self::Rejection> {
let arguments: Args = FromRef::from_ref(state);
let inner = Extractor::from_request(req, state)
.await

73
src/validator/test.rs
View File

@@ -3,24 +3,22 @@
use crate::tests::{ValidTest, ValidTestParameter};
use crate::{Arguments, HasValidate, HasValidateArgs, Valid, ValidEx, VALIDATION_ERROR_STATUS};
use axum::extract::{FromRef, Path, Query};
use axum::http::StatusCode;
use axum::routing::{get, post};
use axum::{Form, Json, Router};
use hyper::Method;
use once_cell::sync::Lazy;
use reqwest::{StatusCode, Url};
use reqwest::Url;
use serde::{Deserialize, Serialize};
use std::any::type_name;
use std::net::SocketAddr;
use std::ops::{Deref, RangeInclusive};
use std::sync::Arc;
use tokio::net::TcpListener;
use validator::{Validate, ValidateArgs, ValidationError};
#[derive(Clone, Deserialize, Serialize, Validate, Eq, PartialEq)]
#[cfg_attr(feature = "extra_protobuf", derive(prost::Message))]
#[cfg_attr(
feature = "typed_multipart",
derive(axum_typed_multipart::TryFromMultipart)
)]
pub struct Parameters {
#[validate(range(min = 5, max = 10))]
#[cfg_attr(feature = "extra_protobuf", prost(int32, tag = "1"))]
@@ -32,10 +30,6 @@ pub struct Parameters {
#[derive(Clone, Deserialize, Serialize, Validate, Eq, PartialEq)]
#[cfg_attr(feature = "extra_protobuf", derive(prost::Message))]
#[cfg_attr(
feature = "typed_multipart",
derive(axum_typed_multipart::TryFromMultipart)
)]
pub struct ParametersEx {
#[validate(custom(function = "validate_v0", arg = "&'v_a RangeInclusive<i32>"))]
#[cfg_attr(feature = "extra_protobuf", prost(int32, tag = "1"))]
@@ -271,15 +265,14 @@ async fn test_main() -> anyhow::Result<()> {
let router = router.with_state(state);
let server = axum::Server::bind(&SocketAddr::from(([0u8, 0, 0, 0], 0u16)))
.serve(router.into_make_service());
let server_addr = server.local_addr();
let listener = TcpListener::bind(&SocketAddr::from(([0u8, 0, 0, 0], 0u16))).await?;
let server_addr = listener.local_addr()?;
let server = axum::serve(listener, router.into_make_service());
println!("Axum server address: {}.", server_addr);
let (server_guard, close) = tokio::sync::oneshot::channel::<()>();
let server_handle = tokio::spawn(server.with_graceful_shutdown(async move {
let _ = close.await;
}));
tokio::spawn(async move {
let _ = server.await;
});
let server_url = format!("http://{}", server_addr);
let test_executor = TestExecutor::from(Url::parse(&format!("http://{}", server_addr))?);
@@ -299,8 +292,8 @@ async fn test_main() -> anyhow::Result<()> {
.send()
.await?;
assert_eq!(
valid_path_response.status(),
StatusCode::OK,
valid_path_response.status().as_u16(),
StatusCode::OK.as_u16(),
"Valid '{}' test failed.",
path_type_name
);
@@ -311,8 +304,8 @@ async fn test_main() -> anyhow::Result<()> {
.send()
.await?;
assert_eq!(
error_path_response.status(),
StatusCode::BAD_REQUEST,
error_path_response.status().as_u16(),
StatusCode::BAD_REQUEST.as_u16(),
"Error '{}' test failed.",
path_type_name
);
@@ -326,8 +319,8 @@ async fn test_main() -> anyhow::Result<()> {
.send()
.await?;
assert_eq!(
invalid_path_response.status(),
VALIDATION_ERROR_STATUS,
invalid_path_response.status().as_u16(),
VALIDATION_ERROR_STATUS.as_u16(),
"Invalid '{}' test failed.",
path_type_name
);
@@ -372,7 +365,7 @@ async fn test_main() -> anyhow::Result<()> {
#[cfg(feature = "typed_header")]
{
use axum::TypedHeader;
use axum_extra::typed_header::TypedHeader;
// Valid
test_executor
.execute::<TypedHeader<Parameters>>(Method::POST, typed_header::route::TYPED_HEADER)
@@ -476,8 +469,8 @@ async fn test_main() -> anyhow::Result<()> {
.send()
.await?;
assert_eq!(
valid_extra_typed_path_response.status(),
StatusCode::OK,
valid_extra_typed_path_response.status().as_u16(),
StatusCode::OK.as_u16(),
"Valid '{}' test failed.",
extra_typed_path_type_name
);
@@ -488,8 +481,8 @@ async fn test_main() -> anyhow::Result<()> {
.send()
.await?;
assert_eq!(
error_extra_typed_path_response.status(),
StatusCode::BAD_REQUEST,
error_extra_typed_path_response.status().as_u16(),
StatusCode::BAD_REQUEST.as_u16(),
"Error '{}' test failed.",
extra_typed_path_type_name
);
@@ -503,8 +496,8 @@ async fn test_main() -> anyhow::Result<()> {
.send()
.await?;
assert_eq!(
invalid_extra_typed_path_response.status(),
VALIDATION_ERROR_STATUS,
invalid_extra_typed_path_response.status().as_u16(),
VALIDATION_ERROR_STATUS.as_u16(),
"Invalid '{}' test failed.",
extra_typed_path_type_name
);
@@ -583,8 +576,6 @@ async fn test_main() -> anyhow::Result<()> {
.await?;
}
drop(server_guard);
server_handle.await??;
Ok(())
}
@@ -617,8 +608,8 @@ impl TestExecutor {
let valid_builder = self.client.request(method.clone(), url.clone());
let valid_response = T::set_valid_request(valid_builder).send().await?;
assert_eq!(
valid_response.status(),
StatusCode::OK,
valid_response.status().as_u16(),
StatusCode::OK.as_u16(),
"Valid '{}' test failed.",
type_name
);
@@ -626,8 +617,8 @@ impl TestExecutor {
let error_builder = self.client.request(method.clone(), url.clone());
let error_response = T::set_error_request(error_builder).send().await?;
assert_eq!(
error_response.status(),
T::ERROR_STATUS_CODE,
error_response.status().as_u16(),
T::ERROR_STATUS_CODE.as_u16(),
"Error '{}' test failed.",
type_name
);
@@ -635,8 +626,8 @@ impl TestExecutor {
let invalid_builder = self.client.request(method, url);
let invalid_response = T::set_invalid_request(invalid_builder).send().await?;
assert_eq!(
invalid_response.status(),
T::INVALID_STATUS_CODE,
invalid_response.status().as_u16(),
T::INVALID_STATUS_CODE.as_u16(),
"Invalid '{}' test failed.",
type_name
);
@@ -659,8 +650,8 @@ impl TestExecutor {
#[cfg(feature = "into_json")]
pub async fn check_json(type_name: &'static str, response: reqwest::Response) {
assert_eq!(
response.headers()[axum::http::header::CONTENT_TYPE],
axum::http::HeaderValue::from_static(mime::APPLICATION_JSON.as_ref()),
response.headers()[reqwest::header::CONTENT_TYPE],
reqwest::header::HeaderValue::from_static(mime::APPLICATION_JSON.as_ref()),
"'{}' rejection into json test failed",
type_name
);
@@ -754,9 +745,9 @@ mod typed_header {
use super::{validate_again, Parameters};
use super::{validate_again_ex, ParametersEx, ParametersExValidationArguments};
use crate::{Arguments, Valid, ValidEx};
use axum::headers::{Error, Header, HeaderName, HeaderValue};
use axum::http::StatusCode;
use axum::TypedHeader;
use axum_extra::headers::{Error, Header, HeaderName, HeaderValue};
use axum_extra::typed_header::TypedHeader;
pub static AXUM_VALID_PARAMETERS: HeaderName = HeaderName::from_static("axum-valid-parameters");

39
src/validify.rs
View File

@@ -10,9 +10,8 @@ pub mod test;
use crate::{HasValidate, ValidationRejection};
use axum::async_trait;
use axum::extract::{FromRequest, FromRequestParts};
use axum::extract::{FromRequest, FromRequestParts, Request};
use axum::http::request::Parts;
use axum::http::Request;
use axum::response::{IntoResponse, Response};
use std::fmt::{Display, Formatter};
use std::ops::{Deref, DerefMut};
@@ -241,16 +240,15 @@ pub trait HasValidify: Sized {
}
#[async_trait]
impl<State, Body, Extractor> FromRequest<State, Body> for Validated<Extractor>
impl<State, Extractor> FromRequest<State> for Validated<Extractor>
where
State: Send + Sync,
Body: Send + Sync + 'static,
Extractor: HasValidate + FromRequest<State, Body>,
Extractor: HasValidate + FromRequest<State>,
Extractor::Validate: validify::Validate,
{
type Rejection = ValidifyRejection<<Extractor as FromRequest<State, Body>>::Rejection>;
type Rejection = ValidifyRejection<<Extractor as FromRequest<State>>::Rejection>;
async fn from_request(req: Request<Body>, state: &State) -> Result<Self, Self::Rejection> {
async fn from_request(req: Request, state: &State) -> Result<Self, Self::Rejection> {
let inner = Extractor::from_request(req, state)
.await
.map_err(ValidifyRejection::Inner)?;
@@ -278,15 +276,14 @@ where
}
#[async_trait]
impl<State, Body, Extractor> FromRequest<State, Body> for Modified<Extractor>
impl<State, Extractor> FromRequest<State> for Modified<Extractor>
where
State: Send + Sync,
Body: Send + Sync + 'static,
Extractor: HasModify + FromRequest<State, Body>,
Extractor: HasModify + FromRequest<State>,
{
type Rejection = <Extractor as FromRequest<State, Body>>::Rejection;
type Rejection = <Extractor as FromRequest<State>>::Rejection;
async fn from_request(req: Request<Body>, state: &State) -> Result<Self, Self::Rejection> {
async fn from_request(req: Request, state: &State) -> Result<Self, Self::Rejection> {
let mut inner = Extractor::from_request(req, state).await?;
inner.get_modify().modify();
Ok(Modified(inner))
@@ -309,18 +306,17 @@ where
}
#[async_trait]
impl<State, Body, Extractor> FromRequest<State, Body> for Validified<Extractor>
impl<State, Extractor> FromRequest<State> for Validified<Extractor>
where
State: Send + Sync,
Body: Send + Sync + 'static,
Extractor: HasValidify,
Extractor::Validify: Validify,
Extractor::PayloadExtractor: FromRequest<State, Body>,
Extractor::PayloadExtractor: FromRequest<State>,
{
type Rejection =
ValidifyRejection<<Extractor::PayloadExtractor as FromRequest<State, Body>>::Rejection>;
ValidifyRejection<<Extractor::PayloadExtractor as FromRequest<State>>::Rejection>;
async fn from_request(req: Request<Body>, state: &State) -> Result<Self, Self::Rejection> {
async fn from_request(req: Request, state: &State) -> Result<Self, Self::Rejection> {
let payload = Extractor::PayloadExtractor::from_request(req, state)
.await
.map_err(ValidifyRejection::Inner)?;
@@ -352,16 +348,15 @@ where
}
#[async_trait]
impl<State, Body, Extractor> FromRequest<State, Body> for ValidifiedByRef<Extractor>
impl<State, Extractor> FromRequest<State> for ValidifiedByRef<Extractor>
where
State: Send + Sync,
Body: Send + Sync + 'static,
Extractor: HasValidate + HasModify + FromRequest<State, Body>,
Extractor: HasValidate + HasModify + FromRequest<State>,
Extractor::Validate: Validate,
{
type Rejection = ValidifyRejection<<Extractor as FromRequest<State, Body>>::Rejection>;
type Rejection = ValidifyRejection<<Extractor as FromRequest<State>>::Rejection>;
async fn from_request(req: Request<Body>, state: &State) -> Result<Self, Self::Rejection> {
async fn from_request(req: Request, state: &State) -> Result<Self, Self::Rejection> {
let mut inner = Extractor::from_request(req, state)
.await
.map_err(ValidifyRejection::Inner)?;

65
src/validify/test.rs
View File

@@ -5,15 +5,17 @@ use crate::{
HasValidate, Modified, Validated, Validified, ValidifiedByRef, VALIDATION_ERROR_STATUS,
};
use axum::extract::{Path, Query};
use axum::http::StatusCode;
use axum::routing::{get, post};
use axum::{Form, Json, Router};
use hyper::Method;
use once_cell::sync::Lazy;
use reqwest::{StatusCode, Url};
use reqwest::Url;
use serde::{Deserialize, Serialize};
use std::any::type_name;
use std::net::SocketAddr;
use std::ops::Deref;
use tokio::net::TcpListener;
use validify::{Modify, Validate, Validify};
#[derive(Clone, Deserialize, Serialize, Validify, Eq, PartialEq)]
@@ -300,15 +302,14 @@ async fn test_main() -> anyhow::Result<()> {
post(msgpack::extract_msgpack_raw_validified_by_ref),
);
let server = axum::Server::bind(&SocketAddr::from(([0u8, 0, 0, 0], 0u16)))
.serve(router.into_make_service());
let server_addr = server.local_addr();
let listener = TcpListener::bind(&SocketAddr::from(([0u8, 0, 0, 0], 0u16))).await?;
let server_addr = listener.local_addr()?;
let server = axum::serve(listener, router.into_make_service());
println!("Axum server address: {}.", server_addr);
let (server_guard, close) = tokio::sync::oneshot::channel::<()>();
let server_handle = tokio::spawn(server.with_graceful_shutdown(async move {
let _ = close.await;
}));
tokio::spawn(async move {
let _ = server.await;
});
let server_url = format!("http://{}", server_addr);
let test_executor = TestExecutor::from(Url::parse(&format!("http://{}", server_addr))?);
@@ -383,8 +384,8 @@ async fn test_main() -> anyhow::Result<()> {
.send()
.await?;
assert_eq!(
valid_path_response.status(),
expected_valid_status,
valid_path_response.status().as_u16(),
expected_valid_status.as_u16(),
"Valid '{}' test failed.",
path_type_name
);
@@ -395,8 +396,8 @@ async fn test_main() -> anyhow::Result<()> {
.send()
.await?;
assert_eq!(
error_path_response.status(),
expected_error_status,
error_path_response.status().as_u16(),
expected_error_status.as_u16(),
"Error '{}' test failed: {}",
path_type_name,
error_path_response.text().await?
@@ -411,8 +412,8 @@ async fn test_main() -> anyhow::Result<()> {
.send()
.await?;
assert_eq!(
invalid_path_response.status(),
expected_invalid_status,
invalid_path_response.status().as_u16(),
expected_invalid_status.as_u16(),
"Invalid '{}' test failed.",
path_type_name
);
@@ -482,7 +483,7 @@ async fn test_main() -> anyhow::Result<()> {
#[cfg(feature = "typed_header")]
{
use axum::TypedHeader;
use axum_extra::typed_header::TypedHeader;
// Validated
test_executor
.execute::<TypedHeader<ParametersValidify>>(
@@ -683,8 +684,8 @@ async fn test_main() -> anyhow::Result<()> {
.send()
.await?;
assert_eq!(
valid_extra_typed_path_response.status(),
expected_valid_status,
valid_extra_typed_path_response.status().as_u16(),
expected_valid_status.as_u16(),
"Validified '{}' test failed.",
extra_typed_path_type_name
);
@@ -695,8 +696,8 @@ async fn test_main() -> anyhow::Result<()> {
.send()
.await?;
assert_eq!(
error_extra_typed_path_response.status(),
expected_error_status,
error_extra_typed_path_response.status().as_u16(),
expected_error_status.as_u16(),
"Error '{}' test failed.",
extra_typed_path_type_name
);
@@ -710,8 +711,8 @@ async fn test_main() -> anyhow::Result<()> {
.send()
.await?;
assert_eq!(
invalid_extra_typed_path_response.status(),
expected_invalid_status,
invalid_extra_typed_path_response.status().as_u16(),
expected_invalid_status.as_u16(),
"Invalid '{}' test failed.",
extra_typed_path_type_name
);
@@ -906,8 +907,6 @@ async fn test_main() -> anyhow::Result<()> {
.await?;
}
drop(server_guard);
server_handle.await??;
Ok(())
}
@@ -994,8 +993,8 @@ impl TestExecutor {
let valid_builder = self.client.request(method.clone(), url.clone());
let valid_response = T::set_valid_request(valid_builder).send().await?;
assert_eq!(
valid_response.status(),
expected_valid_status,
valid_response.status().as_u16(),
expected_valid_status.as_u16(),
"Validified '{}' test failed: {}.",
type_name,
valid_response.text().await?
@@ -1004,8 +1003,8 @@ impl TestExecutor {
let error_builder = self.client.request(method.clone(), url.clone());
let error_response = T::set_error_request(error_builder).send().await?;
assert_eq!(
error_response.status(),
expected_error_status,
error_response.status().as_u16(),
expected_error_status.as_u16(),
"Error '{}' test failed: {}.",
type_name,
error_response.text().await?
@@ -1014,8 +1013,8 @@ impl TestExecutor {
let invalid_builder = self.client.request(method, url);
let invalid_response = T::set_invalid_request(invalid_builder).send().await?;
assert_eq!(
invalid_response.status(),
expected_invalid_status,
invalid_response.status().as_u16(),
expected_invalid_status.as_u16(),
"Invalid '{}' test failed: {}.",
type_name,
invalid_response.text().await?
@@ -1040,8 +1039,8 @@ impl TestExecutor {
#[cfg(feature = "into_json")]
pub async fn check_json(type_name: &'static str, response: reqwest::Response) {
assert_eq!(
response.headers()[axum::http::header::CONTENT_TYPE],
axum::http::HeaderValue::from_static(mime::APPLICATION_JSON.as_ref()),
response.headers()[reqwest::header::CONTENT_TYPE],
reqwest::header::HeaderValue::from_static(mime::APPLICATION_JSON.as_ref()),
"'{}' rejection into json test failed",
type_name
);
@@ -1206,9 +1205,9 @@ mod typed_header {
use super::{check_modified, check_validated, check_validified, ParametersValidify};
use crate::{Modified, Validated, ValidifiedByRef};
use axum::headers::{Error, Header, HeaderName, HeaderValue};
use axum::http::StatusCode;
use axum::TypedHeader;
use axum_extra::headers::{Error, Header, HeaderName, HeaderValue};
use axum_extra::typed_header::TypedHeader;
pub static AXUM_VALID_PARAMETERS: HeaderName = HeaderName::from_static("axum-valid-parameters");

176
src/yaml.rs
View File

@@ -1,176 +0,0 @@
//! # Support for `Yaml<T>` from `axum-yaml`
//!
//! ## Feature
//!
//! Enable the `yaml` feature to use `Valid<Yaml<T>>`.
//!
//! ## Usage
//!
//! 1. Implement `Deserialize` and `Validate` for your data type `T`.
//! 2. In your handler function, use `Valid<Yaml<T>>` as some parameter's type.
//!
//! ## Example
//!
//! ```no_run
//! #[cfg(feature = "validator")]
//! mod validator_example {
//! use axum::routing::post;
//! use axum_yaml::Yaml;
//! use axum::Router;
//! use axum_valid::Valid;
//! use serde::Deserialize;
//! use validator::Validate;
//!
//! pub fn router() -> Router {
//! Router::new().route("/yaml", post(handler))
//! }
//!
//! async fn handler(Valid(Yaml(parameter)): Valid<Yaml<Parameter>>) {
//! assert!(parameter.validate().is_ok());
//! // Support automatic dereferencing
//! println!("v0 = {}, v1 = {}", parameter.v0, parameter.v1);
//! }
//!
//! #[derive(Validate, Deserialize)]
//! pub struct Parameter {
//! #[validate(range(min = 5, max = 10))]
//! pub v0: i32,
//! #[validate(length(min = 1, max = 10))]
//! pub v1: String,
//! }
//! }
//!
//! #[cfg(feature = "garde")]
//! mod garde_example {
//! use axum::routing::post;
//! use axum_yaml::Yaml;
//! use axum::Router;
//! use axum_valid::Garde;
//! use serde::Deserialize;
//! use garde::Validate;
//!
//! pub fn router() -> Router {
//! Router::new().route("/yaml", post(handler))
//! }
//!
//! async fn handler(Garde(Yaml(parameter)): Garde<Yaml<Parameter>>) {
//! assert!(parameter.validate(&()).is_ok());
//! // Support automatic dereferencing
//! println!("v0 = {}, v1 = {}", parameter.v0, parameter.v1);
//! }
//!
//! #[derive(Validate, Deserialize)]
//! pub struct Parameter {
//! #[garde(range(min = 5, max = 10))]
//! pub v0: i32,
//! #[garde(length(min = 1, max = 10))]
//! pub v1: String,
//! }
//! }
//!
//! # #[tokio::main]
//! # async fn main() -> anyhow::Result<()> {
//! # use axum::Router;
//! # let router = Router::new();
//! # #[cfg(feature = "validator")]
//! # let router = router.nest("/validator", validator_example::router());
//! # #[cfg(feature = "garde")]
//! # let router = router.nest("/garde", garde_example::router());
//! # axum::Server::bind(&([0u8, 0, 0, 0], 8080).into())
//! # .serve(router.into_make_service())
//! # .await?;
//! # Ok(())
//! # }
//! ```
use crate::HasValidate;
#[cfg(feature = "validator")]
use crate::HasValidateArgs;
use axum_yaml::Yaml;
#[cfg(feature = "validator")]
use validator::ValidateArgs;
impl<T> HasValidate for Yaml<T> {
type Validate = T;
fn get_validate(&self) -> &T {
&self.0
}
}
#[cfg(feature = "validator")]
impl<'v, T: ValidateArgs<'v>> HasValidateArgs<'v> for Yaml<T> {
type ValidateArgs = T;
fn get_validate_args(&self) -> &Self::ValidateArgs {
&self.0
}
}
#[cfg(feature = "validify")]
impl<T: validify::Modify> crate::HasModify for Yaml<T> {
type Modify = T;
fn get_modify(&mut self) -> &mut Self::Modify {
&mut self.0
}
}
#[cfg(feature = "validify")]
impl<T> crate::PayloadExtractor for Yaml<T> {
type Payload = T;
fn get_payload(self) -> Self::Payload {
self.0
}
}
#[cfg(feature = "validify")]
impl<T: validify::Validify> crate::HasValidify for Yaml<T> {
type Validify = T;
type PayloadExtractor = Yaml<T::Payload>;
fn from_validified(v: Self::Validify) -> Self {
Yaml(v)
}
}
#[cfg(test)]
mod tests {
use crate::tests::{ValidTest, ValidTestParameter};
use axum::http::StatusCode;
use axum_yaml::Yaml;
use reqwest::RequestBuilder;
use serde::Serialize;
impl<T: ValidTestParameter + Serialize> ValidTest for Yaml<T> {
const ERROR_STATUS_CODE: StatusCode = StatusCode::UNPROCESSABLE_ENTITY;
fn set_valid_request(builder: RequestBuilder) -> RequestBuilder {
builder
.header(reqwest::header::CONTENT_TYPE, "application/yaml")
.body(
serde_yaml::to_string(&T::valid())
.expect("Failed to serialize parameters to yaml"),
)
}
fn set_error_request(builder: RequestBuilder) -> RequestBuilder {
#[derive(Serialize, Default)]
struct ErrorData {
error_field: i32,
}
builder
.header(reqwest::header::CONTENT_TYPE, "application/yaml")
.body(
serde_yaml::to_string(&ErrorData::default())
.expect("Failed to serialize parameters to yaml"),
)
}
fn set_invalid_request(builder: RequestBuilder) -> RequestBuilder {
builder
.header(reqwest::header::CONTENT_TYPE, "application/yaml")
.body(
serde_yaml::to_string(&T::invalid())
.expect("Failed to serialize parameters to yaml"),
)
}
}
}