Add missing fmt::Debug impls (#224)

* Add missing fmt::Debug impls

ntex-service/CHANGES.md

@@ -1,5 +1,9 @@
 # Changes
 
+## [1.2.6] - 2023-09-11
+
+* Add fmt::Debug impls
+
 ## [1.2.5] - 2023-08-14
 
 * Use Pipeline<T> instead of ApplyService<T>

ntex-service/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ntex-service"
-version = "1.2.5"
+version = "1.2.6"
 authors = ["ntex contributors <team@ntex.rs>"]
 description = "ntex service"
 keywords = ["network", "framework", "async", "futures"]

ntex-service/src/and_then.rs

@@ -2,6 +2,7 @@ use std::{future::Future, pin::Pin, task::Context, task::Poll};
 
 use super::{Service, ServiceCall, ServiceCtx, ServiceFactory};
 
+#[derive(Clone, Debug)]
 /// Service for the `and_then` combinator, chaining a computation onto the end
 /// of another service which completes successfully.
 ///
@@ -18,19 +19,6 @@ impl<A, B> AndThen<A, B> {
     }
 }
 
-impl<A, B> Clone for AndThen<A, B>
-where
-    A: Clone,
-    B: Clone,
-{
-    fn clone(&self) -> Self {
-        AndThen {
-            svc1: self.svc1.clone(),
-            svc2: self.svc2.clone(),
-        }
-    }
-}
-
 impl<A, B, Req> Service<Req> for AndThen<A, B>
 where
     A: Service<Req>,
@@ -129,6 +117,7 @@ where
     }
 }
 
+#[derive(Debug, Clone)]
 /// `.and_then()` service factory combinator
 pub struct AndThenFactory<A, B> {
     svc1: A,
@@ -166,19 +155,6 @@ where
     }
 }
 
-impl<A, B> Clone for AndThenFactory<A, B>
-where
-    A: Clone,
-    B: Clone,
-{
-    fn clone(&self) -> Self {
-        Self {
-            svc1: self.svc1.clone(),
-            svc2: self.svc2.clone(),
-        }
-    }
-}
-
 pin_project_lite::pin_project! {
     #[must_use = "futures do nothing unless polled"]
     pub struct AndThenFactoryResponse<'f, A, B, Req, Cfg>

ntex-service/src/apply.rs

@@ -1,5 +1,5 @@
 #![allow(clippy::type_complexity)]
-use std::{future::Future, marker, pin::Pin, task, task::Poll};
+use std::{fmt, future::Future, marker, pin::Pin, task, task::Poll};
 
 use super::ctx::ServiceCtx;
 use super::{IntoService, IntoServiceFactory, Pipeline, Service, ServiceFactory};
@@ -72,6 +72,18 @@ where
     }
 }
 
+impl<T, Req, F, R, In, Out, Err> fmt::Debug for Apply<T, Req, F, R, In, Out, Err>
+where
+    T: Service<Req, Error = Err> + fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Apply")
+            .field("service", &self.service)
+            .field("map", &std::any::type_name::<F>())
+            .finish()
+    }
+}
+
 impl<T, Req, F, R, In, Out, Err> Service<In> for Apply<T, Req, F, R, In, Out, Err>
 where
     T: Service<Req, Error = Err>,
@@ -135,6 +147,21 @@ where
     }
 }
 
+impl<T, Req, Cfg, F, R, In, Out, Err> fmt::Debug
+    for ApplyFactory<T, Req, Cfg, F, R, In, Out, Err>
+where
+    T: ServiceFactory<Req, Cfg, Error = Err> + fmt::Debug,
+    F: Fn(In, Pipeline<T::Service>) -> R + Clone,
+    R: Future<Output = Result<Out, Err>>,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("ApplyFactory")
+            .field("factory", &self.service)
+            .field("map", &std::any::type_name::<F>())
+            .finish()
+    }
+}
+
 impl<T, Req, Cfg, F, R, In, Out, Err> ServiceFactory<In, Cfg>
     for ApplyFactory<T, Req, Cfg, F, R, In, Out, Err>
 where
