fix tests

Cargo.toml

@@ -47,10 +47,10 @@ compress = ["actix-http/compress", "awc/compress"]
 secure-cookies = ["actix-http/secure-cookies"]
 
 # openssl
-openssl = ["actix-tls/openssl", "awc/openssl", "open-ssl"]
+openssl = ["actix-tls/accept", "actix-tls/openssl", "awc/openssl", "open-ssl"]
 
 # rustls
-rustls = ["actix-tls/rustls", "awc/rustls", "rust-tls"]
+rustls = ["actix-tls/accept", "actix-tls/rustls", "awc/rustls", "rust-tls"]
 
 [[example]]
 name = "basic"
@@ -74,15 +74,14 @@ required-features = ["rustls"]
 
 [dependencies]
 actix-codec = "0.4.0-beta.1"
-actix-service = "2.0.0-beta.1"
+actix-macros = "0.1.0"
-actix-utils = "3.0.0-beta.1"
 actix-router = "0.2.4"
 actix-rt = "2.0.0-beta.1"
 actix-server = "2.0.0-beta.1"
-#actix-testing = "1.0.0"
+actix-service = "2.0.0-beta.1"
-actix-macros = "0.1.0"
+actix-utils = "3.0.0-beta.1"
 actix-threadpool = "0.3.1"
-actix-tls = "3.0.0-beta.1"
+actix-tls = { version = "3.0.0-beta.1", default-features = false, optional = true }
 
 actix-web-codegen = "0.4.0"
 actix-http = "2.2.0"
@@ -110,7 +109,7 @@ tinyvec = { version = "1", features = ["alloc"] }
 
 [dev-dependencies]
 actix = "0.10.0"
-actix-http = { version = "2.1.0", features = ["actors"] }
+actix-http = { version = "2.2.0", features = ["actors"] }
 rand = "0.8"
 env_logger = "0.8"
 serde_derive = "1.0"
@@ -133,12 +132,12 @@ actix-files = { path = "actix-files" }
 awc = { path = "awc" }
 
 # FIXME: remove these override
-actix-tls = { git = "https://github.com/actix/actix-net.git", branch = "fix/actix-tls" }
+actix = { git = "https://github.com/fakeshadow/actix.git", branch = "tokio-0.3" }
-actix-service = { path = "../actix-net/actix-service" }
+actix-tls = { git = "https://github.com/actix/actix-net.git", branch = "master" }
-
+actix-server = { git = "https://github.com/actix/actix-net.git", branch = "master" }
-#http = { git = "https://github.com/fakeshadow/http.git" }
+actix-service = { git = "https://github.com/actix/actix-net.git", branch = "master" }
-trust-dns-proto = { git = "https://github.com/messense/trust-dns.git", branch = "tokio-1" }
+trust-dns-proto = { git = "https://github.com/bluejekyll/trust-dns.git", branch = "main" }
-trust-dns-resolver = { git = "https://github.com/messense/trust-dns.git", branch = "tokio-1" }
+trust-dns-resolver = { git = "https://github.com/bluejekyll/trust-dns.git", branch = "main" }
 
 [[bench]]
 name = "server"

actix-files/Cargo.toml

@@ -18,7 +18,7 @@ path = "src/lib.rs"
 
 [dependencies]
 actix-web = { version = "3.0.0", default-features = false }
-actix-service = "1.0.6"
+actix-service = "2.0.0-beta.1"
 bitflags = "1"
 bytes = "1"
 futures-core = { version = "0.3.7", default-features = false }
@@ -31,5 +31,5 @@ percent-encoding = "2.1"
 v_htmlescape = "0.12"
 
 [dev-dependencies]
-actix-rt = "1.0.0"
+actix-rt = "2.0.0-beta.1"
 actix-web = "3.0.0"

actix-files/src/files.rs

@@ -1,6 +1,6 @@
 use std::{cell::RefCell, fmt, io, path::PathBuf, rc::Rc};
 
