Use a single runtime per test

Author: jtgeibel

Cargo.toml

@@ -18,6 +18,5 @@ semver = "0.5" # Must match version in conduit for now
 tokio-threadpool = "0.1.12"
 
 [dev-dependencies]
-conduit = "0.8"
 conduit-router = "0.8"
 tokio = "0.1"

src/lib.rs

@@ -19,7 +19,6 @@
 //! use tokio::runtime::Runtime;
 //!
 //! fn main() {
-//!     let a = ();
 //!     let app = build_conduit_handler();
 //!     let addr = ([127, 0, 0, 1], 12345).into();
 //!     let server = Server::bind(&addr, app).map_err(|e| {
@@ -36,21 +35,18 @@
 //! #     Endpoint()
 //! }
 //! #
-//! # use std::collections::HashMap;
-//! # use std::error::Error;
-//! # use std::io::Cursor;
+//! # use std::{collections, error, io};
 //! #
 //! # use conduit::{Request, Response};
 //! #
 //! # struct Endpoint();
 //! #
 //! # impl Handler for Endpoint {
-//! #     fn call(&self, _: &mut dyn Request) -> Result<Response, Box<dyn Error + Send>> {
-//! #         let body = "";
+//! #     fn call(&self, _: &mut dyn Request) -> Result<Response, Box<dyn error::Error + Send>> {
 //! #         Ok(Response {
 //! #             status: (200, "OK"),
-//! #             headers: HashMap::new(),
-//! #             body: Box::new(Cursor::new(body)),
+//! #             headers: collections::HashMap::new(),
+//! #             body: Box::new(io::Cursor::new("")),
 //! #         })
 //! #     }
 //! # }

src/tests.rs

@@ -3,8 +3,7 @@ use std::error::Error;
 use std::io::Cursor;
 
 use conduit::{Handler, Request, Response};
-use futures::{Future, Stream};
-use hyper;
+use futures::{future, Future, Stream};
 
 struct OkResult;
 impl Handler for OkResult {
@@ -73,25 +72,28 @@ fn build_headers(msg: &str) -> HashMap<String, Vec<String>> {
     headers
 }
 
-fn build_threadpool() -> tokio::runtime::Runtime {
-    tokio::runtime::Builder::new()
+fn block_on<F>(f: F)
+where
+    F: FnOnce() -> () + Send + 'static,
+{
+    let mut rt = tokio::runtime::Builder::new()
         .core_threads(1)
         .blocking_threads(1)
         .build()
-        .unwrap()
+        .unwrap();
+    rt.spawn(futures::lazy(move || {
+        f();
+        future::ok(())
+    }));
+    rt.shutdown_on_idle().wait().unwrap();
 }
 
 fn simulate_request<H: Handler>(handler: H) -> hyper::Response<hyper::Body> {
     use hyper::service::{NewService, Service};
 
-    let mut pool = build_threadpool();
-
-    pool.block_on(futures::lazy(|| {
-        let new_service = super::Service::new(handler);
-        let mut service = new_service.new_service().wait().unwrap();
-        service.call(hyper::Request::default()).wait()
-    }))
-    .unwrap()
+    let new_service = super::Service::new(handler);
+    let mut service = new_service.new_service().wait().unwrap();
+    service.call(hyper::Request::default()).wait().unwrap()
 }
 
 fn into_chunk(resp: hyper::Response<hyper::Body>) -> hyper::Chunk {
@@ -107,37 +109,43 @@ fn assert_generic_err(resp: hyper::Response<hyper::Body>) {
 
 #[test]
 fn valid_ok_response() {
-    let resp = simulate_request(OkResult);
-    assert_eq!(resp.status(), 200);
-    assert_eq!(resp.headers().len(), 1);
-    let full_body = into_chunk(resp);
-    assert_eq!(&*full_body, b"Hello, world!");
+    block_on(|| {
+        let resp = simulate_request(OkResult);
+        assert_eq!(resp.status(), 200);
+        assert_eq!(resp.headers().len(), 1);
+        let full_body = into_chunk(resp);
+        assert_eq!(&*full_body, b"Hello, world!");
+    })
 }
 
 #[test]
 fn invalid_ok_responses() {
-    assert_generic_err(simulate_request(InvalidHeader));
-    assert_generic_err(simulate_request(InvalidStatus));
+    block_on(|| {
+        assert_generic_err(simulate_request(InvalidHeader));
+        assert_generic_err(simulate_request(InvalidStatus));
+    })
 }
 
 #[test]
 fn err_responses() {
-    assert_generic_err(simulate_request(ErrorResult));
+    block_on(|| {
+        assert_generic_err(simulate_request(ErrorResult));
+    })
 }
 
 #[ignore] // catch_unwind not yet implemented
 #[test]
 fn recover_from_panic() {
-    assert_generic_err(simulate_request(Panic));
+    block_on(|| {
+        assert_generic_err(simulate_request(Panic));
+    })
 }
 
 #[test]
 fn normalize_path() {
     use hyper::service::{NewService, Service};
 
-    let mut pool = build_threadpool();
-
-    pool.block_on(futures::lazy(|| {
+    block_on(|| {
         let new_service = super::Service::new(AssertPathNormalized);
         let mut service = new_service.new_service().wait().unwrap();
         let req = hyper::Request::put("//removed/.././.././normalized")
@@ -153,7 +161,5 @@ fn normalize_path() {
         let resp = service.call(req).wait().unwrap();
         assert_eq!(resp.status(), 200);
         assert_eq!(resp.headers().len(), 1);
-        Ok::<_, ()>(())
-    }))
-    .unwrap()
+    })
 }