@@ -208,7 +235,7 @@ mod tests {
     use super::*;
     use crate::{chain, chain_factory, Service, ServiceCtx};
 
-    #[derive(Clone)]
+    #[derive(Clone, Debug)]
     struct Srv;
 
     impl Service<()> for Srv {
@@ -258,6 +285,7 @@ mod tests {
         let res = srv.call("srv").await;
         assert!(res.is_ok());
         assert_eq!(res.unwrap(), ("srv", ()));
+        format!("{:?}", srv);
     }
 
     #[ntex::test]
@@ -280,6 +308,7 @@ mod tests {
         let res = srv.call("srv").await;
         assert!(res.is_ok());
         assert_eq!(res.unwrap(), ("srv", ()));
+        format!("{:?}", new_srv);
     }
 
     #[ntex::test]
@@ -298,5 +327,6 @@ mod tests {
         let res = srv.call("srv").await;
         assert!(res.is_ok());
         assert_eq!(res.unwrap(), ("srv", ()));
+        format!("{:?}", new_srv);
     }
 }

ntex-service/src/boxed.rs

@@ -1,4 +1,4 @@
-use std::{future::Future, pin::Pin, task::Context, task::Poll};
+use std::{fmt, future::Future, pin::Pin, task::Context, task::Poll};
 
 use crate::ctx::{ServiceCtx, WaitersRef};
 
@@ -32,6 +32,20 @@ where
     BoxService(Box::new(service))
 }
 
+impl<Req, Res, Err> fmt::Debug for BoxService<Req, Res, Err> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("BoxService").finish()
+    }
+}
+
+impl<Cfg, Req, Res, Err, InitErr> fmt::Debug
+    for BoxServiceFactory<Cfg, Req, Res, Err, InitErr>
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("BoxServiceFactory").finish()
+    }
+}
+
 trait ServiceObj<Req> {
     type Response;
     type Error;

ntex-service/src/chain.rs

@@ -1,5 +1,5 @@
 #![allow(clippy::type_complexity)]
-use std::{future::Future, marker::PhantomData};
+use std::{fmt, future::Future, marker::PhantomData};
 
 use crate::and_then::{AndThen, AndThenFactory};
 use crate::apply::{Apply, ApplyFactory};
@@ -156,6 +156,17 @@ where
     }
 }
 
+impl<Svc, Req> fmt::Debug for ServiceChain<Svc, Req>
+where
+    Svc: fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("ServiceChain")
+            .field("service", &self.service)
+            .finish()
+    }
+}
+
 impl<Svc: Service<Req>, Req> Service<Req> for ServiceChain<Svc, Req> {
     type Response = Svc::Response;
     type Error = Svc::Error;
@@ -315,6 +326,17 @@ where
     }
 }
 
+impl<T, R, C> fmt::Debug for ServiceChainFactory<T, R, C>
+where
+    T: fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("ServiceChainFactory")
+            .field("factory", &self.factory)
+            .finish()
+    }
+}
+
 impl<T: ServiceFactory<R, C>, R, C> ServiceFactory<R, C> for ServiceChainFactory<T, R, C> {
     type Response = T::Response;
     type Error = T::Error;

ntex-service/src/ctx.rs

@@ -1,4 +1,4 @@
-use std::{cell::UnsafeCell, future::Future, marker, pin::Pin, rc::Rc, task};
+use std::{cell::UnsafeCell, fmt, future::Future, marker, pin::Pin, rc::Rc, task};
 
 use crate::{Pipeline, Service};
 
@@ -75,6 +75,15 @@ impl Clone for Waiters {
     }
 }
 
+impl fmt::Debug for Waiters {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Waiters")
+            .field("index", &self.index)
+            .field("waiters", &self.waiters.get().len())
+            .finish()
+    }
+}
+
 impl Drop for Waiters {
     #[inline]
     fn drop(&mut self) {
@@ -148,6 +157,15 @@ impl<'a, S> Clone for ServiceCtx<'a, S> {
     }
 }
 
+impl<'a, S> fmt::Debug for ServiceCtx<'a, S> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("ServiceCtx")
+            .field("idx", &self.idx)
+            .field("waiters", &self.waiters.get().len())
+            .finish()
+    }
+}
+
 pin_project_lite::pin_project! {
     #[must_use = "futures do nothing unless polled"]
     pub struct ServiceCall<'a, S, Req>

ntex-service/src/fn_service.rs

@@ -1,4 +1,4 @@
-use std::{future::ready, future::Future, future::Ready, marker::PhantomData};
+use std::{fmt, future::ready, future::Future, future::Ready, marker::PhantomData};
 
 use crate::{IntoService, IntoServiceFactory, Service, ServiceCtx, ServiceFactory};
 
@@ -118,6 +118,14 @@ where
     }
 }
 
