mirrors/ntex
1
0
Fork 0
mirror of https://github.com/ntex-rs/ntex.git synced 2025-04-04 13:27:39 +03:00
Code Issues Projects Releases Packages Wiki Activity

update tests

Browse source
This commit is contained in:
Nikolay Kim 2021-12-24 04:14:11 +06:00
parent 7557c287b5
commit cc55a4bbd3
12 changed files with 74 additions and 102 deletions
Download patch file Download diff file Expand all files Collapse all files

7
ntex-io/src/dispatcher.rs
View file

@ -518,11 +518,11 @@ mod tests {
impl<S, U> Dispatcher<S, U> impl<S, U> Dispatcher<S, U>
where where
S: Service<Request = DispatchItem<U>, Response = Option<Response<U>>> + 'static, S: Service<DispatchItem<U>, Response = Option<Response<U>>> + 'static,
U: Decoder + Encoder + 'static, U: Decoder + Encoder + 'static,
{ {
/// Construct new `Dispatcher` instance /// Construct new `Dispatcher` instance
pub(crate) fn debug<T: IoStream, F: IntoService<S>>( pub(crate) fn debug<T: IoStream, F: IntoService<S, DispatchItem<U>>>(
io: T, io: T,
codec: U, codec: U,
service: F, service: F,
@ -682,8 +682,7 @@ mod tests {
struct Srv(Rc<Cell<usize>>); struct Srv(Rc<Cell<usize>>);
impl Service for Srv { impl Service<DispatchItem<BytesCodec>> for Srv {
type Request = DispatchItem<BytesCodec>;
type Response = Option<Response<BytesCodec>>; type Response = Option<Response<BytesCodec>>;
type Error = (); type Error = ();
type Future = Ready<Option<Response<BytesCodec>>, ()>; type Future = Ready<Option<Response<BytesCodec>>, ()>;

8
ntex/src/http/h1/dispatcher.rs
View file

@ -654,8 +654,8 @@ mod tests {
service: F, service: F,
) -> Dispatcher<Base, S, B, ExpectHandler, UpgradeHandler<Base>> ) -> Dispatcher<Base, S, B, ExpectHandler, UpgradeHandler<Base>>
where where
F: IntoService<S>, F: IntoService<S, Request>,
S: Service<Request = Request>, S: Service<Request>,
S::Error: ResponseError + 'static, S::Error: ResponseError + 'static,
S::Response: Into<Response<B>>, S::Response: Into<Response<B>>,
B: MessageBody, B: MessageBody,
@ -680,8 +680,8 @@ mod tests {
pub(crate) fn spawn_h1<F, S, B>(stream: Io, service: F) pub(crate) fn spawn_h1<F, S, B>(stream: Io, service: F)
where where
F: IntoService<S>, F: IntoService<S, Request>,
S: Service<Request = Request> + 'static, S: Service<Request> + 'static,
S::Error: ResponseError, S::Error: ResponseError,
S::Response: Into<Response<B>>, S::Response: Into<Response<B>>,
B: MessageBody + 'static, B: MessageBody + 'static,

7
ntex/src/server/worker.rs
View file

@ -514,12 +514,10 @@ mod tests {
counter: Arc<Mutex<usize>>, counter: Arc<Mutex<usize>>,
} }
impl ServiceFactory for SrvFactory { impl ServiceFactory<Io> for SrvFactory {
type Request = Io;
type Response = (); type Response = ();
type Error = (); type Error = ();
type Service = Srv; type Service = Srv;
type Config = ();
type InitError = (); type InitError = ();
type Future = Ready<Srv, ()>; type Future = Ready<Srv, ()>;
@ -536,8 +534,7 @@ mod tests {
st: Arc<Mutex<St>>, st: Arc<Mutex<St>>,
} }
impl Service for Srv { impl Service<Io> for Srv {
type Request = Io;
type Response = (); type Response = ();
type Error = (); type Error = ();
type Future = Ready<(), ()>; type Future = Ready<(), ()>;

3
ntex/src/util/buffer.rs
View file

@ -244,8 +244,7 @@ mod tests {
count: Cell<usize>, count: Cell<usize>,
} }
impl Service for TestService { impl Service<()> for TestService {
type Request = ();
type Response = (); type Response = ();
type Error = (); type Error = ();
type Future = Ready<(), ()>; type Future = Ready<(), ()>;

3
ntex/src/util/inflight.rs
View file

@ -117,8 +117,7 @@ mod tests {
struct SleepService(Duration); struct SleepService(Duration);
impl Service for SleepService { impl Service<()> for SleepService {
type Request = ();
type Response = (); type Response = ();
type Error = (); type Error = ();
type Future = Pin<Box<dyn Future<Output = Result<(), ()>>>>; type Future = Pin<Box<dyn Future<Output = Result<(), ()>>>>;

20
ntex/src/util/keepalive.rs
View file

@ -7,13 +7,13 @@ use crate::{util::Ready, Service, ServiceFactory};
/// KeepAlive service factory /// KeepAlive service factory
/// ///
/// Controls min time between requests. /// Controls min time between requests.
pub struct KeepAlive<E, F> { pub struct KeepAlive<R, E, F> {
f: F, f: F,
ka: Millis, ka: Millis,
_t: marker::PhantomData<E>, _t: marker::PhantomData<(R, E)>,
} }
impl<E, F> KeepAlive<E, F> impl<R, E, F> KeepAlive<R, E, F>
where where
F: Fn() -> E + Clone, F: Fn() -> E + Clone,
{ {
@ -30,7 +30,7 @@ where
} }
} }
impl<E, F> Clone for KeepAlive<E, F> impl<R, E, F> Clone for KeepAlive<R, E, F>
where where
F: Clone, F: Clone,
{ {
@ -43,14 +43,14 @@ where
} }
} }
impl<R, E, F, C> ServiceFactory<R, C> for KeepAlive<E, F> impl<R, E, F, C> ServiceFactory<R, C> for KeepAlive<R, E, F>
where where
F: Fn() -> E + Clone, F: Fn() -> E + Clone,
{ {
type Response = R; type Response = R;
type Error = E; type Error = E;
type InitError = Infallible; type InitError = Infallible;
type Service = KeepAliveService<E, F>; type Service = KeepAliveService<R, E, F>;
type Future = Ready<Self::Service, Self::InitError>; type Future = Ready<Self::Service, Self::InitError>;
#[inline] #[inline]
@ -59,15 +59,15 @@ where
} }
} }
pub struct KeepAliveService<E, F> { pub struct KeepAliveService<R, E, F> {
f: F, f: F,
dur: Millis, dur: Millis,
sleep: Sleep, sleep: Sleep,
expire: Cell<Instant>, expire: Cell<Instant>,
_t: marker::PhantomData<E>, _t: marker::PhantomData<(R, E)>,
} }
impl<E, F> KeepAliveService<E, F> impl<R, E, F> KeepAliveService<R, E, F>
where where
F: Fn() -> E, F: Fn() -> E,
{ {
@ -84,7 +84,7 @@ where
} }
} }
impl<R, E, F> Service<R> for KeepAliveService<E, F> impl<R, E, F> Service<R> for KeepAliveService<R, E, F>
where where
F: Fn() -> E, F: Fn() -> E,
{ {

2
ntex/src/util/mod.rs
View file

@ -6,7 +6,7 @@ pub mod keepalive;
pub mod sink; pub mod sink;
pub mod stream; pub mod stream;
pub mod timeout; pub mod timeout;
//pub mod variant; pub mod variant;
pub use self::extensions::Extensions; pub use self::extensions::Extensions;

3
ntex/src/util/timeout.rs
View file

@ -228,8 +228,7 @@ mod tests {
#[derive(Clone, Debug, Display, PartialEq)] #[derive(Clone, Debug, Display, PartialEq)]
struct SrvError; struct SrvError;
impl Service for SleepService { impl Service<()> for SleepService {
type Request = ();
type Response = (); type Response = ();
type Error = SrvError; type Error = SrvError;
type Future = Pin<Box<dyn Future<Output = Result<(), SrvError>>>>; type Future = Pin<Box<dyn Future<Output = Result<(), SrvError>>>>;

66
ntex/src/util/variant.rs
View file

@ -6,7 +6,9 @@ use crate::service::{IntoServiceFactory, Service, ServiceFactory};
/// Construct `Variant` service factory. /// Construct `Variant` service factory.
/// ///
/// Variant service allow to combine multiple different services into a single service. /// Variant service allow to combine multiple different services into a single service.
pub fn variant<V1: ServiceFactory<V1R>, V1R>(factory: V1) -> Variant<V1, V1R> { pub fn variant<V1: ServiceFactory<V1R, V1C>, V1R, V1C>(
factory: V1,
) -> Variant<V1, V1R, V1C> {
Variant { Variant {
factory, factory,
_t: PhantomData, _t: PhantomData,
@ -14,27 +16,27 @@ pub fn variant<V1: ServiceFactory<V1R>, V1R>(factory: V1) -> Variant<V1, V1R> {
} }
/// Combine multiple different service types into a single service. /// Combine multiple different service types into a single service.
pub struct Variant<A, AR> { pub struct Variant<A, AR, AC> {
factory: A, factory: A,
_t: PhantomData<AR>, _t: PhantomData<(AR, AC)>,
} }
impl<A, AR> Variant<A, AR> impl<A, AR, AC> Variant<A, AR, AC>
where where
A: ServiceFactory<AR>, A: ServiceFactory<AR, AC>,
A::Config: Clone, AC: Clone,
{ {
/// Convert to a Variant with two request types /// Convert to a Variant with two request types
pub fn v2<B, BR, F>(self, factory: F) -> VariantFactory2<A, B, AR, BR> pub fn v2<B, BR, F>(self, factory: F) -> VariantFactory2<A, AC, B, AR, BR>
where where
B: ServiceFactory< B: ServiceFactory<
BR, BR,
Config = A::Config, AC,
Response = A::Response, Response = A::Response,
Error = A::Error, Error = A::Error,
InitError = A::InitError, InitError = A::InitError,
>, >,
F: IntoServiceFactory<B, BR>, F: IntoServiceFactory<B, BR, AC>,
{ {
VariantFactory2 { VariantFactory2 {
V1: self.factory, V1: self.factory,
@ -47,19 +49,18 @@ where
macro_rules! variant_impl_and ({$fac1_type:ident, $fac2_type:ident, $name:ident, $r_name:ident, $m_name:ident, ($($T:ident),+), ($($R:ident),+)} => { macro_rules! variant_impl_and ({$fac1_type:ident, $fac2_type:ident, $name:ident, $r_name:ident, $m_name:ident, ($($T:ident),+), ($($R:ident),+)} => {
#[allow(non_snake_case)] #[allow(non_snake_case)]
impl<V1, $($T,)+ V1R, $($R,)+> $fac1_type<V1, $($T,)+ V1R, $($R,)+> impl<V1, V1C, $($T,)+ V1R, $($R,)+> $fac1_type<V1, V1C, $($T,)+ V1R, $($R,)+>
where where
V1: ServiceFactory<V1R>, V1: ServiceFactory<V1R, V1C>,
V1::Config: Clone, V1C: Clone,
{ {
/// Convert to a Variant with more request types /// Convert to a Variant with more request types
pub fn $m_name<$name, $r_name, F>(self, factory: F) -> $fac2_type<V1, $($T,)+ $name, V1R, $($R,)+ $r_name> pub fn $m_name<$name, $r_name, F>(self, factory: F) -> $fac2_type<V1, V1C, $($T,)+ $name, V1R, $($R,)+ $r_name>
where $name: ServiceFactory<$r_name, where $name: ServiceFactory<$r_name, V1C,
Config = V1::Config,
Response = V1::Response, Response = V1::Response,
Error = V1::Error, Error = V1::Error,
InitError = V1::InitError>, InitError = V1::InitError>,
F: IntoServiceFactory<$name, $r_name>, F: IntoServiceFactory<$name, $r_name, V1C>,
{ {
$fac2_type { $fac2_type {
V1: self.V1, V1: self.V1,
@ -136,13 +137,13 @@ macro_rules! variant_impl ({$mod_name:ident, $enum_type:ident, $srv_type:ident,
} }
#[allow(non_snake_case)] #[allow(non_snake_case)]
pub struct $fac_type<V1, $($T,)+ V1R, $($R,)+> { pub struct $fac_type<V1, V1C, $($T,)+ V1R, $($R,)+> {
V1: V1, V1: V1,
$($T: $T,)+ $($T: $T,)+
_t: PhantomData<(V1R, $($R,)+)>, _t: PhantomData<(V1C, V1R, $($R,)+)>,
} }
impl<V1: Clone, $($T: Clone,)+ V1R, $($R,)+> Clone for $fac_type<V1, $($T,)+ V1R, $($R,)+> { impl<V1: Clone, V1C, $($T: Clone,)+ V1R, $($R,)+> Clone for $fac_type<V1, V1C, $($T,)+ V1R, $($R,)+> {
fn clone(&self) -> Self { fn clone(&self) -> Self {
Self { Self {
_t: PhantomData, _t: PhantomData,
@ -152,20 +153,19 @@ macro_rules! variant_impl ({$mod_name:ident, $enum_type:ident, $srv_type:ident,
} }
} }
impl<V1, $($T,)+ V1R, $($R,)+> ServiceFactory<$enum_type<V1R, $($R),+>> for $fac_type<V1, $($T,)+ V1R, $($R,)+> impl<V1, V1C, $($T,)+ V1R, $($R,)+> ServiceFactory<$enum_type<V1R, $($R),+>, V1C> for $fac_type<V1, V1C, $($T,)+ V1R, $($R,)+>
where where
V1: ServiceFactory<V1R>, V1: ServiceFactory<V1R, V1C>,
V1::Config: Clone, V1C: Clone,
$($T: ServiceFactory<$R, Config = V1::Config, Response = V1::Response, Error = V1::Error, InitError = V1::InitError>),+ $($T: ServiceFactory<$R, V1C, Response = V1::Response, Error = V1::Error, InitError = V1::InitError>),+
{ {
type Response = V1::Response; type Response = V1::Response;
type Error = V1::Error; type Error = V1::Error;
type Config = V1::Config;
type InitError = V1::InitError; type InitError = V1::InitError;
type Service = $srv_type<V1::Service, $($T::Service,)+ V1R, $($R,)+>; type Service = $srv_type<V1::Service, $($T::Service,)+ V1R, $($R,)+>;
type Future = $mod_name::ServiceFactoryResponse<V1, $($T,)+ V1R, $($R,)+>; type Future = $mod_name::ServiceFactoryResponse<V1, V1C, $($T,)+ V1R, $($R,)+>;
fn new_service(&self, cfg: Self::Config) -> Self::Future { fn new_service(&self, cfg: V1C) -> Self::Future {
$mod_name::ServiceFactoryResponse { $mod_name::ServiceFactoryResponse {
V1: None, V1: None,
items: Default::default(), items: Default::default(),
@ -206,7 +206,7 @@ macro_rules! variant_impl ({$mod_name:ident, $enum_type:ident, $srv_type:ident,
pin_project_lite::pin_project! { pin_project_lite::pin_project! {
#[doc(hidden)] #[doc(hidden)]
pub struct ServiceFactoryResponse<V1: ServiceFactory<V1R>, $($T: ServiceFactory<$R>,)+ V1R, $($R,)+> { pub struct ServiceFactoryResponse<V1: ServiceFactory<V1R, V1C>, V1C, $($T: ServiceFactory<$R, V1C>,)+ V1R, $($R,)+> {
pub(super) V1: Option<V1::Service>, pub(super) V1: Option<V1::Service>,
pub(super) items: ($(Option<$T::Service>,)+), pub(super) items: ($(Option<$T::Service>,)+),
#[pin] pub(super) V1_fut: V1::Future, #[pin] pub(super) V1_fut: V1::Future,
@ -214,10 +214,10 @@ macro_rules! variant_impl ({$mod_name:ident, $enum_type:ident, $srv_type:ident,
} }
} }
impl<V1, $($T,)+ V1R, $($R,)+> Future for ServiceFactoryResponse<V1, $($T,)+ V1R, $($R,)+> impl<V1, V1C, $($T,)+ V1R, $($R,)+> Future for ServiceFactoryResponse<V1, V1C, $($T,)+ V1R, $($R,)+>
where where
V1: ServiceFactory<V1R>, V1: ServiceFactory<V1R, V1C>,
$($T: ServiceFactory<$R, Response = V1::Response, Error = V1::Error, InitError = V1::InitError,>),+ $($T: ServiceFactory<$R, V1C, Response = V1::Response, Error = V1::Error, InitError = V1::InitError,>),+
{ {
type Output = Result<$srv_type<V1::Service, $($T::Service,)+ V1R, $($R),+>, V1::InitError>; type Output = Result<$srv_type<V1::Service, $($T::Service,)+ V1R, $($R),+>, V1::InitError>;
@ -301,8 +301,7 @@ mod tests {
#[derive(Clone)] #[derive(Clone)]
struct Srv1; struct Srv1;
impl Service for Srv1 { impl Service<()> for Srv1 {
type Request = ();
type Response = usize; type Response = usize;
type Error = (); type Error = ();
type Future = Ready<usize, ()>; type Future = Ready<usize, ()>;
@ -323,8 +322,7 @@ mod tests {
#[derive(Clone)] #[derive(Clone)]
struct Srv2; struct Srv2;
impl Service for Srv2 { impl Service<()> for Srv2 {
type Request = ();
type Response = usize; type Response = usize;
type Error = (); type Error = ();
type Future = Ready<usize, ()>; type Future = Ready<usize, ()>;

26
ntex/src/web/middleware/compress.rs
View file

@ -26,50 +26,40 @@ use crate::web::{BodyEncoding, ErrorRenderer, WebRequest, WebResponse};
/// ); /// );
/// } /// }
/// ``` /// ```
pub struct Compress<E> { pub struct Compress {
enc: ContentEncoding, enc: ContentEncoding,
_t: marker::PhantomData<E>,
} }
impl<E> Compress<E> { impl Compress {
/// Create new `Compress` middleware with default encoding. /// Create new `Compress` middleware with default encoding.
pub fn new(encoding: ContentEncoding) -> Self { pub fn new(encoding: ContentEncoding) -> Self {
Compress { Compress { enc: encoding }
enc: encoding,
_t: marker::PhantomData,
}
} }
} }
impl<E> Default for Compress<E> { impl Default for Compress {
fn default() -> Self { fn default() -> Self {
Compress::new(ContentEncoding::Auto) Compress::new(ContentEncoding::Auto)
} }
} }
impl<S, E> Transform<S> for Compress<E> impl<S> Transform<S> for Compress {
where type Service = CompressMiddleware<S>;
S: Service<WebRequest<E>, Response = WebResponse>,
E: ErrorRenderer,
{
type Service = CompressMiddleware<S, E>;
fn new_transform(&self, service: S) -> Self::Service { fn new_transform(&self, service: S) -> Self::Service {
CompressMiddleware { CompressMiddleware {
service, service,
encoding: self.enc, encoding: self.enc,
_t: marker::PhantomData,
} }
} }
} }
pub struct CompressMiddleware<S, E> { pub struct CompressMiddleware<S> {
service: S, service: S,
encoding: ContentEncoding, encoding: ContentEncoding,
_t: marker::PhantomData<E>,
} }
impl<S, E> Service<WebRequest<E>> for CompressMiddleware<S, E> impl<S, E> Service<WebRequest<E>> for CompressMiddleware<S>
where where
S: Service<WebRequest<E>, Response = WebResponse>, S: Service<WebRequest<E>, Response = WebResponse>,
E: ErrorRenderer, E: ErrorRenderer,

26
ntex/src/web/middleware/defaultheaders.rs
View file

@ -1,6 +1,6 @@
//! Middleware for setting default response headers //! Middleware for setting default response headers
use std::task::{Context, Poll}; use std::task::{Context, Poll};
use std::{convert::TryFrom, future::Future, marker::PhantomData, pin::Pin, rc::Rc}; use std::{convert::TryFrom, future::Future, pin::Pin, rc::Rc};
use crate::http::error::HttpError; use crate::http::error::HttpError;
use crate::http::header::{HeaderMap, HeaderName, HeaderValue, CONTENT_TYPE}; use crate::http::header::{HeaderMap, HeaderName, HeaderValue, CONTENT_TYPE};
@ -26,9 +26,8 @@ use crate::web::{WebRequest, WebResponse};
/// } /// }
/// ``` /// ```
#[derive(Clone)] #[derive(Clone)]
pub struct DefaultHeaders<E> { pub struct DefaultHeaders {
inner: Rc<Inner>, inner: Rc<Inner>,
_t: PhantomData<E>,
} }
struct Inner { struct Inner {
@ -36,21 +35,20 @@ struct Inner {
headers: HeaderMap, headers: HeaderMap,
} }
impl<E> Default for DefaultHeaders<E> { impl Default for DefaultHeaders {
fn default() -> Self { fn default() -> Self {
DefaultHeaders { DefaultHeaders {
inner: Rc::new(Inner { inner: Rc::new(Inner {
ct: false, ct: false,
headers: HeaderMap::new(), headers: HeaderMap::new(),
}), }),
_t: PhantomData,
} }
} }
} }
impl<E> DefaultHeaders<E> { impl DefaultHeaders {
/// Construct `DefaultHeaders` middleware. /// Construct `DefaultHeaders` middleware.
pub fn new() -> DefaultHeaders<E> { pub fn new() -> DefaultHeaders {
DefaultHeaders::default() DefaultHeaders::default()
} }
@ -88,29 +86,23 @@ impl<E> DefaultHeaders<E> {
} }
} }
impl<S, E> Transform<S> for DefaultHeaders<E> impl<S> Transform<S> for DefaultHeaders {
where type Service = DefaultHeadersMiddleware<S>;
S: Service<WebRequest<E>, Response = WebResponse>,
S::Future: 'static,
{
type Service = DefaultHeadersMiddleware<S, E>;
fn new_transform(&self, service: S) -> Self::Service { fn new_transform(&self, service: S) -> Self::Service {
DefaultHeadersMiddleware { DefaultHeadersMiddleware {
service, service,
inner: self.inner.clone(), inner: self.inner.clone(),
_t: PhantomData,
} }
} }
} }
pub struct DefaultHeadersMiddleware<S, E> { pub struct DefaultHeadersMiddleware<S> {
service: S, service: S,
inner: Rc<Inner>, inner: Rc<Inner>,
_t: PhantomData<E>,
} }
impl<S, E> Service<WebRequest<E>> for DefaultHeadersMiddleware<S, E> impl<S, E> Service<WebRequest<E>> for DefaultHeadersMiddleware<S>
where where
S: Service<WebRequest<E>, Response = WebResponse>, S: Service<WebRequest<E>, Response = WebResponse>,
S::Future: 'static, S::Future: 'static,

5
ntex/tests/http_ws.rs
View file

@ -31,8 +31,7 @@ impl Clone for WsService {
} }
} }
impl Service for WsService { impl Service<(Request, Io, h1::Codec)> for WsService {
type Request = (Request, Io, h1::Codec);
type Response = (); type Response = ();
type Error = io::Error; type Error = io::Error;
type Future = Pin<Box<dyn Future<Output = Result<(), io::Error>>>>; type Future = Pin<Box<dyn Future<Output = Result<(), io::Error>>>>;
@ -42,7 +41,7 @@ impl Service for WsService {
Poll::Ready(Ok(())) Poll::Ready(Ok(()))
} }
fn call(&self, (req, io, codec): Self::Request) -> Self::Future { fn call(&self, (req, io, codec): (Request, Io, h1::Codec)) -> Self::Future {
let fut = async move { let fut = async move {
let res = handshake(req.head()).unwrap().message_body(()); let res = handshake(req.head()).unwrap().message_body(());