mirrors/ntex
1
0
Fork 0
mirror of https://github.com/ntex-rs/ntex.git synced 2025-04-03 21:07: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>
where
S: Service<Request = DispatchItem<U>, Response = Option<Response<U>>> + 'static,
S: Service<DispatchItem<U>, Response = Option<Response<U>>> + 'static,
U: Decoder + Encoder + 'static,
{
/// 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,
codec: U,
service: F,
@ -682,8 +682,7 @@ mod tests {
struct Srv(Rc<Cell<usize>>);
impl Service for Srv {
type Request = DispatchItem<BytesCodec>;
impl Service<DispatchItem<BytesCodec>> for Srv {
type Response = Option<Response<BytesCodec>>;
type Error = ();
type Future = Ready<Option<Response<BytesCodec>>, ()>;

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

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

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

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

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

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

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

@ -117,8 +117,7 @@ mod tests {
struct SleepService(Duration);
impl Service for SleepService {
type Request = ();
impl Service<()> for SleepService {
type Response = ();
type Error = ();
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
///
/// Controls min time between requests.
pub struct KeepAlive<E, F> {
pub struct KeepAlive<R, E, F> {
f: F,
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
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
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
F: Fn() -> E + Clone,
{
type Response = R;
type Error = E;
type InitError = Infallible;
type Service = KeepAliveService<E, F>;
type Service = KeepAliveService<R, E, F>;
type Future = Ready<Self::Service, Self::InitError>;
#[inline]
@ -59,15 +59,15 @@ where
}
}
pub struct KeepAliveService<E, F> {
pub struct KeepAliveService<R, E, F> {
f: F,
dur: Millis,
sleep: Sleep,
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
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
F: Fn() -> E,
{

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

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

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

@ -228,8 +228,7 @@ mod tests {
#[derive(Clone, Debug, Display, PartialEq)]
struct SrvError;
impl Service for SleepService {
type Request = ();
impl Service<()> for SleepService {
type Response = ();
type Error = 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.
///
/// 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 {
factory,
_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.
pub struct Variant<A, AR> {
pub struct Variant<A, AR, AC> {
factory: A,
_t: PhantomData<AR>,
_t: PhantomData<(AR, AC)>,
}
impl<A, AR> Variant<A, AR>
impl<A, AR, AC> Variant<A, AR, AC>
where
A: ServiceFactory<AR>,
A::Config: Clone,
A: ServiceFactory<AR, AC>,
AC: Clone,
{
/// 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
B: ServiceFactory<
BR,
Config = A::Config,
AC,
Response = A::Response,
Error = A::Error,
InitError = A::InitError,
>,
F: IntoServiceFactory<B, BR>,
F: IntoServiceFactory<B, BR, AC>,
{
VariantFactory2 {
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),+)} => {
#[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
V1: ServiceFactory<V1R>,
V1::Config: Clone,
V1: ServiceFactory<V1R, V1C>,
V1C: Clone,
{
/// 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>
where $name: ServiceFactory<$r_name,
Config = V1::Config,
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, V1C,
Response = V1::Response,
Error = V1::Error,
InitError = V1::InitError>,
F: IntoServiceFactory<$name, $r_name>,
F: IntoServiceFactory<$name, $r_name, V1C>,
{
$fac2_type {
V1: self.V1,
@ -136,13 +137,13 @@ macro_rules! variant_impl ({$mod_name:ident, $enum_type:ident, $srv_type:ident,
}
#[allow(non_snake_case)]
pub struct $fac_type<V1, $($T,)+ V1R, $($R,)+> {
pub struct $fac_type<V1, V1C, $($T,)+ V1R, $($R,)+> {
V1: V1,
$($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 {
Self {
_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
V1: ServiceFactory<V1R>,
V1::Config: Clone,
$($T: ServiceFactory<$R, Config = V1::Config, Response = V1::Response, Error = V1::Error, InitError = V1::InitError>),+
V1: ServiceFactory<V1R, V1C>,
V1C: Clone,
$($T: ServiceFactory<$R, V1C, Response = V1::Response, Error = V1::Error, InitError = V1::InitError>),+
{
type Response = V1::Response;
type Error = V1::Error;
type Config = V1::Config;
type InitError = V1::InitError;
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 {
V1: None,
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! {
#[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) items: ($(Option<$T::Service>,)+),
#[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
V1: ServiceFactory<V1R>,
$($T: ServiceFactory<$R, Response = V1::Response, Error = V1::Error, InitError = V1::InitError,>),+
V1: ServiceFactory<V1R, V1C>,
$($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>;
@ -301,8 +301,7 @@ mod tests {
#[derive(Clone)]
struct Srv1;
impl Service for Srv1 {
type Request = ();
impl Service<()> for Srv1 {
type Response = usize;
type Error = ();
type Future = Ready<usize, ()>;
@ -323,8 +322,7 @@ mod tests {
#[derive(Clone)]
struct Srv2;
impl Service for Srv2 {
type Request = ();
impl Service<()> for Srv2 {
type Response = usize;
type Error = ();
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,
_t: marker::PhantomData<E>,
}
impl<E> Compress<E> {
impl Compress {
/// Create new `Compress` middleware with default encoding.
pub fn new(encoding: ContentEncoding) -> Self {
Compress {
enc: encoding,
_t: marker::PhantomData,
}
Compress { enc: encoding }
}
}
impl<E> Default for Compress<E> {
impl Default for Compress {
fn default() -> Self {
Compress::new(ContentEncoding::Auto)
}
}
impl<S, E> Transform<S> for Compress<E>
where
S: Service<WebRequest<E>, Response = WebResponse>,
E: ErrorRenderer,
{
type Service = CompressMiddleware<S, E>;
impl<S> Transform<S> for Compress {
type Service = CompressMiddleware<S>;
fn new_transform(&self, service: S) -> Self::Service {
CompressMiddleware {
service,
encoding: self.enc,
_t: marker::PhantomData,
}
}
}
pub struct CompressMiddleware<S, E> {
pub struct CompressMiddleware<S> {
service: S,
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
S: Service<WebRequest<E>, Response = WebResponse>,
E: ErrorRenderer,

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

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

5
ntex/tests/http_ws.rs
View file

@ -31,8 +31,7 @@ impl Clone for WsService {
}
}
impl Service for WsService {
type Request = (Request, Io, h1::Codec);
impl Service<(Request, Io, h1::Codec)> for WsService {
type Response = ();
type Error = io::Error;
type Future = Pin<Box<dyn Future<Output = Result<(), io::Error>>>>;
@ -42,7 +41,7 @@ impl Service for WsService {
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 res = handshake(req.head()).unwrap().message_body(());