+impl<F, Req> fmt::Debug for FnService<F, Req> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("FnService")
+            .field("f", &std::any::type_name::<F>())
+            .finish()
+    }
+}
+
 impl<F, Fut, Req, Res, Err> Service<Req> for FnService<F, Req>
 where
     F: Fn(Req) -> Fut,
@@ -180,6 +188,18 @@ where
     }
 }
 
+impl<F, Fut, Req, Res, Err, Cfg> fmt::Debug for FnServiceFactory<F, Fut, Req, Res, Err, Cfg>
+where
+    F: Fn(Req) -> Fut,
+    Fut: Future<Output = Result<Res, Err>>,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("FnServiceFactory")
+            .field("f", &std::any::type_name::<F>())
+            .finish()
+    }
+}
+
 impl<F, Fut, Req, Res, Err> Service<Req> for FnServiceFactory<F, Fut, Req, Res, Err, ()>
 where
     F: Fn(Req) -> Fut,
@@ -255,6 +275,19 @@ where
     }
 }
 
+impl<F, Fut, Cfg, Srv, Req, Err> fmt::Debug for FnServiceConfig<F, Fut, Cfg, Srv, Req, Err>
+where
+    F: Fn(Cfg) -> Fut,
+    Fut: Future<Output = Result<Srv, Err>>,
+    Srv: Service<Req>,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("FnServiceConfig")
+            .field("f", &std::any::type_name::<F>())
+            .finish()
+    }
+}
+
 impl<F, Fut, Cfg, Srv, Req, Err> ServiceFactory<Req, Cfg>
     for FnServiceConfig<F, Fut, Cfg, Srv, Req, Err>
 where
@@ -328,6 +361,19 @@ where
     }
 }
 
+impl<F, S, R, Req, E> fmt::Debug for FnServiceNoConfig<F, S, R, Req, E>
+where
+    F: Fn() -> R,
+    R: Future<Output = Result<S, E>>,
+    S: Service<Req>,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("FnServiceNoConfig")
+            .field("f", &std::any::type_name::<F>())
+            .finish()
+    }
+}
+
 impl<F, S, R, Req, E, C> IntoServiceFactory<FnServiceNoConfig<F, S, R, Req, E>, Req, C>
     for F
 where
@@ -353,17 +399,20 @@ mod tests {
     #[ntex::test]
     async fn test_fn_service() {
         let new_srv = fn_service(|()| async { Ok::<_, ()>("srv") }).clone();
+        format!("{:?}", new_srv);
 
         let srv = Pipeline::new(new_srv.create(()).await.unwrap());
         let res = srv.call(()).await;
         assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Ready(Ok(())));
         assert!(res.is_ok());
         assert_eq!(res.unwrap(), "srv");
+        format!("{:?}", srv);
 
         let srv2 = Pipeline::new(new_srv.clone());
         let res = srv2.call(()).await;
         assert!(res.is_ok());
         assert_eq!(res.unwrap(), "srv");
+        format!("{:?}", srv2);
 
         assert_eq!(lazy(|cx| srv2.poll_shutdown(cx)).await, Poll::Ready(()));
     }

ntex-service/src/fn_shutdown.rs

@@ -1,7 +1,5 @@
-use std::cell::Cell;
-use std::future::{ready, Ready};
-use std::marker::PhantomData;
 use std::task::{Context, Poll};
+use std::{cell::Cell, fmt, future::ready, future::Ready, marker::PhantomData};
 
 use crate::{Service, ServiceCtx};
 
@@ -43,6 +41,14 @@ where
     }
 }
 
+impl<Req, Err, F> fmt::Debug for FnShutdown<Req, Err, F> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("FnShutdown")
+            .field("fn", &std::any::type_name::<F>())
+            .finish()
+    }
+}
+
 impl<Req, Err, F> Service<Req> for FnShutdown<Req, Err, F>
 where
     F: FnOnce(),
@@ -91,5 +97,7 @@ mod tests {
         assert_eq!(res.unwrap(), "pipe");
         assert_eq!(lazy(|cx| pipe.poll_shutdown(cx)).await, Poll::Ready(()));
         assert!(is_called.get());
+
+        format!("{:?}", pipe);
     }
 }

ntex-service/src/lib.rs