-use actix_service::{boxed, IntoServiceFactory, ServiceFactory};
+use actix_service::{boxed, IntoServiceFactory, ServiceFactory, ServiceFactoryExt};
 use actix_web::{
     dev::{
         AppService, HttpServiceFactory, ResourceDef, ServiceRequest, ServiceResponse,
@@ -201,10 +201,10 @@ impl Files {
     /// Sets default handler which is used when no matched file could be found.
     pub fn default_handler<F, U>(mut self, f: F) -> Self
     where
-        F: IntoServiceFactory<U>,
+        F: IntoServiceFactory<U, ServiceRequest>,
         U: ServiceFactory<
+                ServiceRequest,
                 Config = (),
-                Request = ServiceRequest,
                 Response = ServiceResponse,
                 Error = Error,
             > + 'static,
@@ -241,8 +241,7 @@ impl HttpServiceFactory for Files {
     }
 }
 
-impl ServiceFactory for Files {
+impl ServiceFactory<ServiceRequest> for Files {
-    type Request = ServiceRequest;
     type Response = ServiceResponse;
     type Error = Error;
     type Config = ();

actix-files/src/service.rs

@@ -57,8 +57,7 @@ impl fmt::Debug for FilesService {
     }
 }
 
-impl Service for FilesService {
+impl Service<ServiceRequest> for FilesService {
-    type Request = ServiceRequest;
     type Response = ServiceResponse;
     type Error = Error;
     type Future = FilesServiceFuture;

actix-http-test/Cargo.toml

@@ -31,11 +31,10 @@ openssl = ["open-ssl", "awc/openssl"]
 [dependencies]
 actix-service = "2.0.0-beta.1"
 actix-codec = "0.4.0-beta.1"
-#actix-connect = "2.0.0"
+actix-tls = "3.0.0-beta.1"
 actix-utils = "3.0.0-beta.1"
 actix-rt = "2.0.0-beta.1"
 actix-server = "2.0.0-beta.1"
-#actix-testing = "1.0.0"
 awc = "2.0.0"
 
 base64 = "0.13"

actix-http-test/src/lib.rs

@@ -16,8 +16,6 @@ use futures_core::stream::Stream;
 use http::Method;
 use socket2::{Domain, Protocol, Socket, Type};
 
-pub use actix_testing::*;
-
 /// Start test server
 ///
 /// `TestServer` is very simple test server that simplify process of writing
@@ -65,13 +63,16 @@ pub async fn test_server_with_addr<F: ServiceFactory<TcpStream>>(
         let sys = System::new("actix-test-server");
         let local_addr = tcp.local_addr().unwrap();
 
-        Server::build()
+        let srv = Server::build()
             .listen("test", tcp, factory)?
             .workers(1)
-            .disable_signals()
+            .disable_signals();
-            .start();
+
+        sys.block_on(async {
+            srv.start();
+            tx.send((System::current(), local_addr)).unwrap();
+        });
 
-        tx.send((System::current(), local_addr)).unwrap();
         sys.run()
     });
 
@@ -105,7 +106,7 @@ pub async fn test_server_with_addr<F: ServiceFactory<TcpStream>>(
 
         Client::builder().connector(connector).finish()
     };
-    actix_connect::start_default_resolver().await.unwrap();
+    actix_tls::connect::start_default_resolver().await.unwrap();
 
     TestServer {
         addr,

actix-http/Cargo.toml

@@ -45,7 +45,7 @@ actix-codec = "0.4.0-beta.1"
 actix-utils = "3.0.0-beta.1"
 actix-rt = "2.0.0-beta.1"
 actix-threadpool = "0.3.1"
-actix-tls = { version = "3.0.0-beta.1" }
+actix-tls = "3.0.0-beta.1"
 actix = { version = "0.10.0", optional = true }
 
 base64 = "0.13"
@@ -87,7 +87,7 @@ flate2 = { version = "1.0.13", optional = true }
 [dev-dependencies]
 actix-server = "2.0.0-beta.1"
 actix-http-test = { version = "2.0.0", features = ["openssl"] }
-actix-tls = { version = "2.0.0", features = ["openssl"] }
+actix-tls = { version = "3.0.0-beta.1", features = ["openssl"] }
 criterion = "0.3"
 env_logger = "0.7"
 serde_derive = "1.0"

actix-http/src/h1/dispatcher.rs

@@ -978,7 +978,7 @@ where
 
 #[cfg(test)]
 mod tests {
-    use std::{marker::PhantomData, str};
+    use std::str;
 
     use actix_service::fn_service;
     use futures_util::future::{lazy, ready};
@@ -1040,7 +1040,7 @@ mod tests {
         lazy(|cx| {
             let buf = TestBuffer::new("GET /test HTTP/1\r\n\r\n");
 
-            let h1 = Dispatcher::<_, _, _, _, UpgradeHandler<TestBuffer>>::new(
+            let h1 = Dispatcher::<_, _, _, _, UpgradeHandler>::new(
                 buf,
                 ServiceConfig::default(),
                 CloneableService::new(ok_service()),
@@ -1081,7 +1081,7 @@ mod tests {
 
             let cfg = ServiceConfig::new(KeepAlive::Disabled, 1, 1, false, None);
 
-            let h1 = Dispatcher::<_, _, _, _, UpgradeHandler<TestBuffer>>::new(
+            let h1 = Dispatcher::<_, _, _, _, UpgradeHandler>::new(
                 buf,
                 cfg,
                 CloneableService::new(echo_path_service()),
@@ -1136,7 +1136,7 @@ mod tests {
 
             let cfg = ServiceConfig::new(KeepAlive::Disabled, 1, 1, false, None);
 
-            let h1 = Dispatcher::<_, _, _, _, UpgradeHandler<TestBuffer>>::new(
+            let h1 = Dispatcher::<_, _, _, _, UpgradeHandler>::new(
                 buf,
                 cfg,
                 CloneableService::new(echo_path_service()),
@@ -1186,7 +1186,7 @@ mod tests {
         lazy(|cx| {
             let mut buf = TestSeqBuffer::empty();
             let cfg = ServiceConfig::new(KeepAlive::Disabled, 0, 0, false, None);
-            let h1 = Dispatcher::<_, _, _, _, UpgradeHandler<_>>::new(
+            let h1 = Dispatcher::<_, _, _, _, UpgradeHandler>::new(
                 buf.clone(),
                 cfg,
                 CloneableService::new(echo_payload_service()),
@@ -1258,7 +1258,7 @@ mod tests {
         lazy(|cx| {
             let mut buf = TestSeqBuffer::empty();
             let cfg = ServiceConfig::new(KeepAlive::Disabled, 0, 0, false, None);
-            let h1 = Dispatcher::<_, _, _, _, UpgradeHandler<_>>::new(
+            let h1 = Dispatcher::<_, _, _, _, UpgradeHandler>::new(
                 buf.clone(),
                 cfg,
                 CloneableService::new(echo_path_service()),
@@ -1318,12 +1318,12 @@ mod tests {
         lazy(|cx| {
             let mut buf = TestSeqBuffer::empty();
             let cfg = ServiceConfig::new(KeepAlive::Disabled, 0, 0, false, None);
-            let h1 = Dispatcher::<_, _, _, _, UpgradeHandler<_>>::new(
+            let h1 = Dispatcher::<_, _, _, _, UpgradeHandler>::new(
                 buf.clone(),
                 cfg,
                 CloneableService::new(ok_service()),
                 CloneableService::new(ExpectHandler),
-                Some(CloneableService::new(UpgradeHandler(PhantomData))),
+                Some(CloneableService::new(UpgradeHandler)),
                 None,
                 Extensions::new(),
                 None,

actix-http/src/h1/expect.rs

@@ -9,9 +9,9 @@ use crate::request::Request;
 pub struct ExpectHandler;
 
 impl ServiceFactory<Request> for ExpectHandler {
-    type Config = ();
     type Response = Request;
     type Error = Error;
+    type Config = ();
     type Service = ExpectHandler;
     type InitError = Error;
     type Future = Ready<Result<Self::Service, Self::InitError>>;

actix-http/src/request.rs

@@ -23,6 +23,10 @@ impl<P> HttpMessage for Request<P> {
         &self.head().headers
     }
 
+    fn take_payload(&mut self) -> Payload<P> {
+        std::mem::replace(&mut self.payload, Payload::None)
+    }
+
     /// Request extensions
     #[inline]
     fn extensions(&self) -> Ref<'_, Extensions> {
@@ -34,10 +38,6 @@ impl<P> HttpMessage for Request<P> {
     fn extensions_mut(&self) -> RefMut<'_, Extensions> {
         self.head.extensions_mut()
     }
-
-    fn take_payload(&mut self) -> Payload<P> {
-        std::mem::replace(&mut self.payload, Payload::None)
-    }
 }
 
 impl From<Message<RequestHead>> for Request<PayloadStream> {

actix-http/src/service.rs

@@ -348,11 +348,11 @@ where
     U::InitError: fmt::Debug,
     <U::Service as Service<(Request, Framed<T, h1::Codec>)>>::Future: 'static,
 {
-    type Config = ();
     type Response = ();
     type Error = DispatchError;
-    type InitError = ();
+    type Config = ();
     type Service = HttpServiceHandler<T, S::Service, B, X::Service, U::Service>;
+    type InitError = ();
     type Future = HttpServiceResponse<T, S, B, X, U>;
 
     fn new_service(&self, _: ()) -> Self::Future {

actix-http/tests/test_client.rs

@@ -1,9 +1,8 @@
-use actix_service::ServiceFactory;
-use bytes::Bytes;
-use futures_util::future::{self, ok};
-
 use actix_http::{http, HttpService, Request, Response};
 use actix_http_test::test_server;
+use actix_service::ServiceFactoryExt;
+use bytes::Bytes;
+use futures_util::future::{self, ok};
 
 const STR: &str = "Hello World Hello World Hello World Hello World Hello World \
                    Hello World Hello World Hello World Hello World Hello World \

actix-http/tests/test_openssl.rs

@@ -1,19 +1,17 @@
 #![cfg(feature = "openssl")]
 use std::io;
 
-use actix_http_test::test_server;
-use actix_service::{fn_service, ServiceFactory};
-
-use bytes::{Bytes, BytesMut};
-use futures_util::future::{err, ok, ready};
-use futures_util::stream::{once, Stream, StreamExt};
-use open_ssl::ssl::{AlpnError, SslAcceptor, SslFiletype, SslMethod};
-
 use actix_http::error::{ErrorBadRequest, PayloadError};
 use actix_http::http::header::{self, HeaderName, HeaderValue};
 use actix_http::http::{Method, StatusCode, Version};
 use actix_http::httpmessage::HttpMessage;
 use actix_http::{body, Error, HttpService, Request, Response};
+use actix_http_test::test_server;
+use actix_service::{fn_service, ServiceFactoryExt};
+use bytes::{Bytes, BytesMut};
+use futures_util::future::{err, ok, ready};
+use futures_util::stream::{once, Stream, StreamExt};
+use open_ssl::ssl::{AlpnError, SslAcceptor, SslFiletype, SslMethod};
 
 async fn load_body<S>(stream: S) -> Result<BytesMut, PayloadError>
 where

actix-multipart/Cargo.toml

@@ -17,7 +17,6 @@ path = "src/lib.rs"
 
 [dependencies]
 actix-web = { version = "3.0.0", default-features = false }
-actix-service = "2.0.0-beta.1"
 actix-utils = "3.0.0-beta.1"
 
 bytes = "1"
@@ -29,5 +28,5 @@ mime = "0.3"
 twoway = "0.2"
 
 [dev-dependencies]
-actix-rt = "1.0.0"
+actix-rt = "2.0.0-beta.1"
 actix-http = "2.0.0"

actix-web-actors/Cargo.toml

@@ -17,15 +17,16 @@ path = "src/lib.rs"
 
 [dependencies]
 actix = "0.10.0"
-actix-web = { version = "3.0.0", default-features = false }
+actix-codec = "0.4.0-beta.1"
 actix-http = "2.0.0"
-actix-codec = "0.3.0"
+actix-web = { version = "3.0.0", default-features = false }
+
 bytes = "1"
 futures-channel = { version = "0.3.7", default-features = false }
 futures-core = { version = "0.3.7", default-features = false }
 pin-project = "1.0.0"
 
 [dev-dependencies]
-actix-rt = "1.1.1"
+actix-rt = "2.0.0-beta.1"
 env_logger = "0.7"
 futures-util = { version = "0.3.7", default-features = false }

actix-web-codegen/Cargo.toml

@@ -19,7 +19,7 @@ syn = { version = "1", features = ["full", "parsing"] }
 proc-macro2 = "1"
 
 [dev-dependencies]
-actix-rt = "1.1.1"
+actix-rt = "2.0.0-beta.1"
 actix-web = "3.0.0"
 futures-util = { version = "0.3.7", default-features = false }
 trybuild = "1"

actix-web-codegen/tests/test_macro.rs

@@ -88,17 +88,16 @@ async fn route_test() -> impl Responder {
 
 pub struct ChangeStatusCode;
 
-impl<S, B> Transform<S> for ChangeStatusCode
+impl<S, B> Transform<S, ServiceRequest> for ChangeStatusCode
 where
-    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
+    S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
     S::Future: 'static,
     B: 'static,
 {
-    type Request = ServiceRequest;
     type Response = ServiceResponse<B>;
     type Error = Error;
-    type InitError = ();
     type Transform = ChangeStatusCodeMiddleware<S>;
+    type InitError = ();
     type Future = future::Ready<Result<Self::Transform, Self::InitError>>;
 
     fn new_transform(&self, service: S) -> Self::Future {
@@ -110,13 +109,12 @@ pub struct ChangeStatusCodeMiddleware<S> {
     service: S,
 }
 
-impl<S, B> Service for ChangeStatusCodeMiddleware<S>
+impl<S, B> Service<ServiceRequest> for ChangeStatusCodeMiddleware<S>
 where
-    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
+    S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
     S::Future: 'static,
     B: 'static,
 {
-    type Request = ServiceRequest;
     type Response = ServiceResponse<B>;
     type Error = Error;
     #[allow(clippy::type_complexity)]

awc/Cargo.toml

@@ -58,13 +58,12 @@ open-ssl = { version = "0.10", package = "openssl", optional = true }
 rust-tls = { version = "0.19.0", package = "rustls", optional = true, features = ["dangerous_configuration"] }
 
 [dev-dependencies]
-#actix-connect = { version = "2.0.0", features = ["openssl"] }
 actix-web = { version = "3.0.0", features = ["openssl"] }
 actix-http = { version = "2.0.0", features = ["openssl"] }
 actix-http-test = { version = "2.0.0", features = ["openssl"] }
 actix-utils = "3.0.0-beta.1"
 actix-server = "2.0.0-beta.1"
-#actix-tls = { version = "3", features = ["openssl", "rustls"] }
+actix-tls = { version = "3.0.0-beta.1", features = ["openssl", "rustls"] }
 brotli2 = "0.3.2"
 flate2 = "1.0.13"
 futures-util = { version = "0.3.7", default-features = false }

awc/tests/test_client.rs

@@ -114,8 +114,8 @@ async fn test_timeout() {
     });
 
     let connector = awc::Connector::new()
-        .connector(actix_connect::new_connector(
+        .connector(actix_tls::connect::new_connector(
-            actix_connect::start_default_resolver().await.unwrap(),
+            actix_tls::connect::start_default_resolver().await.unwrap(),
         ))
         .timeout(Duration::from_secs(15))
         .finish();

awc/tests/test_connector.rs

@@ -1,7 +1,7 @@
 #![cfg(feature = "openssl")]
 use actix_http::HttpService;
 use actix_http_test::test_server;
-use actix_service::{map_config, ServiceFactory};
+use actix_service::{map_config, ServiceFactoryExt};
 use actix_web::http::Version;
 use actix_web::{dev::AppConfig, web, App, HttpResponse};
 use open_ssl::ssl::{SslAcceptor, SslConnector, SslFiletype, SslMethod, SslVerifyMode};

awc/tests/test_rustls_client.rs

@@ -4,7 +4,7 @@ use std::sync::Arc;
 
 use actix_http::HttpService;
 use actix_http_test::test_server;
-use actix_service::{map_config, pipeline_factory, ServiceFactory};
+use actix_service::{map_config, pipeline_factory, ServiceFactoryExt};
 use actix_web::http::Version;
 use actix_web::{dev::AppConfig, web, App, HttpResponse};
 use futures_util::future::ok;

awc/tests/test_ssl_client.rs

@@ -4,7 +4,7 @@ use std::sync::Arc;
 
 use actix_http::HttpService;
 use actix_http_test::test_server;
-use actix_service::{map_config, pipeline_factory, ServiceFactory};
+use actix_service::{map_config, pipeline_factory, ServiceFactoryExt};
 use actix_web::http::Version;
 use actix_web::{dev::AppConfig, web, App, HttpResponse};
 use futures_util::future::ok;

benches/server.rs

@@ -29,18 +29,22 @@ const STR: &str = "Hello World Hello World Hello World Hello World Hello World \
 fn bench_async_burst(c: &mut Criterion) {
     // We are using System here, since Runtime requires preinitialized tokio
     // Maybe add to actix_rt docs
-    let mut rt = actix_rt::System::new("test");
+    let rt = actix_rt::System::new("test");
 
-    let srv = test::start(|| {
+    let srv = rt.block_on(async {
-        App::new()
+        test::start(|| {
-            .service(web::resource("/").route(web::to(|| HttpResponse::Ok().body(STR))))
+            App::new().service(
+                web::resource("/").route(web::to(|| HttpResponse::Ok().body(STR))),
+            )
+        })
     });
 
     let url = srv.url("/");
 
     c.bench_function("get_body_async_burst", move |b| {
         b.iter_custom(|iters| {
-            let client = Client::new().get(url.clone()).freeze().unwrap();
+            let client =
+                rt.block_on(async { Client::new().get(url.clone()).freeze().unwrap() });
 
             let start = std::time::Instant::now();
             // benchmark body

benches/service.rs

@@ -23,8 +23,7 @@ use actix_web::test::{init_service, ok_service, TestRequest};
 /// async_service_direct    time:   [1.0908 us 1.1656 us 1.2613 us]
 pub fn bench_async_service<S>(c: &mut Criterion, srv: S, name: &str)
 where
-    S: Service<Request = ServiceRequest, Response = ServiceResponse, Error = Error>
+    S: Service<ServiceRequest, Response = ServiceResponse, Error = Error> + 'static,
-        + 'static,
 {
     let rt = actix_rt::System::new("test");
     let srv = Rc::new(RefCell::new(srv));
@@ -41,14 +40,15 @@ where
         b.iter_custom(|iters| {
             let srv = srv.clone();
             // exclude request generation, it appears it takes significant time vs call (3us vs 1us)
-            let reqs: Vec<_> = (0..iters)
+            let futs = (0..iters)
                 .map(|_| TestRequest::default().to_srv_request())
-                .collect();
+                .map(|req| srv.borrow_mut().call(req));
+
             let start = std::time::Instant::now();
             // benchmark body
             rt.block_on(async move {
-                for req in reqs {
+                for fut in futs {
-                    srv.borrow_mut().call(req).await.unwrap();
+                    fut.await.unwrap();
                 }
             });
             let elapsed = start.elapsed();
@@ -83,13 +83,14 @@ fn async_web_service(c: &mut Criterion) {
     c.bench_function("async_web_service_direct", move |b| {
         b.iter_custom(|iters| {
             let srv = srv.clone();
-            let reqs = (0..iters).map(|_| TestRequest::get().uri("/").to_request());
+            let futs = (0..iters)
-
+                .map(|_| TestRequest::get().uri("/").to_request())
+                .map(|req| srv.borrow_mut().call(req));
             let start = std::time::Instant::now();
             // benchmark body
             rt.block_on(async move {
-                for req in reqs {
+                for fut in futs {
-                    srv.borrow_mut().call(req).await.unwrap();
+                    fut.await.unwrap();
                 }
             });
             let elapsed = start.elapsed();

src/server.rs

@@ -171,7 +171,9 @@ where
     /// limit the global TLS CPU usage.
     ///
     /// By default max connections is set to a 256.
+    #[allow(unused_variables)]
     pub fn max_connection_rate(self, num: usize) -> Self {
+        #[cfg(any(feature = "rustls", feature = "openssl"))]
         actix_tls::accept::max_concurrent_tls_connect(num);
         self
     }

src/test.rs

@@ -785,9 +785,11 @@ where
         }
         .unwrap();
 
-        let srv = sys.block_on(async { srv.start() });
+        sys.block_on(async {
+            let srv = srv.start();
+            tx.send((System::current(), srv, local_addr)).unwrap();
+        });
 
-        tx.send((System::current(), srv, local_addr)).unwrap();
         sys.run()
     });
 

tests/test_httpserver.rs

@@ -15,8 +15,8 @@ async fn test_start() {
     thread::spawn(move || {
         let sys = actix_rt::System::new("test");
 
-        let srv = sys.block_on(async {
+        sys.block_on(async {
-            HttpServer::new(|| {
+            let srv = HttpServer::new(|| {
                 App::new().service(
                     web::resource("/")
                         .route(web::to(|| HttpResponse::Ok().body("test"))),
@@ -34,10 +34,11 @@ async fn test_start() {
             .disable_signals()
             .bind(format!("{}", addr))
             .unwrap()
-            .run()
+            .run();
+
+            let _ = tx.send((srv, actix_rt::System::current()));
         });
 
-        let _ = tx.send((srv, actix_rt::System::current()));
         let _ = sys.run();
     });
     let (srv, sys) = rx.recv().unwrap();
@@ -103,10 +104,13 @@ async fn test_start_ssl() {
         .system_exit()
         .disable_signals()
         .bind_openssl(format!("{}", addr), builder)
-        .unwrap()
+        .unwrap();
-        .run();
+
+        sys.block_on(async {
+            let srv = srv.run();
+            let _ = tx.send((srv, actix_rt::System::current()));
+        });
 
-        let _ = tx.send((srv, actix_rt::System::current()));
         let _ = sys.run();
     });
     let (srv, sys) = rx.recv().unwrap();