add TestServer

tests/test_client.rs

@@ -4,16 +4,12 @@ extern crate actix_net;
 extern crate bytes;
 extern crate futures;
 
-use std::{thread, time};
-
-use actix::System;
-use actix_net::server::Server;
 use actix_net::service::NewServiceExt;
 use bytes::Bytes;
-use futures::future::{self, lazy, ok};
+use futures::future::{self, ok};
 
 use actix_http::HttpMessage;
-use actix_http::{client, h1, test, Request, Response};
+use actix_http::{client, h1, test::TestServer, Request, Response};
 
 const STR: &str = "Hello World Hello World Hello World Hello World Hello World \
                    Hello World Hello World Hello World Hello World Hello World \
@@ -39,111 +35,70 @@ const STR: &str = "Hello World Hello World Hello World Hello World Hello World \
 
 #[test]
 fn test_h1_v2() {
-    let addr = test::TestServer::unused_addr();
-    thread::spawn(move || {
-        Server::new()
-            .bind("test", addr, move || {
-                h1::H1Service::build()
-                    .finish(|_| future::ok::<_, ()>(Response::Ok().body(STR)))
-                    .map(|_| ())
-            }).unwrap()
-            .run();
+    let mut srv = TestServer::with_factory(move || {
+        h1::H1Service::build()
+            .finish(|_| future::ok::<_, ()>(Response::Ok().body(STR)))
+            .map(|_| ())
     });
-    thread::sleep(time::Duration::from_millis(100));
+    let mut connector = srv.new_connector();
 
-    let mut sys = System::new("test");
-    let mut connector = sys
-        .block_on(lazy(|| Ok::<_, ()>(client::Connector::default().service())))
-        .unwrap();
-
-    let req = client::ClientRequest::get(format!("http://{}/", addr))
-        .finish()
-        .unwrap();
-
-    let response = sys.block_on(req.send(&mut connector)).unwrap();
+    let request = srv.get().finish().unwrap();
+    let response = srv.block_on(request.send(&mut connector)).unwrap();
     assert!(response.status().is_success());
 
-    let request = client::ClientRequest::get(format!("http://{}/", addr))
-        .header("x-test", "111")
-        .finish()
-        .unwrap();
+    let request = srv.get().header("x-test", "111").finish().unwrap();
     let repr = format!("{:?}", request);
     assert!(repr.contains("ClientRequest"));
     assert!(repr.contains("x-test"));
 
-    let response = sys.block_on(request.send(&mut connector)).unwrap();
+    let response = srv.block_on(request.send(&mut connector)).unwrap();
     assert!(response.status().is_success());
 
     // read response
-    let bytes = sys.block_on(response.body()).unwrap();
+    let bytes = srv.block_on(response.body()).unwrap();
     assert_eq!(bytes, Bytes::from_static(STR.as_ref()));
 
-    let request = client::ClientRequest::post(format!("http://{}/", addr))
-        .finish()
-        .unwrap();
-    let response = sys.block_on(request.send(&mut connector)).unwrap();
+    let request = srv.post().finish().unwrap();
+    let response = srv.block_on(request.send(&mut connector)).unwrap();
     assert!(response.status().is_success());
 
     // read response
-    let bytes = sys.block_on(response.body()).unwrap();
+    let bytes = srv.block_on(response.body()).unwrap();
     assert_eq!(bytes, Bytes::from_static(STR.as_ref()));
 }
 
 #[test]
 fn test_connection_close() {
-    let addr = test::TestServer::unused_addr();
-    thread::spawn(move || {
-        Server::new()
-            .bind("test", addr, move || {
-                h1::H1Service::build()
-                    .finish(|_| ok::<_, ()>(Response::Ok().body(STR)))
-                    .map(|_| ())
-            }).unwrap()
-            .run();
+    let mut srv = TestServer::with_factory(move || {
+        h1::H1Service::build()
+            .finish(|_| ok::<_, ()>(Response::Ok().body(STR)))
+            .map(|_| ())
     });
-    thread::sleep(time::Duration::from_millis(100));
+    let mut connector = srv.new_connector();
 
-    let mut sys = System::new("test");
-    let mut connector = sys
-        .block_on(lazy(|| Ok::<_, ()>(client::Connector::default().service())))
-        .unwrap();
-
-    let request = client::ClientRequest::get(format!("http://{}/", addr))
-        .header("Connection", "close")
-        .finish()
-        .unwrap();
-    let response = sys.block_on(request.send(&mut connector)).unwrap();
+    let request = srv.get().close().finish().unwrap();
+    let response = srv.block_on(request.send(&mut connector)).unwrap();
     assert!(response.status().is_success());
 }
 
 #[test]
 fn test_with_query_parameter() {
-    let addr = test::TestServer::unused_addr();
-    thread::spawn(move || {
-        Server::new()
-            .bind("test", addr, move || {
-                h1::H1Service::build()
-                    .finish(|req: Request| {
-                        if req.uri().query().unwrap().contains("qp=") {
-                            ok::<_, ()>(Response::Ok().finish())
-                        } else {
-                            ok::<_, ()>(Response::BadRequest().finish())
-                        }
-                    }).map(|_| ())
-            }).unwrap()
-            .run();
+    let mut srv = TestServer::with_factory(move || {
+        h1::H1Service::build()
+            .finish(|req: Request| {
+                if req.uri().query().unwrap().contains("qp=") {
+                    ok::<_, ()>(Response::Ok().finish())
+                } else {
+                    ok::<_, ()>(Response::BadRequest().finish())
+                }
+            }).map(|_| ())
     });
-    thread::sleep(time::Duration::from_millis(100));
+    let mut connector = srv.new_connector();
 
-    let mut sys = System::new("test");
-    let mut connector = sys
-        .block_on(lazy(|| Ok::<_, ()>(client::Connector::default().service())))
-        .unwrap();
-
-    let request = client::ClientRequest::get(format!("http://{}/?qp=5", addr))
+    let request = client::ClientRequest::get(srv.url("/?qp=5"))
         .finish()
         .unwrap();
 
-    let response = sys.block_on(request.send(&mut connector)).unwrap();
+    let response = srv.block_on(request.send(&mut connector)).unwrap();
     assert!(response.status().is_success());
 }

tests/test_server.rs

@@ -1,70 +1,48 @@
 extern crate actix;
 extern crate actix_http;
 extern crate actix_net;
-extern crate actix_web;
 extern crate bytes;
 extern crate futures;
 
-use std::{io::Read, io::Write, net, thread, time};
+use std::{io::Read, io::Write, net};
 
-use actix::System;
-use actix_net::server::Server;
 use actix_net::service::NewServiceExt;
-use actix_web::{client, test, HttpMessage};
 use bytes::Bytes;
-use futures::future::{self, lazy, ok};
+use futures::future::{self, ok};
 use futures::stream::once;
 
 use actix_http::{
-    body, client as client2, h1, http, Body, Error, HttpMessage as HttpMessage2,
-    KeepAlive, Request, Response,
+    body, client, h1, http, test, Body, Error, HttpMessage as HttpMessage2, KeepAlive,
+    Request, Response,
 };
 
 #[test]
 fn test_h1_v2() {
-    let addr = test::TestServer::unused_addr();
-    thread::spawn(move || {
-        Server::new()
-            .bind("test", addr, move || {
-                h1::H1Service::build()
-                    .keep_alive(KeepAlive::Disabled)
-                    .client_timeout(1000)
-                    .client_disconnect(1000)
-                    .server_hostname("localhost")
-                    .server_address(addr)
-                    .finish(|_| future::ok::<_, ()>(Response::Ok().finish()))
-                    .map(|_| ())
-            }).unwrap()
-            .run();
+    let mut srv = test::TestServer::with_factory(|| {
+        h1::H1Service::build()
+            .keep_alive(KeepAlive::Disabled)
+            .client_timeout(1000)
+            .client_disconnect(1000)
+            .server_hostname("localhost")
+            .finish(|_| future::ok::<_, ()>(Response::Ok().finish()))
+            .map(|_| ())
     });
-    thread::sleep(time::Duration::from_millis(100));
 
-    let mut sys = System::new("test");
-    {
-        let req = client::ClientRequest::get(format!("http://{}/", addr))
-            .finish()
-            .unwrap();
-        let response = sys.block_on(req.send()).unwrap();
-        assert!(response.status().is_success());
-    }
+    let req = client::ClientRequest::get(srv.url("/")).finish().unwrap();
+    let response = srv.send_request(req).unwrap();
+    assert!(response.status().is_success());
 }
 
 #[test]
 fn test_slow_request() {
-    let addr = test::TestServer::unused_addr();
-    thread::spawn(move || {
-        Server::new()
-            .bind("test", addr, move || {
-                h1::H1Service::build()
-                    .client_timeout(100)
-                    .finish(|_| future::ok::<_, ()>(Response::Ok().finish()))
-                    .map(|_| ())
-            }).unwrap()
-            .run();
+    let srv = test::TestServer::with_factory(|| {
+        h1::H1Service::build()
+            .client_timeout(100)
+            .finish(|_| future::ok::<_, ()>(Response::Ok().finish()))
+            .map(|_| ())
     });
-    thread::sleep(time::Duration::from_millis(100));
 
-    let mut stream = net::TcpStream::connect(addr).unwrap();
+    let mut stream = net::TcpStream::connect(srv.addr()).unwrap();
     let _ = stream.write_all(b"GET /test/tests/test HTTP/1.1\r\n");
     let mut data = String::new();
     let _ = stream.read_to_string(&mut data);
@@ -73,18 +51,11 @@ fn test_slow_request() {
 
 #[test]
 fn test_malformed_request() {
-    let addr = test::TestServer::unused_addr();
-    thread::spawn(move || {
-        Server::new()
-            .bind("test", addr, move || {
-                h1::H1Service::new(|_| future::ok::<_, ()>(Response::Ok().finish()))
-                    .map(|_| ())
-            }).unwrap()
-            .run();
+    let srv = test::TestServer::with_factory(|| {
+        h1::H1Service::new(|_| future::ok::<_, ()>(Response::Ok().finish())).map(|_| ())
     });
-    thread::sleep(time::Duration::from_millis(100));
 
-    let mut stream = net::TcpStream::connect(addr).unwrap();
+    let mut stream = net::TcpStream::connect(srv.addr()).unwrap();
     let _ = stream.write_all(b"GET /test/tests/test HTTP1.1\r\n");
     let mut data = String::new();
     let _ = stream.read_to_string(&mut data);
@@ -98,51 +69,42 @@ fn test_content_length() {
         StatusCode,
     };
 
-    let addr = test::TestServer::unused_addr();
-    thread::spawn(move || {
-        Server::new()
-            .bind("test", addr, move || {
-                h1::H1Service::new(|req: Request| {
-                    let indx: usize = req.uri().path()[1..].parse().unwrap();
-                    let statuses = [
-                        StatusCode::NO_CONTENT,
-                        StatusCode::CONTINUE,
-                        StatusCode::SWITCHING_PROTOCOLS,
-                        StatusCode::PROCESSING,
-                        StatusCode::OK,
-                        StatusCode::NOT_FOUND,
-                    ];
-                    future::ok::<_, ()>(Response::new(statuses[indx]))
-                }).map(|_| ())
-            }).unwrap()
-            .run();
+    let mut srv = test::TestServer::with_factory(|| {
+        h1::H1Service::new(|req: Request| {
+            let indx: usize = req.uri().path()[1..].parse().unwrap();
+            let statuses = [
+                StatusCode::NO_CONTENT,
+                StatusCode::CONTINUE,
+                StatusCode::SWITCHING_PROTOCOLS,
+                StatusCode::PROCESSING,
+                StatusCode::OK,
+                StatusCode::NOT_FOUND,
+            ];
+            future::ok::<_, ()>(Response::new(statuses[indx]))
+        }).map(|_| ())
     });
-    thread::sleep(time::Duration::from_millis(100));
 
     let header = HeaderName::from_static("content-length");
     let value = HeaderValue::from_static("0");
 
-    let mut sys = System::new("test");
     {
         for i in 0..4 {
-            let req = client::ClientRequest::get(format!("http://{}/{}", addr, i))
-                .finish()
-                .unwrap();
-            let response = sys.block_on(req.send()).unwrap();
+            let req = client::ClientRequest::get(srv.url("/")).finish().unwrap();
+            let response = srv.send_request(req).unwrap();
             assert_eq!(response.headers().get(&header), None);
 
-            let req = client::ClientRequest::head(format!("http://{}/{}", addr, i))
+            let req = client::ClientRequest::head(srv.url(&format!("/{}", i)))
                 .finish()
                 .unwrap();
-            let response = sys.block_on(req.send()).unwrap();
+            let response = srv.send_request(req).unwrap();
             assert_eq!(response.headers().get(&header), None);
         }
 
         for i in 4..6 {
-            let req = client::ClientRequest::get(format!("http://{}/{}", addr, i))
+            let req = client::ClientRequest::get(srv.url(&format!("/{}", i)))
                 .finish()
                 .unwrap();
-            let response = sys.block_on(req.send()).unwrap();
+            let response = srv.send_request(req).unwrap();
             assert_eq!(response.headers().get(&header), Some(&value));
         }
     }
@@ -153,54 +115,41 @@ fn test_headers() {
     let data = STR.repeat(10);
     let data2 = data.clone();
 
-    let addr = test::TestServer::unused_addr();
-    thread::spawn(move || {
-        Server::new()
-            .bind("test", addr, move || {
-                let data = data.clone();
-                h1::H1Service::new(move |_| {
-                    let mut builder = Response::Ok();
-                    for idx in 0..90 {
-                        builder.header(
-                            format!("X-TEST-{}", idx).as_str(),
-                            "TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
-                             TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
-                             TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
-                             TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
-                             TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
-                             TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
-                             TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
-                             TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
-                             TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
-                             TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
-                             TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
-                             TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
-                             TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST ",
-                        );
-                    }
-                    future::ok::<_, ()>(builder.body(data.clone()))
-                }).map(|_| ())
-            })
-            .unwrap()
-            .run()
+    let mut srv = test::TestServer::with_factory(move || {
+        let data = data.clone();
+        h1::H1Service::new(move |_| {
+            let mut builder = Response::Ok();
+            for idx in 0..90 {
+                builder.header(
+                    format!("X-TEST-{}", idx).as_str(),
+                    "TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
+                        TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
+                        TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
+                        TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
+                        TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
+                        TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
+                        TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
+                        TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
+                        TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
+                        TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
+                        TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
+                        TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
+                        TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST ",
+                );
+            }
+            future::ok::<_, ()>(builder.body(data.clone()))
+        }).map(|_| ())
     });
-    thread::sleep(time::Duration::from_millis(200));
 
-    let mut sys = System::new("test");
-    let mut connector = sys
-        .block_on(lazy(|| {
-            Ok::<_, ()>(client2::Connector::default().service())
-        })).unwrap();
+    let mut connector = srv.new_connector();
 
-    let req = client2::ClientRequest::get(format!("http://{}/", addr))
-        .finish()
-        .unwrap();
+    let req = srv.get().finish().unwrap();
 
-    let response = sys.block_on(req.send(&mut connector)).unwrap();
+    let response = srv.block_on(req.send(&mut connector)).unwrap();
     assert!(response.status().is_success());
 
     // read response
-    let bytes = sys.block_on(response.body()).unwrap();
+    let bytes = srv.block_on(response.body()).unwrap();
     assert_eq!(bytes, Bytes::from(data2));
 }
 
@@ -228,46 +177,27 @@ const STR: &str = "Hello World Hello World Hello World Hello World Hello World \
 
 #[test]
 fn test_body() {
-    let addr = test::TestServer::unused_addr();
-    thread::spawn(move || {
-        Server::new()
-            .bind("test", addr, move || {
-                h1::H1Service::new(|_| future::ok::<_, ()>(Response::Ok().body(STR)))
-                    .map(|_| ())
-            }).unwrap()
-            .run();
+    let mut srv = test::TestServer::with_factory(|| {
+        h1::H1Service::new(|_| future::ok::<_, ()>(Response::Ok().body(STR))).map(|_| ())
     });
-    thread::sleep(time::Duration::from_millis(100));
 
-    let mut sys = System::new("test");
-    let req = client::ClientRequest::get(format!("http://{}/", addr))
-        .finish()
-        .unwrap();
-    let response = sys.block_on(req.send()).unwrap();
+    let req = srv.get().finish().unwrap();
+    let response = srv.send_request(req).unwrap();
     assert!(response.status().is_success());
 
     // read response
-    let bytes = sys.block_on(response.body()).unwrap();
+    let bytes = srv.block_on(response.body()).unwrap();
     assert_eq!(bytes, Bytes::from_static(STR.as_ref()));
 }
 
 #[test]
 fn test_head_empty() {
-    let addr = test::TestServer::unused_addr();
-    thread::spawn(move || {
-        Server::new()
-            .bind("test", addr, move || {
-                h1::H1Service::new(|_| ok::<_, ()>(Response::Ok().body(STR))).map(|_| ())
-            }).unwrap()
-            .run()
+    let mut srv = test::TestServer::with_factory(|| {
+        h1::H1Service::new(|_| ok::<_, ()>(Response::Ok().body(STR))).map(|_| ())
     });
-    thread::sleep(time::Duration::from_millis(100));
 
-    let mut sys = System::new("test");
-    let req = client::ClientRequest::head(format!("http://{}/", addr))
-        .finish()
-        .unwrap();
-    let response = sys.block_on(req.send()).unwrap();
+    let req = client::ClientRequest::head(srv.url("/")).finish().unwrap();
+    let response = srv.send_request(req).unwrap();
     assert!(response.status().is_success());
 
     {
@@ -279,31 +209,20 @@ fn test_head_empty() {
     }
 
     // read response
-    let bytes = sys.block_on(response.body()).unwrap();
+    let bytes = srv.block_on(response.body()).unwrap();
     assert!(bytes.is_empty());
 }
 
 #[test]
 fn test_head_binary() {
-    let addr = test::TestServer::unused_addr();
-    thread::spawn(move || {
-        Server::new()
-            .bind("test", addr, move || {
-                h1::H1Service::new(|_| {
-                    ok::<_, ()>(
-                        Response::Ok().content_length(STR.len() as u64).body(STR),
-                    )
-                }).map(|_| ())
-            }).unwrap()
-            .run()
+    let mut srv = test::TestServer::with_factory(|| {
+        h1::H1Service::new(|_| {
+            ok::<_, ()>(Response::Ok().content_length(STR.len() as u64).body(STR))
+        }).map(|_| ())
     });
-    thread::sleep(time::Duration::from_millis(100));
 
-    let mut sys = System::new("test");
-    let req = client::ClientRequest::head(format!("http://{}/", addr))
-        .finish()
-        .unwrap();
-    let response = sys.block_on(req.send()).unwrap();
+    let req = client::ClientRequest::head(srv.url("/")).finish().unwrap();
+    let response = srv.send_request(req).unwrap();
     assert!(response.status().is_success());
 
     {
@@ -315,27 +234,18 @@ fn test_head_binary() {
     }
 
     // read response
-    let bytes = sys.block_on(response.body()).unwrap();
+    let bytes = srv.block_on(response.body()).unwrap();
     assert!(bytes.is_empty());
 }
 
 #[test]
 fn test_head_binary2() {
-    let addr = test::TestServer::unused_addr();
-    thread::spawn(move || {
-        Server::new()
-            .bind("test", addr, move || {
-                h1::H1Service::new(|_| ok::<_, ()>(Response::Ok().body(STR))).map(|_| ())
-            }).unwrap()
-            .run()
+    let mut srv = test::TestServer::with_factory(|| {
+        h1::H1Service::new(|_| ok::<_, ()>(Response::Ok().body(STR))).map(|_| ())
     });
-    thread::sleep(time::Duration::from_millis(100));
 
-    let mut sys = System::new("test");
-    let req = client::ClientRequest::head(format!("http://{}/", addr))
-        .finish()
-        .unwrap();
-    let response = sys.block_on(req.send()).unwrap();
+    let req = client::ClientRequest::head(srv.url("/")).finish().unwrap();
+    let response = srv.send_request(req).unwrap();
     assert!(response.status().is_success());
 
     {
@@ -349,57 +259,40 @@ fn test_head_binary2() {
 
 #[test]
 fn test_body_length() {
-    let addr = test::TestServer::unused_addr();
-    thread::spawn(move || {
-        Server::new()
-            .bind("test", addr, move || {
-                h1::H1Service::new(|_| {
-                    let body = once(Ok(Bytes::from_static(STR.as_ref())));
-                    ok::<_, ()>(Response::Ok().body(Body::from_message(
-                        body::SizedStream::new(STR.len(), body),
-                    )))
-                }).map(|_| ())
-            }).unwrap()
-            .run()
+    let mut srv = test::TestServer::with_factory(|| {
+        h1::H1Service::new(|_| {
+            let body = once(Ok(Bytes::from_static(STR.as_ref())));
+            ok::<_, ()>(
+                Response::Ok()
+                    .body(Body::from_message(body::SizedStream::new(STR.len(), body))),
+            )
+        }).map(|_| ())
     });
-    thread::sleep(time::Duration::from_millis(100));
 
-    let mut sys = System::new("test");
-    let req = client::ClientRequest::get(format!("http://{}/", addr))
-        .finish()
-        .unwrap();
-    let response = sys.block_on(req.send()).unwrap();
+    let req = srv.get().finish().unwrap();
+    let response = srv.send_request(req).unwrap();
     assert!(response.status().is_success());
 
     // read response
-    let bytes = sys.block_on(response.body()).unwrap();
+    let bytes = srv.block_on(response.body()).unwrap();
     assert_eq!(bytes, Bytes::from_static(STR.as_ref()));
 }
 
 #[test]
 fn test_body_chunked_explicit() {
-    let addr = test::TestServer::unused_addr();
-    thread::spawn(move || {
-        Server::new()
-            .bind("test", addr, move || {
-                h1::H1Service::new(|_| {
-                    let body = once::<_, Error>(Ok(Bytes::from_static(STR.as_ref())));
-                    ok::<_, ()>(Response::Ok().streaming(body))
-                }).map(|_| ())
-            }).unwrap()
-            .run()
+    let mut srv = test::TestServer::with_factory(|| {
+        h1::H1Service::new(|_| {
+            let body = once::<_, Error>(Ok(Bytes::from_static(STR.as_ref())));
+            ok::<_, ()>(Response::Ok().streaming(body))
+        }).map(|_| ())
     });
-    thread::sleep(time::Duration::from_millis(100));
 
-    let mut sys = System::new("test");
-    let req = client::ClientRequest::get(format!("http://{}/", addr))
-        .finish()
-        .unwrap();
-    let response = sys.block_on(req.send()).unwrap();
+    let req = srv.get().finish().unwrap();
+    let response = srv.send_request(req).unwrap();
     assert!(response.status().is_success());
 
     // read response
-    let bytes = sys.block_on(response.body()).unwrap();
+    let bytes = srv.block_on(response.body()).unwrap();
 
     // decode
     assert_eq!(bytes, Bytes::from_static(STR.as_ref()));
@@ -407,27 +300,18 @@ fn test_body_chunked_explicit() {
 
 #[test]
 fn test_body_chunked_implicit() {
-    let addr = test::TestServer::unused_addr();
-    thread::spawn(move || {
-        Server::new()
-            .bind("test", addr, move || {
-                h1::H1Service::new(|_| {
-                    let body = once::<_, Error>(Ok(Bytes::from_static(STR.as_ref())));
-                    ok::<_, ()>(Response::Ok().streaming(body))
-                }).map(|_| ())
-            }).unwrap()
-            .run()
+    let mut srv = test::TestServer::with_factory(|| {
+        h1::H1Service::new(|_| {
+            let body = once::<_, Error>(Ok(Bytes::from_static(STR.as_ref())));
+            ok::<_, ()>(Response::Ok().streaming(body))
+        }).map(|_| ())
     });
-    thread::sleep(time::Duration::from_millis(100));
 
-    let mut sys = System::new("test");
-    let req = client::ClientRequest::get(format!("http://{}/", addr))
-        .finish()
-        .unwrap();
-    let response = sys.block_on(req.send()).unwrap();
+    let req = srv.get().finish().unwrap();
+    let response = srv.send_request(req).unwrap();
     assert!(response.status().is_success());
 
     // read response
-    let bytes = sys.block_on(response.body()).unwrap();
+    let bytes = srv.block_on(response.body()).unwrap();
     assert_eq!(bytes, Bytes::from_static(STR.as_ref()));
 }

tests/test_ws.rs

@@ -5,20 +5,18 @@ extern crate actix_web;
 extern crate bytes;
 extern crate futures;
 
-use std::{io, thread};
+use std::io;
 
-use actix::System;
 use actix_net::codec::Framed;
 use actix_net::framed::IntoFramed;
-use actix_net::server::Server;
-use actix_net::service::{NewServiceExt, Service};
+use actix_net::service::NewServiceExt;
 use actix_net::stream::TakeItem;
-use actix_web::{test, ws as web_ws};
+use actix_web::ws as web_ws;
 use bytes::{Bytes, BytesMut};
-use futures::future::{lazy, ok, Either};
-use futures::{Future, IntoFuture, Sink, Stream};
+use futures::future::{ok, Either};
+use futures::{Future, Sink, Stream};
 
-use actix_http::{h1, ws, ResponseError, SendResponse, ServiceConfig};
+use actix_http::{h1, test, ws, ResponseError, SendResponse, ServiceConfig};
 
 fn ws_service(req: ws::Frame) -> impl Future<Item = ws::Message, Error = io::Error> {
     match req {
@@ -43,72 +41,66 @@ fn ws_service(req: ws::Frame) -> impl Future<Item = ws::Message, Error = io::Err
 
 #[test]
 fn test_simple() {
-    let addr = test::TestServer::unused_addr();
-    thread::spawn(move || {
-        Server::new()
-            .bind("test", addr, move || {
-                IntoFramed::new(|| h1::Codec::new(ServiceConfig::default()))
-                    .and_then(TakeItem::new().map_err(|_| ()))
-                    .and_then(|(req, framed): (_, Framed<_, _>)| {
-                        // validate request
-                        if let Some(h1::Message::Item(req)) = req {
-                            match ws::verify_handshake(&req) {
-                                Err(e) => {
-                                    // validation failed
-                                    Either::A(
-                                        SendResponse::send(framed, e.error_response())
-                                            .map_err(|_| ())
-                                            .map(|_| ()),
-                                    )
-                                }
-                                Ok(_) => {
-                                    Either::B(
-                                        // send handshake response
-                                        SendResponse::send(
-                                            framed,
-                                            ws::handshake_response(&req).finish(),
-                                        ).map_err(|_| ())
-                                        .and_then(|framed| {
-                                            // start websocket service
-                                            let framed =
-                                                framed.into_framed(ws::Codec::new());
-                                            ws::Transport::with(framed, ws_service)
-                                                .map_err(|_| ())
-                                        }),
-                                    )
-                                }
-                            }
-                        } else {
-                            panic!()
+    let mut srv = test::TestServer::with_factory(|| {
+        IntoFramed::new(|| h1::Codec::new(ServiceConfig::default()))
+            .and_then(TakeItem::new().map_err(|_| ()))
+            .and_then(|(req, framed): (_, Framed<_, _>)| {
+                // validate request
+                if let Some(h1::Message::Item(req)) = req {
+                    match ws::verify_handshake(&req) {
+                        Err(e) => {
+                            // validation failed
+                            Either::A(
+                                SendResponse::send(framed, e.error_response())
+                                    .map_err(|_| ())
+                                    .map(|_| ()),
+                            )
                         }
-                    })
-            }).unwrap()
-            .run();
+                        Ok(_) => {
+                            Either::B(
+                                // send handshake response
+                                SendResponse::send(
+                                    framed,
+                                    ws::handshake_response(&req).finish(),
+                                ).map_err(|_| ())
+                                .and_then(|framed| {
+                                    // start websocket service
+                                    let framed = framed.into_framed(ws::Codec::new());
+                                    ws::Transport::with(framed, ws_service)
+                                        .map_err(|_| ())
+                                }),
+                            )
+                        }
+                    }
+                } else {
+                    panic!()
+                }
+            })
     });
 
-    let mut sys = System::new("test");
     {
-        let (reader, mut writer) = sys
-            .block_on(web_ws::Client::new(format!("http://{}/", addr)).connect())
-            .unwrap();
+        let url = srv.url("/");
+
+        let (reader, mut writer) =
+            srv.block_on(web_ws::Client::new(url).connect()).unwrap();
 
         writer.text("text");
-        let (item, reader) = sys.block_on(reader.into_future()).unwrap();
+        let (item, reader) = srv.block_on(reader.into_future()).unwrap();
         assert_eq!(item, Some(web_ws::Message::Text("text".to_owned())));
 
         writer.binary(b"text".as_ref());
-        let (item, reader) = sys.block_on(reader.into_future()).unwrap();
+        let (item, reader) = srv.block_on(reader.into_future()).unwrap();
         assert_eq!(
             item,
             Some(web_ws::Message::Binary(Bytes::from_static(b"text").into()))
         );
 
         writer.ping("ping");
-        let (item, reader) = sys.block_on(reader.into_future()).unwrap();
+        let (item, reader) = srv.block_on(reader.into_future()).unwrap();
         assert_eq!(item, Some(web_ws::Message::Pong("ping".to_owned())));
 
         writer.close(Some(web_ws::CloseCode::Normal.into()));
-        let (item, _) = sys.block_on(reader.into_future()).unwrap();
+        let (item, _) = srv.block_on(reader.into_future()).unwrap();
         assert_eq!(
             item,
             Some(web_ws::Message::Close(Some(
@@ -118,39 +110,33 @@ fn test_simple() {
     }
 
     // client service
-    let mut client = sys
-        .block_on(lazy(|| Ok::<_, ()>(ws::Client::default()).into_future()))
-        .unwrap();
-    let framed = sys
-        .block_on(client.call(ws::Connect::new(format!("http://{}/", addr))))
-        .unwrap();
-
-    let framed = sys
+    let framed = srv.ws().unwrap();
+    let framed = srv
         .block_on(framed.send(ws::Message::Text("text".to_string())))
         .unwrap();
-    let (item, framed) = sys.block_on(framed.into_future()).map_err(|_| ()).unwrap();
+    let (item, framed) = srv.block_on(framed.into_future()).map_err(|_| ()).unwrap();
     assert_eq!(item, Some(ws::Frame::Text(Some(BytesMut::from("text")))));
 
-    let framed = sys
+    let framed = srv
         .block_on(framed.send(ws::Message::Binary("text".into())))
         .unwrap();
-    let (item, framed) = sys.block_on(framed.into_future()).map_err(|_| ()).unwrap();
+    let (item, framed) = srv.block_on(framed.into_future()).map_err(|_| ()).unwrap();
     assert_eq!(
         item,
         Some(ws::Frame::Binary(Some(Bytes::from_static(b"text").into())))
     );
 
-    let framed = sys
+    let framed = srv
         .block_on(framed.send(ws::Message::Ping("text".into())))
         .unwrap();
-    let (item, framed) = sys.block_on(framed.into_future()).map_err(|_| ()).unwrap();
+    let (item, framed) = srv.block_on(framed.into_future()).map_err(|_| ()).unwrap();
     assert_eq!(item, Some(ws::Frame::Pong("text".to_string().into())));
 
-    let framed = sys
+    let framed = srv
         .block_on(framed.send(ws::Message::Close(Some(ws::CloseCode::Normal.into()))))
         .unwrap();
 
-    let (item, _framed) = sys.block_on(framed.into_future()).map_err(|_| ()).unwrap();
+    let (item, _framed) = srv.block_on(framed.into_future()).map_err(|_| ()).unwrap();
     assert_eq!(
         item,
         Some(ws::Frame::Close(Some(ws::CloseCode::Normal.into())))