@@ -1,6 +1,10 @@
 //! See [`Service`] docs for information on this crate's foundational trait.
-
-#![deny(rust_2018_idioms, warnings)]
+#![deny(
+    rust_2018_idioms,
+    warnings,
+    unreachable_pub,
+    missing_debug_implementations
+)]
 
 use std::future::Future;
 use std::rc::Rc;

ntex-service/src/map.rs

@@ -1,4 +1,4 @@
-use std::{future::Future, marker::PhantomData, pin::Pin, task::Context, task::Poll};
+use std::{fmt, future::Future, marker::PhantomData, pin::Pin, task::Context, task::Poll};
 
 use super::{Service, ServiceCall, ServiceCtx, ServiceFactory};
 
@@ -41,6 +41,18 @@ where
     }
 }
 
+impl<A, F, Req, Res> fmt::Debug for Map<A, F, Req, Res>
+where
+    A: fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Map")
+            .field("service", &self.service)
+            .field("map", &std::any::type_name::<F>())
+            .finish()
+    }
+}
+
 impl<A, F, Req, Res> Service<Req> for Map<A, F, Req, Res>
 where
     A: Service<Req>,
@@ -133,6 +145,18 @@ where
     }
 }
 
+impl<A, F, Req, Res, Cfg> fmt::Debug for MapFactory<A, F, Req, Res, Cfg>
+where
+    A: fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("MapFactory")
+            .field("factory", &self.a)
+            .field("map", &std::any::type_name::<F>())
+            .finish()
+    }
+}
+
 impl<A, F, Req, Res, Cfg> ServiceFactory<Req, Cfg> for MapFactory<A, F, Req, Res, Cfg>
 where
     A: ServiceFactory<Req, Cfg>,
@@ -194,7 +218,7 @@ mod tests {
     use super::*;
     use crate::{fn_factory, Pipeline, Service, ServiceCtx, ServiceFactory};
 
-    #[derive(Clone)]
+    #[derive(Debug, Clone)]
     struct Srv;
 
     impl Service<()> for Srv {
@@ -223,6 +247,8 @@ mod tests {
 
         let res = lazy(|cx| srv.poll_shutdown(cx)).await;
         assert_eq!(res, Poll::Ready(()));
+
+        format!("{:?}", srv);
     }
 
     #[ntex::test]
@@ -248,6 +274,8 @@ mod tests {
         let res = srv.call(()).await;
         assert!(res.is_ok());
         assert_eq!(res.unwrap(), ("ok"));
+
+        format!("{:?}", new_srv);
     }
 
     #[ntex::test]
@@ -259,5 +287,7 @@ mod tests {
         let res = srv.call(()).await;
         assert!(res.is_ok());
         assert_eq!(res.unwrap(), ("ok"));
+
+        format!("{:?}", new_srv);
     }
 }

ntex-service/src/map_config.rs

@@ -1,4 +1,4 @@
-use std::{future::Future, marker::PhantomData, pin::Pin, task::Context, task::Poll};
+use std::{fmt, future::Future, marker::PhantomData, pin::Pin, task::Context, task::Poll};
 
 use super::{IntoServiceFactory, ServiceFactory};
 
@@ -56,6 +56,18 @@ where
     }
 }
 
+impl<A, F, C, C2> fmt::Debug for MapConfig<A, F, C, C2>
+where
+    A: fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("MapConfig")
+            .field("factory", &self.a)
+            .field("map", &std::any::type_name::<F>())
+            .finish()
+    }
+}
+
 impl<A, F, R, C, C2> ServiceFactory<R, C> for MapConfig<A, F, C, C2>
 where
     A: ServiceFactory<R, C2>,
@@ -74,24 +86,16 @@ where
     }
 }
 
+#[derive(Clone, Debug)]
 /// `unit_config()` config combinator
 pub struct UnitConfig<A> {
-    a: A,
+    factory: A,
 }
 
 impl<A> UnitConfig<A> {
     /// Create new `UnitConfig` combinator
-    pub(crate) fn new(a: A) -> Self {
-        Self { a }
-    }
-}
-
-impl<A> Clone for UnitConfig<A>
-where
-    A: Clone,
-{
-    fn clone(&self) -> Self {
-        Self { a: self.a.clone() }
+    pub(crate) fn new(factory: A) -> Self {
+        Self { factory }
     }
 }
 
@@ -108,7 +112,7 @@ where
 
     fn create(&self, _: C) -> Self::Future<'_> {
         UnitConfigFuture {
-            fut: self.a.create(()),
+            fut: self.factory.create(()),
             _t: PhantomData,
         }
     }
