Merge pull request #503 from http-rs/remove-http-service

Remove http service

Author: yoshuawuyts

Cargo.toml

@@ -24,15 +24,14 @@ rustdoc-args = ["--cfg", "feature=\"docs\""]
 
 [features]
 default = ["h1-server"]
-h1-server = ["http-service-h1"]
+h1-server = ["async-h1"]
 docs = ["unstable"]
 unstable = []
 
 [dependencies]
 async-sse = "2.1.0"
 http-types = "1.0.1"
-http-service = "0.5.0"
-http-service-h1 = { version = "0.1.0", optional = true }
+async-h1 = { version = "1.1.2", optional = true }
 route-recognizer = "0.1.13"
 serde = "1.0.102"
 serde_json = "1.0.41"
@@ -54,7 +53,6 @@ basic-cookies = "0.1.3"
 bytes = "0.4.12"
 futures-fs = "0.0.5"
 futures-util = { version = "0.3.0", features = ["compat"] }
-http-service-mock = "0.5.0"
 juniper = "0.14.1"
 mime = "0.3.14"
 mime_guess = "2.0.1"
@@ -64,6 +62,7 @@ structopt = "0.3.3"
 surf = "2.0.0-alpha.1"
 futures = "0.3.1"
 femme = "1.3.0"
+portpicker = "0.1.0"
 
 [[test]]
 name = "nested"

src/middleware.rs

@@ -2,9 +2,6 @@
 
 use std::sync::Arc;
 
-#[doc(inline)]
-pub use http_service::HttpService;
-
 use crate::endpoint::DynEndpoint;
 use crate::utils::BoxFuture;
 use crate::Request;

src/request.rs

@@ -1,8 +1,4 @@
 use cookie::Cookie;
-use http_types::{
-    headers::{HeaderName, HeaderValue},
-    Method, StatusCode, Url, Version,
-};
 use route_recognizer::Params;
 use serde::Deserialize;
 
@@ -13,6 +9,8 @@ use std::pin::Pin;
 use std::{str::FromStr, sync::Arc};
 
 use crate::cookies::CookieData;
+use crate::http::headers::{HeaderName, HeaderValue};
+use crate::http::{self, Method, StatusCode, Url, Version};
 use crate::Response;
 
 /// An HTTP request.
@@ -25,7 +23,7 @@ use crate::Response;
 #[derive(Debug)]
 pub struct Request<State> {
     pub(crate) state: Arc<State>,
-    pub(crate) request: http_service::Request,
+    pub(crate) request: http::Request,
     pub(crate) route_params: Vec<Params>,
 }
 

src/response.rs

@@ -2,14 +2,12 @@ use async_std::io::prelude::*;
 use std::convert::TryFrom;
 
 use cookie::Cookie;
-use http_service::Body;
-use http_types::{
-    headers::{HeaderName, HeaderValue},
-    StatusCode,
-};
 use mime::Mime;
 use serde::Serialize;
 
