Merge pull request #4 from jtgeibel/use-http-types

Bump to latest conduit alpha and use `http` types

Author: jtgeibel

Cargo.toml

@@ -9,5 +9,4 @@ repository = "https://github.com/conduit-rust/conduit-middleware"
 license = "MIT"
 
 [dependencies]
-conduit = "0.9.0-alpha.0"
-semver = "0.9"
+conduit = "0.9.0-alpha.1"

src/lib.rs

@@ -1,20 +1,17 @@
 #![warn(rust_2018_idioms)]
 extern crate conduit;
 
-use std::error::Error;
+use conduit::{BoxError, Handler, RequestExt};
 
-use conduit::{Handler, Request, Response};
+pub type BeforeResult = Result<(), BoxError>;
+pub type AfterResult = conduit::HandlerResult;
 
 pub trait Middleware: Send + Sync + 'static {
-    fn before(&self, _: &mut dyn Request) -> Result<(), Box<dyn Error + Send>> {
+    fn before(&self, _: &mut dyn RequestExt) -> BeforeResult {
         Ok(())
     }
 
-    fn after(
-        &self,
-        _: &mut dyn Request,
-        res: Result<Response, Box<dyn Error + Send>>,
-    ) -> Result<Response, Box<dyn Error + Send>> {
+    fn after(&self, _: &mut dyn RequestExt, res: AfterResult) -> AfterResult {
         res
     }
 }
@@ -49,7 +46,7 @@ impl MiddlewareBuilder {
 }
 
 impl Handler for MiddlewareBuilder {
-    fn call(&self, req: &mut dyn Request) -> Result<Response, Box<dyn Error + Send>> {
+    fn call(&self, req: &mut dyn RequestExt) -> AfterResult {
         let mut error = None;
 
         for (i, middleware) in self.middlewares.iter().enumerate() {
@@ -79,9 +76,9 @@ impl Handler for MiddlewareBuilder {
 
 fn run_afters(
     middleware: &[Box<dyn Middleware>],
-    req: &mut dyn Request,
-    res: Result<Response, Box<dyn Error + Send>>,
-) -> Result<Response, Box<dyn Error + Send>> {
+    req: &mut dyn RequestExt,
+    res: AfterResult,
+) -> AfterResult {
     middleware
         .iter()
         .rev()
@@ -90,20 +87,17 @@ fn run_afters(
 
 #[cfg(test)]
 mod tests {
-    extern crate semver;
-
-    use {AroundMiddleware, Middleware, MiddlewareBuilder};
+    use {AfterResult, AroundMiddleware, BeforeResult, Middleware, MiddlewareBuilder};
 
     use std::any::Any;
-    use std::collections::HashMap;
-    use std::error::Error;
+    use std::io;
     use std::io::prelude::*;
-    use std::io::{self, Cursor};
     use std::net::SocketAddr;
 
-    use conduit;
-    use conduit::{Extensions, Headers, Host, Method, Request, Response, Scheme};
-    use conduit::{Handler, TypeMap};
+    use conduit::{
+        box_error, static_to_body, vec_to_body, Body, Extensions, Handler, HeaderMap, Host, Method,
+        RequestExt, Response, Scheme, StatusCode, TypeMap, Version,
+    };
 
     struct RequestSentinel {
         path: String,
@@ -121,15 +115,12 @@ mod tests {
         }
     }
 
-    impl conduit::Request for RequestSentinel {
-        fn http_version(&self) -> semver::Version {
-            unimplemented!()
-        }
-        fn conduit_version(&self) -> semver::Version {
+    impl conduit::RequestExt for RequestSentinel {
+        fn http_version(&self) -> Version {
             unimplemented!()
         }
-        fn method(&self) -> Method {
-            self.method.clone()
+        fn method(&self) -> &Method {
+            &self.method
         }
         fn scheme(&self) -> Scheme {
             unimplemented!()
@@ -152,7 +143,7 @@ mod tests {
         fn content_length(&self) -> Option<u64> {
             unimplemented!()
         }
-        fn headers<'a>(&'a self) -> &'a dyn Headers {
+        fn headers(&self) -> &HeaderMap {
             unimplemented!()
         }
         fn body<'a>(&'a mut self) -> &'a mut dyn Read {
@@ -169,7 +160,7 @@ mod tests {
     struct MyMiddleware;
 
     impl Middleware for MyMiddleware {
-        fn before<'a>(&self, req: &'a mut dyn Request) -> Result<(), Box<dyn Error + Send>> {
+        fn before<'a>(&self, req: &'a mut dyn RequestExt) -> BeforeResult {
             req.mut_extensions().insert("hello".to_string());
             Ok(())
         }
@@ -178,43 +169,32 @@ mod tests {
     struct ErrorRecovery;
 
     impl Middleware for ErrorRecovery {
-        fn after(
-            &self,
-            _: &mut dyn Request,
-            res: Result<Response, Box<dyn Error + Send>>,
-        ) -> Result<Response, Box<dyn Error + Send>> {
+        fn after(&self, _: &mut dyn RequestExt, res: AfterResult) -> AfterResult {
             res.or_else(|e| {
-                let e = e.to_string();
-                Ok(Response {
-                    status: (500, "Internal Server Error"),
-                    headers: HashMap::new(),
-                    body: Box::new(Cursor::new(e.into_bytes())),
-                })
+                let e = e.to_string().into_bytes();
+                Response::builder()
+                    .status(StatusCode::INTERNAL_SERVER_ERROR)
+                    .body(vec_to_body(e))
+                    .map_err(box_error)
             })
         }
     }
 
     struct ProducesError;
 
     impl Middleware for ProducesError {
-        fn before(&self, _: &mut dyn Request) -> Result<(), Box<dyn Error + Send>> {
+        fn before(&self, _: &mut dyn RequestExt) -> BeforeResult {
             Err(Box::new(io::Error::new(io::ErrorKind::Other, "")))
         }
     }
 
     struct NotReached;
 
     impl Middleware for NotReached {
-        fn after(
-            &self,
-            _: &mut dyn Request,
-            _: Result<Response, Box<dyn Error + Send>>,
-        ) -> Result<Response, Box<dyn Error + Send>> {
-            Ok(Response {
-                status: (200, "OK"),
-                headers: HashMap::new(),
-                body: Box::new(Cursor::new(vec![])),
-            })
+        fn after(&self, _: &mut dyn RequestExt, _: AfterResult) -> AfterResult {
+            Response::builder()
+                .body(static_to_body(b""))
+                .map_err(box_error)
         }
     }
 
@@ -237,34 +217,32 @@ mod tests {
     }
 
     impl Handler for MyAroundMiddleware {
-        fn call(&self, req: &mut dyn Request) -> Result<Response, Box<dyn Error + Send>> {
+        fn call(&self, req: &mut dyn RequestExt) -> AfterResult {
             req.mut_extensions().insert("hello".to_string());
             self.handler.as_ref().unwrap().call(req)
         }
     }
 
-    fn get_extension<'a, T: Any>(req: &'a dyn Request) -> &'a T {
+    fn get_extension<'a, T: Any>(req: &'a dyn RequestExt) -> &'a T {
         req.extensions().find::<T>().unwrap()
     }
 
-    fn response(string: String) -> Response {
-        Response {
-            status: (200, "OK"),
-            headers: HashMap::new(),
-            body: Box::new(Cursor::new(string.into_bytes())),
-        }
+    fn response(string: String) -> Response<Body> {
+        Response::builder()
+            .body(vec_to_body(string.into_bytes()))
+            .unwrap()
     }
 
-    fn handler(req: &mut dyn Request) -> io::Result<Response> {
+    fn handler(req: &mut dyn RequestExt) -> io::Result<Response<Body>> {
         let hello = get_extension::<String>(req);
         Ok(response(hello.clone()))
     }
 
-    fn error_handler(_: &mut dyn Request) -> io::Result<Response> {
+    fn error_handler(_: &mut dyn RequestExt) -> io::Result<Response<Body>> {
         Err(io::Error::new(io::ErrorKind::Other, "Error in handler"))
     }
 
-    fn middle_handler(req: &mut dyn Request) -> io::Result<Response> {
+    fn middle_handler(req: &mut dyn RequestExt) -> io::Result<Response<Body>> {
         let hello = get_extension::<String>(req);
         let middle = get_extension::<String>(req);
 
@@ -276,11 +254,11 @@ mod tests {
         let mut builder = MiddlewareBuilder::new(handler);
         builder.add(MyMiddleware);
 
-        let mut req = RequestSentinel::new(Method::Get, "/");
+        let mut req = RequestSentinel::new(Method::GET, "/");
         let mut res = builder.call(&mut req).ok().expect("No response");
 
         let mut s = Vec::new();
-        res.body.write_body(&mut s).unwrap();
+        res.body_mut().write_body(&mut s).unwrap();
         assert_eq!(s, b"hello");
     }
 
@@ -292,23 +270,23 @@ mod tests {
         // the error bubbles up from ProducesError and shouldn't reach here
         builder.add(NotReached);
 
-        let mut req = RequestSentinel::new(Method::Get, "/");
+        let mut req = RequestSentinel::new(Method::GET, "/");
         let res = builder.call(&mut req).ok().expect("Error not handled");
 
-        assert_eq!(res.status, (500, "Internal Server Error"));
+        assert_eq!(res.status(), StatusCode::INTERNAL_SERVER_ERROR);
     }
 
     #[test]
     fn test_error_recovery_in_handlers() {
         let mut builder = MiddlewareBuilder::new(error_handler);
         builder.add(ErrorRecovery);
 
-        let mut req = RequestSentinel::new(Method::Get, "/");
+        let mut req = RequestSentinel::new(Method::GET, "/");
         let mut res = builder.call(&mut req).ok().expect("Error not handled");
 
-        assert_eq!(res.status, (500, "Internal Server Error"));
+        assert_eq!(res.status(), StatusCode::INTERNAL_SERVER_ERROR);
         let mut s = Vec::new();
-        res.body.write_body(&mut s).unwrap();
+        res.body_mut().write_body(&mut s).unwrap();
         assert_eq!(s, b"Error in handler");
     }
 
@@ -318,11 +296,11 @@ mod tests {
         builder.add(MyMiddleware);
         builder.around(MyAroundMiddleware::new());
 
-        let mut req = RequestSentinel::new(Method::Get, "/");
+        let mut req = RequestSentinel::new(Method::GET, "/");
         let mut res = builder.call(&mut req).ok().expect("No response");
 
         let mut s = Vec::new();
-        res.body.write_body(&mut s).unwrap();
+        res.body_mut().write_body(&mut s).unwrap();
         assert_eq!(s, b"hello hello");
     }
 }