@@ -161,6 +165,7 @@ mod tests {
 
         let _ = factory.create(&10).await;
         assert_eq!(item.get(), 11);
+        format!("{:?}", factory);
     }
 
     #[ntex::test]

ntex-service/src/map_err.rs

@@ -1,4 +1,4 @@
-use std::{future::Future, marker::PhantomData, pin::Pin, task::Context, task::Poll};
+use std::{fmt, future::Future, marker::PhantomData, pin::Pin, task::Context, task::Poll};
 
 use super::{Service, ServiceCall, ServiceCtx, ServiceFactory};
 
@@ -42,6 +42,18 @@ where
     }
 }
 
+impl<A, F, E> fmt::Debug for MapErr<A, F, E>
+where
+    A: fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("MapErr")
+            .field("svc", &self.service)
+            .field("map", &std::any::type_name::<F>())
+            .finish()
+    }
+}
+
 impl<A, R, F, E> Service<R> for MapErr<A, F, E>
 where
     A: Service<R>,
@@ -138,6 +150,19 @@ where
     }
 }
 
+impl<A, R, C, F, E> fmt::Debug for MapErrFactory<A, R, C, F, E>
+where
+    A: ServiceFactory<R, C> + fmt::Debug,
+    F: Fn(A::Error) -> E + Clone,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("MapErrFactory")
+            .field("factory", &self.a)
+            .field("map", &std::any::type_name::<F>())
+            .finish()
+    }
+}
+
 impl<A, R, C, F, E> ServiceFactory<R, C> for MapErrFactory<A, R, C, F, E>
 where
     A: ServiceFactory<R, C>,
@@ -198,7 +223,7 @@ mod tests {
     use super::*;
     use crate::{fn_factory, Pipeline, Service, ServiceCtx, ServiceFactory};
 
-    #[derive(Clone)]
+    #[derive(Debug, Clone)]
     struct Srv(bool);
 
     impl Service<()> for Srv {
@@ -235,6 +260,8 @@ mod tests {
         let res = srv.call(()).await;
         assert!(res.is_err());
         assert_eq!(res.err().unwrap(), "error");
+
+        format!("{:?}", srv);
     }
 
     #[ntex::test]
@@ -243,6 +270,8 @@ mod tests {
         let res = srv.call(()).await;
         assert!(res.is_err());
         assert_eq!(res.err().unwrap(), "error");
+
+        format!("{:?}", srv);
     }
 
     #[ntex::test]
@@ -254,6 +283,7 @@ mod tests {
         let res = srv.call(()).await;
         assert!(res.is_err());
         assert_eq!(res.err().unwrap(), "error");
+        format!("{:?}", new_srv);
     }
 
     #[ntex::test]
@@ -266,5 +296,6 @@ mod tests {
         let res = srv.call(()).await;
         assert!(res.is_err());
         assert_eq!(res.err().unwrap(), "error");
+        format!("{:?}", new_srv);
     }
 }

ntex-service/src/map_init_err.rs

@@ -1,4 +1,4 @@
-use std::{future::Future, marker::PhantomData, pin::Pin, task::Context, task::Poll};
+use std::{fmt, future::Future, marker::PhantomData, pin::Pin, task::Context, task::Poll};
 
 use super::ServiceFactory;
 
@@ -38,6 +38,18 @@ where
     }
 }
 
+impl<A, R, C, F, E> fmt::Debug for MapInitErr<A, R, C, F, E>
+where
+    A: fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("MapInitErr")
+            .field("service", &self.a)
+            .field("map", &std::any::type_name::<F>())
+            .finish()
+    }
+}
+
 impl<A, R, C, F, E> ServiceFactory<R, C> for MapInitErr<A, R, C, F, E>
 where
     A: ServiceFactory<R, C>,
@@ -108,6 +120,7 @@ mod tests {
 
         assert!(factory.create(&true).await.is_err());
         assert!(factory.create(&false).await.is_ok());
+        format!("{:?}", factory);
     }
 
     #[ntex::test]
@@ -127,5 +140,6 @@ mod tests {
 
         assert!(factory.create(&true).await.is_err());
         assert!(factory.create(&false).await.is_ok());
+        format!("{:?}", factory);
     }
 }