+use crate::http::headers::{HeaderName, HeaderValue};
+use crate::http::{self, Body, StatusCode};
+
 #[derive(Debug)]
 pub(crate) enum CookieEvent {
     Added(Cookie<'static>),
@@ -19,7 +17,7 @@ pub(crate) enum CookieEvent {
 /// An HTTP response
 #[derive(Debug)]
 pub struct Response {
-    pub(crate) res: http_service::Response,
+    pub(crate) res: http::Response,
     // tracking here
     pub(crate) cookie_events: Vec<CookieEvent>,
 }
@@ -251,14 +249,14 @@ impl Response {
     }
 }
 
-impl Into<http_service::Response> for Response {
-    fn into(self) -> http_service::Response {
+impl Into<http::Response> for Response {
+    fn into(self) -> http::Response {
         self.res
     }
 }
 
-impl From<http_service::Response> for Response {
-    fn from(res: http_service::Response) -> Self {
+impl From<http::Response> for Response {
+    fn from(res: http::Response) -> Self {
         Self {
             res,
             cookie_events: vec![],

src/security/cors.rs

@@ -2,6 +2,7 @@ use crate::utils::BoxFuture;
 use http_types::headers::HeaderValue;
 use http_types::{headers, Method, StatusCode};
 
+use crate::http;
 use crate::middleware::{Middleware, Next};
 use crate::{Request, Result};
 
@@ -167,7 +168,7 @@ impl<State: Send + Sync + 'static> Middleware<State> for CorsMiddleware {
                 return Ok(self.build_preflight_response(&origins).into());
             }
 
-            let mut response: http_service::Response = next.run(req).await?.into();
+            let mut response: http::Response = next.run(req).await?.into();
             response
                 .insert_header(
                     headers::ACCESS_CONTROL_ALLOW_ORIGIN,
@@ -242,7 +243,6 @@ impl From<Vec<&str>> for Origin {
 #[cfg(test)]
 mod test {
     use super::*;
-    use http_service_mock::make_server;
     use http_types::headers::{self, HeaderValue};
 
     const ALLOW_ORIGIN: &str = "example.com";
@@ -271,8 +271,8 @@ mod test {
         req
     }
 
-    #[test]
-    fn preflight_request() {
+    #[async_std::test]
+    async fn preflight_request() {
         let mut app = app();
         app.middleware(
             CorsMiddleware::new()
@@ -282,13 +282,11 @@ mod test {
                 .allow_credentials(true),
         );
 
-        let mut server = make_server(app).unwrap();
-
         let mut req = http_types::Request::new(http_types::Method::Options, endpoint_url());
         req.insert_header(http_types::headers::ORIGIN, ALLOW_ORIGIN)
             .unwrap();
 
-        let res = server.simulate(req).unwrap();
+        let res: crate::http::Response = app.respond(req).await.unwrap();
 
         assert_eq!(res.status(), 200);
 
@@ -316,13 +314,11 @@ mod test {
             "true"
         );
     }
-    #[test]
-    fn default_cors_middleware() {
+    #[async_std::test]
+    async fn default_cors_middleware() {
         let mut app = app();
         app.middleware(CorsMiddleware::new());
-
-        let mut server = make_server(app).unwrap();
-        let res = server.simulate(request()).unwrap();
+        let res: crate::http::Response = app.respond(request()).await.unwrap();
 
         assert_eq!(res.status(), 200);
 
@@ -332,8 +328,8 @@ mod test {
         );
     }
 
-    #[test]
-    fn custom_cors_middleware() {
+    #[async_std::test]
+    async fn custom_cors_middleware() {
         let mut app = app();
         app.middleware(
             CorsMiddleware::new()
@@ -342,9 +338,7 @@ mod test {
                 .allow_methods(ALLOW_METHODS.parse::<HeaderValue>().unwrap())
                 .expose_headers(EXPOSE_HEADER.parse::<HeaderValue>().unwrap()),
         );
-
-        let mut server = make_server(app).unwrap();
-        let res = server.simulate(request()).unwrap();
+        let res: crate::http::Response = app.respond(request()).await.unwrap();
 
         assert_eq!(res.status(), 200);
         assert_eq!(
@@ -353,13 +347,11 @@ mod test {
         );
     }
 
-    #[test]
-    fn credentials_true() {
+    #[async_std::test]
+    async fn credentials_true() {
         let mut app = app();
         app.middleware(CorsMiddleware::new().allow_credentials(true));
-
-        let mut server = make_server(app).unwrap();
-        let res = server.simulate(request()).unwrap();
+        let res: crate::http::Response = app.respond(request()).await.unwrap();
 
         assert_eq!(res.status(), 200);
         assert_eq!(
@@ -370,20 +362,18 @@ mod test {
         );
     }
 
-    #[test]
-    fn set_allow_origin_list() {
+    #[async_std::test]
+    async fn set_allow_origin_list() {
         let mut app = app();
         let origins = vec![ALLOW_ORIGIN, "foo.com", "bar.com"];
         app.middleware(CorsMiddleware::new().allow_origin(origins.clone()));
-        let mut server = make_server(app).unwrap();
 
         for origin in origins {
-            let mut request = http_types::Request::new(http_types::Method::Get, endpoint_url());
-            request
-                .insert_header(http_types::headers::ORIGIN, origin)
+            let mut req = http_types::Request::new(http_types::Method::Get, endpoint_url());
+            req.insert_header(http_types::headers::ORIGIN, origin)
                 .unwrap();
 
-            let res = server.simulate(request).unwrap();
+            let res: crate::http::Response = app.respond(req).await.unwrap();
 
             assert_eq!(res.status(), 200);
             assert_eq!(
@@ -393,31 +383,26 @@ mod test {
         }
     }
 
-    #[test]
-    fn not_set_origin_header() {
+    #[async_std::test]
+    async fn not_set_origin_header() {
         let mut app = app();
         app.middleware(CorsMiddleware::new().allow_origin(ALLOW_ORIGIN));
 
-        let request = http_types::Request::new(http_types::Method::Get, endpoint_url());
-
-        let mut server = make_server(app).unwrap();
-        let res = server.simulate(request).unwrap();
+        let req = crate::http::Request::new(http_types::Method::Get, endpoint_url());
+        let res: crate::http::Response = app.respond(req).await.unwrap();
 
         assert_eq!(res.status(), 200);
     }
 
-    #[test]
-    fn unauthorized_origin() {
+    #[async_std::test]
+    async fn unauthorized_origin() {
         let mut app = app();
         app.middleware(CorsMiddleware::new().allow_origin(ALLOW_ORIGIN));
 
-        let mut request = http_types::Request::new(http_types::Method::Get, endpoint_url());
-        request
-            .insert_header(http_types::headers::ORIGIN, "unauthorize-origin.net")
+        let mut req = http_types::Request::new(http_types::Method::Get, endpoint_url());
+        req.insert_header(http_types::headers::ORIGIN, "unauthorize-origin.net")
             .unwrap();
-
-        let mut server = make_server(app).unwrap();
-        let res = server.simulate(request).unwrap();
+        let res: crate::http::Response = app.respond(req).await.unwrap();
 
         assert_eq!(res.status(), 401);
     }