tide::Server implements http_client::HttpClient

Author: jbr

Cargo.toml

@@ -41,9 +41,10 @@ async-std = { version = "1.6.0", features = ["unstable"] }
 async-trait = "0.1.36"
 femme = { version = "2.0.1", optional = true }
 futures-util = "0.3.5"
-log = { version = "0.4.8", features = ["std"] }
+http-client = { version = "6.0.0", default-features = false }
 http-types = "2.2.1"
 kv-log-macro = "1.0.4"
+log = { version = "0.4.8", features = ["std"] }
 pin-project-lite = "0.1.7"
 route-recognizer = "0.2.0"
 serde = "1.0.102"
@@ -57,7 +58,7 @@ lazy_static = "1.4.0"
 logtest = "2.0.0"
 portpicker = "0.1.0"
 serde = { version = "1.0.102", features = ["derive"] }
-surf = { version = "2.0.0-alpha.3", default-features = false, features = ["h1-client"] }
+surf = { version = "2.0.0-alpha.7", default-features = false, features = ["h1-client"] }
 tempfile = "3.1.0"
 
 [[test]]

src/server.rs

@@ -9,6 +9,7 @@ use crate::log;
 use crate::middleware::{Middleware, Next};
 use crate::router::{Router, Selection};
 use crate::{Endpoint, Request, Route};
+
 /// An HTTP server.
 ///
 /// Servers are built up as a combination of *state*, *endpoints* and *middleware*:
@@ -24,7 +25,6 @@ use crate::{Endpoint, Request, Route};
 /// - Middleware extends the base Tide framework with additional request or
 /// response processing, such as compression, default headers, or logging. To
 /// add middleware to an app, use the [`Server::middleware`] method.
-#[allow(missing_debug_implementations)]
 pub struct Server<State> {
     router: Arc<Router<State>>,
     state: State,
@@ -253,6 +253,12 @@ impl<State: Clone + Send + Sync + 'static> Server<State> {
     }
 }
 
