diff --git a/actix-connect/Cargo.toml b/actix-connect/Cargo.toml
index b60ceeb9..7fad76d5 100644
--- a/actix-connect/Cargo.toml
+++ b/actix-connect/Cargo.toml
@@ -41,6 +41,7 @@ either = "1.5.3"
 futures-util = { version = "0.3.4", default-features = false }
 http = { version = "0.2.0", optional = true }
 log = "0.4"
+tokio-compat-02 = "0.1.2"
 trust-dns-proto = { version = "0.19", default-features = false, features = ["tokio-runtime"] }
 trust-dns-resolver = { version = "0.19", default-features = false, features = ["tokio-runtime", "system-config"] }
 
diff --git a/actix-connect/src/lib.rs b/actix-connect/src/lib.rs
index ea6d7ab8..d5fde318 100644
--- a/actix-connect/src/lib.rs
+++ b/actix-connect/src/lib.rs
@@ -43,28 +43,37 @@ pub async fn start_resolver(
     cfg: ResolverConfig,
     opts: ResolverOpts,
 ) -> Result<AsyncResolver, ConnectError> {
-    Ok(AsyncResolver::tokio(cfg, opts).await?)
+    // FIXME: remove compat layer
+    use tokio_compat_02::FutureExt;
+    async {
+        Ok(AsyncResolver::tokio(cfg, opts).await?)
+    }.compat().await
 }
 
 struct DefaultResolver(AsyncResolver);
 
 pub(crate) async fn get_default_resolver() -> Result<AsyncResolver, ConnectError> {
-    if Arbiter::contains_item::<DefaultResolver>() {
-        Ok(Arbiter::get_item(|item: &DefaultResolver| item.0.clone()))
-    } else {
-        let (cfg, opts) = match read_system_conf() {
-            Ok((cfg, opts)) => (cfg, opts),
-            Err(e) => {
-                log::error!("TRust-DNS can not load system config: {}", e);
-                (ResolverConfig::default(), ResolverOpts::default())
-            }
-        };
+    // FIXME: remove compat layer
+    use tokio_compat_02::FutureExt;
+    async {
 
-        let resolver = AsyncResolver::tokio(cfg, opts).await?;
+        if Arbiter::contains_item::<DefaultResolver>() {
+            Ok(Arbiter::get_item(|item: &DefaultResolver| item.0.clone()))
+        } else {
+            let (cfg, opts) = match read_system_conf() {
+                Ok((cfg, opts)) => (cfg, opts),
+                Err(e) => {
+                    log::error!("TRust-DNS can not load system config: {}", e);
+                    (ResolverConfig::default(), ResolverOpts::default())
+                }
+            };
 
-        Arbiter::set_item(DefaultResolver(resolver.clone()));
-        Ok(resolver)
-    }
+            let resolver = AsyncResolver::tokio(cfg, opts).await?;
+
+            Arbiter::set_item(DefaultResolver(resolver.clone()));
+            Ok(resolver)
+        }
+    }.compat().await
 }
 
 pub async fn start_default_resolver() -> Result<AsyncResolver, ConnectError> {
diff --git a/actix-connect/tests/test_connect.rs b/actix-connect/tests/test_connect.rs
index b156a778..21d78d2c 100644
--- a/actix-connect/tests/test_connect.rs
+++ b/actix-connect/tests/test_connect.rs
@@ -1,127 +1,127 @@
-// use std::io;
-//
-// use actix_codec::{BytesCodec, Framed};
-// use actix_rt::net::TcpStream;
-// use actix_service::{fn_service, Service, ServiceFactory};
-// use actix_testing::TestServer;
-// use bytes::Bytes;
-// use futures_util::sink::SinkExt;
-//
-// use actix_connect::resolver::{ResolverConfig, ResolverOpts};
-// use actix_connect::Connect;
-//
-// #[cfg(feature = "openssl")]
-// #[actix_rt::test]
-// async fn test_string() {
-//     let srv = TestServer::with(|| {
-//         fn_service(|io: TcpStream| async {
-//             let mut framed = Framed::new(io, BytesCodec);
-//             framed.send(Bytes::from_static(b"test")).await?;
-//             Ok::<_, io::Error>(())
-//         })
-//     });
-//
-//     let mut conn = actix_connect::default_connector();
-//     let addr = format!("localhost:{}", srv.port());
-//     let con = conn.call(addr.into()).await.unwrap();
-//     assert_eq!(con.peer_addr().unwrap(), srv.addr());
-// }
-//
-// #[cfg(feature = "rustls")]
-// #[actix_rt::test]
-// async fn test_rustls_string() {
-//     let srv = TestServer::with(|| {
-//         fn_service(|io: TcpStream| async {
-//             let mut framed = Framed::new(io, BytesCodec);
-//             framed.send(Bytes::from_static(b"test")).await?;
-//             Ok::<_, io::Error>(())
-//         })
-//     });
-//
-//     let mut conn = actix_connect::default_connector();
-//     let addr = format!("localhost:{}", srv.port());
-//     let con = conn.call(addr.into()).await.unwrap();
-//     assert_eq!(con.peer_addr().unwrap(), srv.addr());
-// }
-//
-// #[actix_rt::test]
-// async fn test_static_str() {
-//     let srv = TestServer::with(|| {
-//         fn_service(|io: TcpStream| async {
-//             let mut framed = Framed::new(io, BytesCodec);
-//             framed.send(Bytes::from_static(b"test")).await?;
-//             Ok::<_, io::Error>(())
-//         })
-//     });
-//
-//     let resolver = actix_connect::start_default_resolver().await.unwrap();
-//     let mut conn = actix_connect::new_connector(resolver.clone());
-//
-//     let con = conn.call(Connect::with("10", srv.addr())).await.unwrap();
-//     assert_eq!(con.peer_addr().unwrap(), srv.addr());
-//
-//     let connect = Connect::new(srv.host().to_owned());
-//     let mut conn = actix_connect::new_connector(resolver);
-//     let con = conn.call(connect).await;
-//     assert!(con.is_err());
-// }
-//
-// #[actix_rt::test]
-// async fn test_new_service() {
-//     let srv = TestServer::with(|| {
-//         fn_service(|io: TcpStream| async {
-//             let mut framed = Framed::new(io, BytesCodec);
-//             framed.send(Bytes::from_static(b"test")).await?;
-//             Ok::<_, io::Error>(())
-//         })
-//     });
-//
-//     let resolver =
-//         actix_connect::start_resolver(ResolverConfig::default(), ResolverOpts::default())
-//             .await
-//             .unwrap();
-//
-//     let factory = actix_connect::new_connector_factory(resolver);
-//
-//     let mut conn = factory.new_service(()).await.unwrap();
-//     let con = conn.call(Connect::with("10", srv.addr())).await.unwrap();
-//     assert_eq!(con.peer_addr().unwrap(), srv.addr());
-// }
-//
-// #[cfg(all(feature = "openssl", feature = "uri"))]
-// #[actix_rt::test]
-// async fn test_openssl_uri() {
-//     use std::convert::TryFrom;
-//
-//     let srv = TestServer::with(|| {
-//         fn_service(|io: TcpStream| async {
-//             let mut framed = Framed::new(io, BytesCodec);
-//             framed.send(Bytes::from_static(b"test")).await?;
-//             Ok::<_, io::Error>(())
-//         })
-//     });
-//
-//     let mut conn = actix_connect::default_connector();
-//     let addr = http::Uri::try_from(format!("https://localhost:{}", srv.port())).unwrap();
-//     let con = conn.call(addr.into()).await.unwrap();
-//     assert_eq!(con.peer_addr().unwrap(), srv.addr());
-// }
-//
-// #[cfg(all(feature = "rustls", feature = "uri"))]
-// #[actix_rt::test]
-// async fn test_rustls_uri() {
-//     use std::convert::TryFrom;
-//
-//     let srv = TestServer::with(|| {
-//         fn_service(|io: TcpStream| async {
-//             let mut framed = Framed::new(io, BytesCodec);
-//             framed.send(Bytes::from_static(b"test")).await?;
-//             Ok::<_, io::Error>(())
-//         })
-//     });
-//
-//     let mut conn = actix_connect::default_connector();
-//     let addr = http::Uri::try_from(format!("https://localhost:{}", srv.port())).unwrap();
-//     let con = conn.call(addr.into()).await.unwrap();
-//     assert_eq!(con.peer_addr().unwrap(), srv.addr());
-// }
+use std::io;
+
+use actix_codec::{BytesCodec, Framed};
+use actix_rt::net::TcpStream;
+use actix_service::{fn_service, Service, ServiceFactory};
+use actix_testing::TestServer;
+use bytes::Bytes;
+use futures_util::sink::SinkExt;
+
+use actix_connect::resolver::{ResolverConfig, ResolverOpts};
+use actix_connect::Connect;
+
+#[cfg(feature = "openssl")]
+#[actix_rt::test]
+async fn test_string() {
+    let srv = TestServer::with(|| {
+        fn_service(|io: TcpStream| async {
+            let mut framed = Framed::new(io, BytesCodec);
+            framed.send(Bytes::from_static(b"test")).await?;
+            Ok::<_, io::Error>(())
+        })
+    });
+
+    let mut conn = actix_connect::default_connector();
+    let addr = format!("localhost:{}", srv.port());
+    let con = conn.call(addr.into()).await.unwrap();
+    assert_eq!(con.peer_addr().unwrap(), srv.addr());
+}
+
+#[cfg(feature = "rustls")]
+#[actix_rt::test]
+async fn test_rustls_string() {
+    let srv = TestServer::with(|| {
+        fn_service(|io: TcpStream| async {
+            let mut framed = Framed::new(io, BytesCodec);
+            framed.send(Bytes::from_static(b"test")).await?;
+            Ok::<_, io::Error>(())
+        })
+    });
+
+    let mut conn = actix_connect::default_connector();
+    let addr = format!("localhost:{}", srv.port());
+    let con = conn.call(addr.into()).await.unwrap();
+    assert_eq!(con.peer_addr().unwrap(), srv.addr());
+}
+
+#[actix_rt::test]
+async fn test_static_str() {
+    let srv = TestServer::with(|| {
+        fn_service(|io: TcpStream| async {
+            let mut framed = Framed::new(io, BytesCodec);
+            framed.send(Bytes::from_static(b"test")).await?;
+            Ok::<_, io::Error>(())
+        })
+    });
+
+    let resolver = actix_connect::start_default_resolver().await.unwrap();
+    let mut conn = actix_connect::new_connector(resolver.clone());
+
+    let con = conn.call(Connect::with("10", srv.addr())).await.unwrap();
+    assert_eq!(con.peer_addr().unwrap(), srv.addr());
+
+    let connect = Connect::new(srv.host().to_owned());
+    let mut conn = actix_connect::new_connector(resolver);
+    let con = conn.call(connect).await;
+    assert!(con.is_err());
+}
+
+#[actix_rt::test]
+async fn test_new_service() {
+    let srv = TestServer::with(|| {
+        fn_service(|io: TcpStream| async {
+            let mut framed = Framed::new(io, BytesCodec);
+            framed.send(Bytes::from_static(b"test")).await?;
+            Ok::<_, io::Error>(())
+        })
+    });
+
+    let resolver =
+        actix_connect::start_resolver(ResolverConfig::default(), ResolverOpts::default())
+            .await
+            .unwrap();
+
+    let factory = actix_connect::new_connector_factory(resolver);
+
+    let mut conn = factory.new_service(()).await.unwrap();
+    let con = conn.call(Connect::with("10", srv.addr())).await.unwrap();
+    assert_eq!(con.peer_addr().unwrap(), srv.addr());
+}
+
+#[cfg(all(feature = "openssl", feature = "uri"))]
+#[actix_rt::test]
+async fn test_openssl_uri() {
+    use std::convert::TryFrom;
+
+    let srv = TestServer::with(|| {
+        fn_service(|io: TcpStream| async {
+            let mut framed = Framed::new(io, BytesCodec);
+            framed.send(Bytes::from_static(b"test")).await?;
+            Ok::<_, io::Error>(())
+        })
+    });
+
+    let mut conn = actix_connect::default_connector();
+    let addr = http::Uri::try_from(format!("https://localhost:{}", srv.port())).unwrap();
+    let con = conn.call(addr.into()).await.unwrap();
+    assert_eq!(con.peer_addr().unwrap(), srv.addr());
+}
+
+#[cfg(all(feature = "rustls", feature = "uri"))]
+#[actix_rt::test]
+async fn test_rustls_uri() {
+    use std::convert::TryFrom;
+
+    let srv = TestServer::with(|| {
+        fn_service(|io: TcpStream| async {
+            let mut framed = Framed::new(io, BytesCodec);
+            framed.send(Bytes::from_static(b"test")).await?;
+            Ok::<_, io::Error>(())
+        })
+    });
+
+    let mut conn = actix_connect::default_connector();
+    let addr = http::Uri::try_from(format!("https://localhost:{}", srv.port())).unwrap();
+    let con = conn.call(addr.into()).await.unwrap();
+    assert_eq!(con.peer_addr().unwrap(), srv.addr());
+}