Add a test for the TransformMiddleware

Just to see it's useable with the type conversions.

Author: Thomasdezeeuw

http/tests/functional.rs

@@ -24,5 +24,6 @@ mod functional {
     mod route;
     mod server;
     mod status_code;
+    mod transform;
     mod version;
 }

http/tests/functional/transform.rs

@@ -0,0 +1,98 @@
+//! Tests for the transform module.
+
+use heph::test;
+use heph_http::body::OneshotBody;
+use heph_http::handler::{Handler, Middleware};
+use heph_http::transform::{Body, Cloned, Path, TransformMiddleware};
+use heph_http::{Header, HeaderName, Headers, Method, Request, Response, StatusCode, Version};
+
+const REQ_BODY: &'static str = "test_body";
+const OK_BODY: &'static str = "good";
+const BAD_BODY: &'static str = "bad";
+const HOST: &'static str = "localhost";
+
+type TestBody = OneshotBody<'static>;
+
+struct Error(&'static str);
+
+impl From<Error> for Response<TestBody> {
+    fn from(err: Error) -> Response<TestBody> {
+        Response::bad_request().with_body(err.0.into())
+    }
+}
+
+struct Text(&'static str);
+
+impl From<Text> for Response<TestBody> {
+    fn from(txt: Text) -> Response<TestBody> {
+        Response::ok().with_body(txt.0.into())
+    }
+}
+
+#[test]
+fn transform_middleware() {
+    // Test the type conversion in `TransformMiddleware`.
+
+    async fn handler(
+        method: Method,
+        cloned_path: Cloned<Path>,
+        path: Path,
+        version: Version,
+        cloned_headers: Cloned<Headers>,
+        headers: Headers,
+        cloned_body: Cloned<Body<TestBody>>,
+        body: Body<TestBody>,
+    ) -> Result<Text, Error> {
+        assert_eq!(method, Method::Get);
+        assert_eq!((cloned_path.0).0, path.0);
+        assert_eq!(version, Version::Http11);
+        let cloned_headers = cloned_headers.0;
+        assert_eq!(cloned_headers.len(), 1);
+        assert_eq!(headers.len(), 1);
+        assert_eq!(
+            cloned_headers
+                .get_value::<&str>(&HeaderName::HOST)
+                .unwrap()
+                .unwrap(),
+            HOST,
+        );
+        assert_eq!(
+            headers
+                .get_value::<&str>(&HeaderName::HOST)
+                .unwrap()
+                .unwrap(),
+            HOST,
+        );
+        assert_eq!((cloned_body.0).0, REQ_BODY);
+        assert_eq!(body.0, REQ_BODY);
+
+        if path.0 == "/ok" {
+            Ok(Text(OK_BODY))
+        } else {
+            Err(Error(BAD_BODY))
+        }
+    }
+
+    let middleware = TransformMiddleware::wrap(handler);
+
+    let tests = [
+        ("/ok", StatusCode::OK, OK_BODY),
+        ("/error", StatusCode::BAD_REQUEST, BAD_BODY),
+    ];
+    for (path, expected_status, expected_body) in tests {
+        let request = Request::new(
+            Method::Get,
+            path.into(),
+            Version::Http11,
+            {
+                let mut headers = Headers::EMPTY;
+                headers.append(Header::new(HeaderName::HOST, HOST.as_bytes()));
+                headers
+            },
+            TestBody::from(REQ_BODY),
+        );
+        let response: Response<TestBody> = test::block_on(middleware.handle(request));
+        assert_eq!(response.status(), expected_status);
+        assert_eq!(response.body(), expected_body);
+    }
+}