+impl<State: Send + Sync + 'static> std::fmt::Debug for Server<State> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("Server").finish()
+    }
+}
+
 impl<State: Clone> Clone for Server<State> {
     fn clone(&self) -> Self {
         Self {
@@ -292,6 +298,13 @@ impl<State: Clone + Sync + Send + 'static, InnerState: Clone + Sync + Send + 'st
     }
 }
 
+#[crate::utils::async_trait]
+impl<State: Clone + Send + Sync + Unpin + 'static> http_client::HttpClient for Server<State> {
+    async fn send(&self, req: crate::http::Request) -> crate::http::Result<crate::http::Response> {
+        self.respond(req).await
+    }
+}
+
 #[cfg(test)]
 mod test {
     use crate as tide;

tests/log.rs

@@ -5,10 +5,11 @@ mod test_utils;
 use test_utils::ServerTestingExt;
 
 #[async_std::test]
-async fn log_tests() {
+async fn log_tests() -> tide::Result<()> {
     let mut logger = logtest::start();
     test_server_listen(&mut logger).await;
-    test_only_log_once(&mut logger).await;
+    test_only_log_once(&mut logger).await?;
+    Ok(())
 }
 
 async fn test_server_listen(logger: &mut logtest::Logger) {
@@ -29,14 +30,14 @@ async fn test_server_listen(logger: &mut logtest::Logger) {
     );
 }
 
-async fn test_only_log_once(logger: &mut logtest::Logger) {
+async fn test_only_log_once(logger: &mut logtest::Logger) -> tide::Result<()> {
     let mut app = tide::new();
     app.at("/").nest({
         let mut app = tide::new();
         app.at("/").get(|_| async { Ok("nested") });
         app
     });
-    app.get("/").await;
+    assert!(app.get("/").await?.status().is_success());
 
     let entries: Vec<_> = logger.collect();
 
@@ -55,4 +56,5 @@ async fn test_only_log_once(logger: &mut logtest::Logger) {
             .filter(|entry| entry.args() == "--> Response sent")
             .count()
     );
+    Ok(())
 }

tests/nested.rs

@@ -2,7 +2,7 @@ mod test_utils;
 use test_utils::ServerTestingExt;
 
 #[async_std::test]
-async fn nested() {
+async fn nested() -> tide::Result<()> {
     let mut inner = tide::new();
     inner.at("/foo").get(|_| async { Ok("foo") });
     inner.at("/bar").get(|_| async { Ok("bar") });
@@ -11,12 +11,13 @@ async fn nested() {
     // Nest the inner app on /foo
     outer.at("/foo").nest(inner);
 
-    assert_eq!(outer.get_body("/foo/foo").await, "foo");
-    assert_eq!(outer.get_body("/foo/bar").await, "bar");
+    assert_eq!(outer.get("/foo/foo").recv_string().await?, "foo");
+    assert_eq!(outer.get("/foo/bar").recv_string().await?, "bar");
+    Ok(())
 }
 
 #[async_std::test]
-async fn nested_middleware() {
+async fn nested_middleware() -> tide::Result<()> {
     let echo_path = |req: tide::Request<()>| async move { Ok(req.url().path().to_string()) };
     let mut app = tide::new();
     let mut inner_app = tide::new();
@@ -29,24 +30,25 @@ async fn nested_middleware() {
     app.at("/foo").nest(inner_app);
     app.at("/bar").get(echo_path);
 
-    let mut res = app.get("/foo/echo").await;
+    let mut res = app.get("/foo/echo").await?;
     assert_eq!(res["X-Tide-Test"], "1");
     assert_eq!(res.status(), 200);
-    assert_eq!(res.body_string().await.unwrap(), "/echo");
+    assert_eq!(res.body_string().await?, "/echo");
 
-    let mut res = app.get("/foo/x/bar").await;
+    let mut res = app.get("/foo/x/bar").await?;
     assert_eq!(res["X-Tide-Test"], "1");
     assert_eq!(res.status(), 200);
-    assert_eq!(res.body_string().await.unwrap(), "/");
+    assert_eq!(res.body_string().await?, "/");
 
-    let mut res = app.get("/bar").await;
+    let mut res = app.get("/bar").await?;
     assert!(res.header("X-Tide-Test").is_none());
     assert_eq!(res.status(), 200);
-    assert_eq!(res.body_string().await.unwrap(), "/bar");
+    assert_eq!(res.body_string().await?, "/bar");
+    Ok(())
 }
 
 #[async_std::test]
-async fn nested_with_different_state() {
+async fn nested_with_different_state() -> tide::Result<()> {
     let mut outer = tide::new();
     let mut inner = tide::with_state(42);
     inner.at("/").get(|req: tide::Request<i32>| async move {
@@ -56,6 +58,7 @@ async fn nested_with_different_state() {
     outer.at("/").get(|_| async { Ok("Hello, world!") });
     outer.at("/foo").nest(inner);
 
-    assert_eq!(outer.get_body("/foo").await, "the number is 42");
-    assert_eq!(outer.get_body("/").await, "Hello, world!");
+    assert_eq!(outer.get("/foo").recv_string().await?, "the number is 42");
+    assert_eq!(outer.get("/").recv_string().await?, "Hello, world!");
+    Ok(())
 }

tests/response.rs

@@ -36,7 +36,7 @@ async fn string_content_type() {
 }
 
 #[async_std::test]
-async fn json_content_type() {
+async fn json_content_type() -> tide::Result<()> {
     use std::collections::BTreeMap;
     use tide::Body;
 
@@ -51,7 +51,7 @@ async fn json_content_type() {
         Ok(resp)
     });
 
-    let mut resp = app.get("/json_content_type").await;
+    let mut resp = app.get("/json_content_type").await?;
     assert_eq!(resp.status(), StatusCode::InternalServerError);
     assert_eq!(resp.body_string().await.unwrap(), "");
 
@@ -68,6 +68,8 @@ async fn json_content_type() {
     assert_eq!(resp.status(), StatusCode::Ok);
     let body = resp.take_body().into_bytes().await.unwrap();
     assert_eq!(body, br##"{"a":2,"b":4,"c":6}"##);
+
+    Ok(())
 }
 
 #[test]

tests/route_middleware.rs

@@ -31,7 +31,7 @@ async fn echo_path<State>(req: tide::Request<State>) -> tide::Result<String> {
 }
 
 #[async_std::test]
-async fn route_middleware() {
+async fn route_middleware() -> tide::Result<()> {
     let mut app = tide::new();
     let mut foo_route = app.at("/foo");
     foo_route // /foo
@@ -46,17 +46,18 @@ async fn route_middleware() {
         .reset_middleware()
         .put(echo_path);
 
-    assert_eq!(app.get("/foo").await["X-Foo"], "foo");
-    assert_eq!(app.post("/foo").await["X-Foo"], "foo");
-    assert!(app.put("/foo").await.header("X-Foo").is_none());
+    assert_eq!(app.get("/foo").await?["X-Foo"], "foo");
+    assert_eq!(app.post("/foo").await?["X-Foo"], "foo");
+    assert!(app.put("/foo").await?.header("X-Foo").is_none());
 
-    let res = app.get("/foo/bar").await;
+    let res = app.get("/foo/bar").await?;
     assert_eq!(res["X-Foo"], "foo");
     assert_eq!(res["x-bar"], "bar");
+    Ok(())
 }
 
 #[async_std::test]
-async fn app_and_route_middleware() {
+async fn app_and_route_middleware() -> tide::Result<()> {
     let mut app = tide::new();
     app.with(TestMiddleware::with_header_name("X-Root", "root"));
     app.at("/foo")
@@ -66,19 +67,20 @@ async fn app_and_route_middleware() {
         .with(TestMiddleware::with_header_name("X-Bar", "bar"))
         .get(echo_path);
 
-    let res = app.get("/foo").await;
+    let res = app.get("/foo").await?;
     assert_eq!(res["X-Root"], "root");
     assert_eq!(res["x-foo"], "foo");
     assert!(res.header("x-bar").is_none());
 
-    let res = app.get("/bar").await;
+    let res = app.get("/bar").await?;
     assert_eq!(res["X-Root"], "root");
     assert!(res.header("x-foo").is_none());
     assert_eq!(res["X-Bar"], "bar");
+    Ok(())
 }
 
 #[async_std::test]
-async fn nested_app_with_route_middleware() {
+async fn nested_app_with_route_middleware() -> tide::Result<()> {
     let mut inner = tide::new();
     inner.with(TestMiddleware::with_header_name("X-Inner", "inner"));
     inner
@@ -95,23 +97,24 @@ async fn nested_app_with_route_middleware() {
         .with(TestMiddleware::with_header_name("X-Bar", "bar"))
         .nest(inner);
 
-    let res = app.get("/foo").await;
+    let res = app.get("/foo").await?;
     assert_eq!(res["X-Root"], "root");
     assert!(res.header("X-Inner").is_none());
     assert_eq!(res["X-Foo"], "foo");
     assert!(res.header("X-Bar").is_none());
     assert!(res.header("X-Baz").is_none());
 
-    let res = app.get("/bar/baz").await;
+    let res = app.get("/bar/baz").await?;
     assert_eq!(res["X-Root"], "root");
     assert_eq!(res["X-Inner"], "inner");
     assert!(res.header("X-Foo").is_none());
     assert_eq!(res["X-Bar"], "bar");
     assert_eq!(res["X-Baz"], "baz");
+    Ok(())
 }
 
 #[async_std::test]
-async fn subroute_not_nested() {
+async fn subroute_not_nested() -> tide::Result<()> {
     let mut app = tide::new();
     app.at("/parent") // /parent
         .with(TestMiddleware::with_header_name("X-Parent", "Parent"))
@@ -120,7 +123,8 @@ async fn subroute_not_nested() {
         .with(TestMiddleware::with_header_name("X-Child", "child"))
         .get(echo_path);
 
-    let res = app.get("/parent/child").await;
+    let res = app.get("/parent/child").await?;
     assert!(res.header("X-Parent").is_none());
     assert_eq!(res["x-child"], "child");
+    Ok(())
 }

tests/server.rs

@@ -7,7 +7,7 @@ use serde::{Deserialize, Serialize};
 use tide::{Body, Request};
 
 #[test]
-fn hello_world() -> Result<(), http_types::Error> {
+fn hello_world() -> tide::Result<()> {
     task::block_on(async {
         let port = test_utils::find_port().await;
         let server = task::spawn(async move {
@@ -25,7 +25,7 @@ fn hello_world() -> Result<(), http_types::Error> {
         let client = task::spawn(async move {
             task::sleep(Duration::from_millis(100)).await;
             let string = surf::get(format!("http://localhost:{}", port))
-                .body("nori".to_string())
+                .body(Body::from_string("nori".to_string()))
                 .recv_string()
                 .await
                 .unwrap();
@@ -38,7 +38,7 @@ fn hello_world() -> Result<(), http_types::Error> {
 }
 
 #[test]
-fn echo_server() -> Result<(), http_types::Error> {
+fn echo_server() -> tide::Result<()> {
     task::block_on(async {
         let port = test_utils::find_port().await;
         let server = task::spawn(async move {
@@ -52,7 +52,7 @@ fn echo_server() -> Result<(), http_types::Error> {
         let client = task::spawn(async move {
             task::sleep(Duration::from_millis(100)).await;
             let string = surf::get(format!("http://localhost:{}", port))
-                .body("chashu".to_string())
+                .body(Body::from_string("chashu".to_string()))
                 .recv_string()
                 .await
                 .unwrap();
@@ -65,7 +65,7 @@ fn echo_server() -> Result<(), http_types::Error> {
 }
 
 #[test]
-fn json() -> Result<(), http_types::Error> {
+fn json() -> tide::Result<()> {
     #[derive(Deserialize, Serialize)]
     struct Counter {
         count: usize,