move messagebody impl tests

actix-http/CHANGES.md

@@ -15,6 +15,7 @@
 
 ### Removed
 * Remove unnecessary `MessageBody` bound on types passed to `body::AnyBody::new`. [#2468]
+* Move `body::AnyBody` to `awc`. Replaced with `EitherBody` and `BoxBody`. [#2468]
 
 [#2483]: https://github.com/actix/actix-web/pull/2483
 [#2468]: https://github.com/actix/actix-web/pull/2468

actix-http/src/body/message_body.rs

@@ -29,6 +29,9 @@ pub trait MessageBody {
     ) -> Poll<Option<Result<Bytes, Self::Error>>>;
 }
 
+mod foreign_impls {
+    use super::*;
+
     impl MessageBody for Infallible {
         type Error = Infallible;
 
@@ -232,6 +235,7 @@ impl MessageBody for bytestring::ByteString {
             Poll::Ready(Some(Ok(string.into_bytes())))
         }
     }
+}
 
 pin_project! {
     pub(crate) struct MessageBodyMapErr<B, F> {
@@ -283,3 +287,129 @@ where
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use actix_rt::pin;
+    use actix_utils::future::poll_fn;
+    use bytes::{Bytes, BytesMut};
+
+    use super::*;
+
+    macro_rules! assert_poll_next {
+        ($pin:expr, $exp:expr) => {
+            assert_eq!(
+                poll_fn(|cx| $pin.as_mut().poll_next(cx))
+                    .await
+                    .unwrap() // unwrap option
+                    .unwrap(), // unwrap result
+                $exp
+            );
+        };
+    }
+
+    macro_rules! assert_poll_next_none {
+        ($pin:expr) => {
+            assert!(poll_fn(|cx| $pin.as_mut().poll_next(cx)).await.is_none());
+        };
+    }
+
+    #[actix_rt::test]
+    async fn boxing_equivalence() {
+        assert_eq!(().size(), BodySize::Sized(0));
+        assert_eq!(().size(), Box::new(()).size());
+        assert_eq!(().size(), Box::pin(()).size());
+
+        let pl = Box::new(());
+        pin!(pl);
+        assert_poll_next_none!(pl);
+
+        let mut pl = Box::pin(());
+        assert_poll_next_none!(pl);
+    }
+
+    #[actix_rt::test]
+    async fn test_unit() {
+        let pl = ();
+        assert_eq!(pl.size(), BodySize::Sized(0));
+        pin!(pl);
+        assert_poll_next_none!(pl);
+    }
+
+    #[actix_rt::test]
+    async fn test_static_str() {
+        assert_eq!("".size(), BodySize::Sized(0));
+        assert_eq!("test".size(), BodySize::Sized(4));
+
+        let pl = "test";
+        pin!(pl);
+        assert_poll_next!(pl, Bytes::from("test"));
+    }
+
+    #[actix_rt::test]
+    async fn test_static_bytes() {
+        assert_eq!(b"".as_ref().size(), BodySize::Sized(0));
+        assert_eq!(b"test".as_ref().size(), BodySize::Sized(4));
+
+        let pl = b"test".as_ref();
+        pin!(pl);
+        assert_poll_next!(pl, Bytes::from("test"));
+    }
+
+    #[actix_rt::test]
+    async fn test_vec() {
+        assert_eq!(vec![0; 0].size(), BodySize::Sized(0));
+        assert_eq!(Vec::from("test").size(), BodySize::Sized(4));
+
+        let pl = Vec::from("test");
+        pin!(pl);
+        assert_poll_next!(pl, Bytes::from("test"));
+    }
+
+    #[actix_rt::test]
+    async fn test_bytes() {
+        assert_eq!(Bytes::new().size(), BodySize::Sized(0));
+        assert_eq!(Bytes::from_static(b"test").size(), BodySize::Sized(4));
+
+        let pl = Bytes::from_static(b"test");
+        pin!(pl);
+        assert_poll_next!(pl, Bytes::from("test"));
+    }
+
+    #[actix_rt::test]
+    async fn test_bytes_mut() {
+        assert_eq!(BytesMut::new().size(), BodySize::Sized(0));
+        assert_eq!(BytesMut::from(b"test".as_ref()).size(), BodySize::Sized(4));
+
+        let pl = BytesMut::from("test");
+        pin!(pl);
+        assert_poll_next!(pl, Bytes::from("test"));
+    }
+
+    #[actix_rt::test]
+    async fn test_string() {
+        assert_eq!(String::new().size(), BodySize::Sized(0));
+        assert_eq!("test".to_owned().size(), BodySize::Sized(4));
+
+        let pl = "test".to_owned();
+        pin!(pl);
+        assert_poll_next!(pl, Bytes::from("test"));
+    }
+
+    // down-casting used to be done with a method on MessageBody trait
+    // test is kept to demonstrate equivalence of Any trait
+    #[actix_rt::test]
+    async fn test_body_casting() {
+        let mut body = String::from("hello cast");
+        // let mut resp_body: &mut dyn MessageBody<Error = Error> = &mut body;
+        let resp_body: &mut dyn std::any::Any = &mut body;
+        let body = resp_body.downcast_ref::<String>().unwrap();
+        assert_eq!(body, "hello cast");
+        let body = &mut resp_body.downcast_mut::<String>().unwrap();
+        body.push('!');
+        let body = resp_body.downcast_ref::<String>().unwrap();
+        assert_eq!(body, "hello cast!");
+        let not_body = resp_body.downcast_ref::<()>();
+        assert!(not_body.is_none());
+    }
+}

actix-http/src/body/mod.rs

@@ -18,162 +18,3 @@ pub use self::none::None;
 pub use self::size::BodySize;
 pub use self::sized_stream::SizedStream;
 pub use self::utils::to_bytes;
-
-#[cfg(test)]
-mod tests {
-    use std::pin::Pin;
-
-    use actix_rt::pin;
-    use actix_utils::future::poll_fn;
-    use bytes::{Bytes, BytesMut};
-
-    use super::*;
-
-    /// AnyBody alias because rustc does not (can not?) infer the default type parameter.
-    type AnyBody = Bytes;
-
-    #[actix_rt::test]
-    async fn test_static_str() {
-        assert_eq!(AnyBody::from("").size(), BodySize::Sized(0));
-        assert_eq!(AnyBody::from("test").size(), BodySize::Sized(4));
-
-        assert_eq!("test".size(), BodySize::Sized(4));
-        assert_eq!(
-            poll_fn(|cx| Pin::new(&mut "test").poll_next(cx))
-                .await
-                .unwrap()
-                .ok(),
-            Some(Bytes::from("test"))
-        );
-    }
-
-    #[actix_rt::test]
-    async fn test_static_bytes() {
-        assert_eq!(AnyBody::from(b"test".as_ref()).size(), BodySize::Sized(4));
-        assert_eq!(
-            AnyBody::copy_from_slice(b"test".as_ref()).size(),
-            BodySize::Sized(4)
-        );
-        let sb = Bytes::from(&b"test"[..]);
-        pin!(sb);
-
-        assert_eq!(sb.size(), BodySize::Sized(4));
-        assert_eq!(
-            poll_fn(|cx| sb.as_mut().poll_next(cx)).await.unwrap().ok(),
-            Some(Bytes::from("test"))
-        );
-    }
-
-    #[actix_rt::test]
-    async fn test_vec() {
-        assert_eq!(AnyBody::from(Vec::from("test")).size(), BodySize::Sized(4));
-        let test_vec = Vec::from("test");
-        pin!(test_vec);
-
-        assert_eq!(test_vec.size(), BodySize::Sized(4));
-        assert_eq!(
-            poll_fn(|cx| test_vec.as_mut().poll_next(cx))
-                .await
-                .unwrap()
-                .ok(),
-            Some(Bytes::from("test"))
-        );
-    }
-
-    #[actix_rt::test]
-    async fn test_bytes() {
-        let b = Bytes::from("test");
-        assert_eq!(AnyBody::from(b.clone()).size(), BodySize::Sized(4));
-
-        pin!(b);
-
-        assert_eq!(b.size(), BodySize::Sized(4));
-        assert_eq!(
-            poll_fn(|cx| b.as_mut().poll_next(cx)).await.unwrap().ok(),
-            Some(Bytes::from("test"))
-        );
-    }
-
-    #[actix_rt::test]
-    async fn test_bytes_mut() {
-        let b = BytesMut::from("test");
-        assert_eq!(AnyBody::from(b.clone()).size(), BodySize::Sized(4));
-        pin!(b);
-
-        assert_eq!(b.size(), BodySize::Sized(4));
-        assert_eq!(
-            poll_fn(|cx| b.as_mut().poll_next(cx)).await.unwrap().ok(),
-            Some(Bytes::from("test"))
-        );
-    }
-
-    #[actix_rt::test]
-    async fn test_string() {
-        let b = "test".to_owned();
-        assert_eq!(AnyBody::from(b.clone()).size(), BodySize::Sized(4));
-        // assert_eq!(AnyBody::from(&b).size(), BodySize::Sized(4));
-
-        pin!(b);
-        assert_eq!(b.size(), BodySize::Sized(4));
-        assert_eq!(
-            poll_fn(|cx| b.as_mut().poll_next(cx)).await.unwrap().ok(),
-            Some(Bytes::from("test"))
-        );
-    }
-
-    #[actix_rt::test]
-    async fn test_unit() {
-        assert_eq!(().size(), BodySize::Sized(0));
-        assert!(poll_fn(|cx| Pin::new(&mut ()).poll_next(cx))
-            .await
-            .is_none());
-    }
-
-    #[actix_rt::test]
-    async fn test_box_and_pin() {
-        let val = Box::new(());
-        pin!(val);
-        assert_eq!(val.size(), BodySize::Sized(0));
-        assert!(poll_fn(|cx| val.as_mut().poll_next(cx)).await.is_none());
-
-        let mut val = Box::pin(());
-        assert_eq!(val.size(), BodySize::Sized(0));
-        assert!(poll_fn(|cx| val.as_mut().poll_next(cx)).await.is_none());
-    }
-
-    #[actix_rt::test]
-    async fn test_serde_json() {
-        use serde_json::{json, Value};
-        assert_eq!(
-            AnyBody::from(
-                serde_json::to_vec(&Value::String("test".to_owned())).unwrap()
-            )
-            .size(),
-            BodySize::Sized(6)
-        );
-        assert_eq!(
-            AnyBody::from(
-                serde_json::to_vec(&json!({"test-key":"test-value"})).unwrap()
-            )
-            .size(),
-            BodySize::Sized(25)
-        );
-    }
-
-    // down-casting used to be done with a method on MessageBody trait
-    // test is kept to demonstrate equivalence of Any trait
-    #[actix_rt::test]
-    async fn test_body_casting() {
-        let mut body = String::from("hello cast");
-        // let mut resp_body: &mut dyn MessageBody<Error = Error> = &mut body;
-        let resp_body: &mut dyn std::any::Any = &mut body;
-        let body = resp_body.downcast_ref::<String>().unwrap();
-        assert_eq!(body, "hello cast");
-        let body = &mut resp_body.downcast_mut::<String>().unwrap();
-        body.push('!');
-        let body = resp_body.downcast_ref::<String>().unwrap();
-        assert_eq!(body, "hello cast!");
-        let not_body = resp_body.downcast_ref::<()>();
-        assert!(not_body.is_none());
-    }
-}