ntex-service/src/middleware.rs

@@ -1,4 +1,4 @@
-use std::{future::Future, marker, pin::Pin, rc::Rc, task::Context, task::Poll};
+use std::{fmt, future::Future, marker, pin::Pin, rc::Rc, task::Context, task::Poll};
 
 use crate::{IntoServiceFactory, Service, ServiceFactory};
 
@@ -113,6 +113,19 @@ impl<T, S, C> Clone for ApplyMiddleware<T, S, C> {
     }
 }
 
+impl<T, S, C> fmt::Debug for ApplyMiddleware<T, S, C>
+where
+    T: fmt::Debug,
+    S: fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("ApplyMiddleware")
+            .field("service", &self.0 .1)
+            .field("middleware", &self.0 .0)
+            .finish()
+    }
+}
+
 impl<T, S, R, C> ServiceFactory<R, C> for ApplyMiddleware<T, S, C>
 where
     S: ServiceFactory<R, C>,
@@ -216,7 +229,7 @@ mod tests {
     use super::*;
     use crate::{fn_service, Pipeline, Service, ServiceCall, ServiceCtx, ServiceFactory};
 
-    #[derive(Clone)]
+    #[derive(Debug, Clone)]
     struct Tr<R>(marker::PhantomData<R>);
 
     impl<S, R> Middleware<S> for Tr<R> {
@@ -227,7 +240,7 @@ mod tests {
         }
     }
 
-    #[derive(Clone)]
+    #[derive(Debug, Clone)]
     struct Srv<S, R>(S, marker::PhantomData<R>);
 
     impl<S: Service<R>, R> Service<R> for Srv<S, R> {
@@ -256,6 +269,7 @@ mod tests {
         let res = srv.call(10).await;
         assert!(res.is_ok());
         assert_eq!(res.unwrap(), 20);
+        format!("{:?} {:?}", factory, srv);
 
         let res = lazy(|cx| srv.poll_ready(cx)).await;
         assert_eq!(res, Poll::Ready(Ok(())));
@@ -272,6 +286,7 @@ mod tests {
         let res = srv.call(10).await;
         assert!(res.is_ok());
         assert_eq!(res.unwrap(), 20);
+        format!("{:?} {:?}", factory, srv);
 
         let res = lazy(|cx| srv.poll_ready(cx)).await;
         assert_eq!(res, Poll::Ready(Ok(())));

ntex-service/src/pipeline.rs

@@ -2,6 +2,7 @@ use std::{cell::Cell, future, pin::Pin, rc::Rc, task, task::Context, task::Poll}
 
 use crate::{ctx::ServiceCall, ctx::Waiters, Service, ServiceCtx, ServiceFactory};
 
+#[derive(Debug)]
 /// Container for a service.
 ///
 /// Container allows to call enclosed service and adds support of shared readiness.

ntex-service/src/then.rs

@@ -2,6 +2,7 @@ use std::{future::Future, pin::Pin, task::Context, task::Poll};
 
 use super::{Service, ServiceCall, ServiceCtx, ServiceFactory};
 
+#[derive(Debug, Clone)]
 /// Service for the `then` combinator, chaining a computation onto the end of
 /// another service.
 ///
@@ -18,19 +19,6 @@ impl<A, B> Then<A, B> {
     }
 }
 
-impl<A, B> Clone for Then<A, B>
-where
-    A: Clone,
-    B: Clone,
-{
-    fn clone(&self) -> Self {
-        Then {
-            svc1: self.svc1.clone(),
-            svc2: self.svc2.clone(),
-        }
-    }
-}
-
 impl<A, B, R> Service<R> for Then<A, B>
 where
     A: Service<R>,
@@ -131,6 +119,7 @@ where
     }
 }
 
+#[derive(Debug, Clone)]
 /// `.then()` service factory combinator
 pub struct ThenFactory<A, B> {
     svc1: A,
@@ -172,19 +161,6 @@ where
     }
 }
 
-impl<A, B> Clone for ThenFactory<A, B>
-where
-    A: Clone,
-    B: Clone,
-{
-    fn clone(&self) -> Self {
-        Self {
-            svc1: self.svc1.clone(),
-            svc2: self.svc2.clone(),
-        }
-    }
-}
-
 pin_project_lite::pin_project! {
     #[must_use = "futures do nothing unless polled"]
     pub struct ThenFactoryResponse<'f, A, B, R, C>