From b71ca411ab310cc3af339a303fa6f9c5b3042fb3 Mon Sep 17 00:00:00 2001
From: Rob Ede <robjtede@icloud.com>
Date: Wed, 22 Dec 2021 08:11:49 +0000
Subject: [PATCH] add noop middleware for testing

---
 src/middleware/mod.rs  |  4 ++++
 src/middleware/noop.rs | 37 +++++++++++++++++++++++++++++++++++++
 2 files changed, 41 insertions(+)
 create mode 100644 src/middleware/noop.rs

diff --git a/src/middleware/mod.rs b/src/middleware/mod.rs
index 0da9b9b2e..a781052a6 100644
--- a/src/middleware/mod.rs
+++ b/src/middleware/mod.rs
@@ -5,6 +5,8 @@ mod condition;
 mod default_headers;
 mod err_handlers;
 mod logger;
+#[cfg(test)]
+mod noop;
 mod normalize;
 
 pub use self::compat::Compat;
@@ -12,6 +14,8 @@ pub use self::condition::Condition;
 pub use self::default_headers::DefaultHeaders;
 pub use self::err_handlers::{ErrorHandlerResponse, ErrorHandlers};
 pub use self::logger::Logger;
+#[cfg(test)]
+pub(crate) use self::noop::Noop;
 pub use self::normalize::{NormalizePath, TrailingSlash};
 
 #[cfg(feature = "__compress")]
diff --git a/src/middleware/noop.rs b/src/middleware/noop.rs
new file mode 100644
index 000000000..ae7da1d81
--- /dev/null
+++ b/src/middleware/noop.rs
@@ -0,0 +1,37 @@
+//! A no-op middleware. See [Noop] for docs.
+
+use actix_utils::future::{ready, Ready};
+
+use crate::dev::{Service, Transform};
+
+/// A no-op middleware that passes through request and response untouched.
+pub(crate) struct Noop;
+
+impl<S: Service<Req>, Req> Transform<S, Req> for Noop {
+    type Response = S::Response;
+    type Error = S::Error;
+    type Transform = NoopService<S>;
+    type InitError = ();
+    type Future = Ready<Result<Self::Transform, Self::InitError>>;
+
+    fn new_transform(&self, service: S) -> Self::Future {
+        ready(Ok(NoopService { service }))
+    }
+}
+
+#[doc(hidden)]
+pub(crate) struct NoopService<S> {
+    service: S,
+}
+
+impl<S: Service<Req>, Req> Service<Req> for NoopService<S> {
+    type Response = S::Response;
+    type Error = S::Error;
+    type Future = S::Future;
+
+    crate::dev::forward_ready!(service);
+
+    fn call(&self, req: Req) -> Self::Future {
+        self.service.call(req)
+    }
+}