diff --git a/Cargo.toml b/Cargo.toml
index 3efc058df..1af2836fd 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -37,7 +37,7 @@ members = [
   #"actix-session",
   "actix-identity",
   #"actix-multipart",
-  #"actix-web-actors",
+  "actix-web-actors",
   "actix-web-codegen",
   "test-server",
 ]
diff --git a/actix-web-codegen/Cargo.toml b/actix-web-codegen/Cargo.toml
index 981e00323..f363cfbaa 100644
--- a/actix-web-codegen/Cargo.toml
+++ b/actix-web-codegen/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "actix-web-codegen"
-version = "0.1.3"
+version = "0.2.0-alpha.1"
 description = "Actix web proc macros"
 readme = "README.md"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
@@ -17,7 +17,7 @@ syn = { version = "1", features = ["full", "parsing"] }
 proc-macro2 = "1"
 
 [dev-dependencies]
-actix-web = { version = "1.0.0" }
-actix-http = { version = "0.2.4", features=["ssl"] }
-actix-http-test = { version = "0.2.0", features=["ssl"] }
-futures = { version = "0.1" }
+actix-web = { version = "2.0.0-alph.a" }
+actix-http = { version = "0.3.0-alpha.1", features=["openssl"] }
+actix-http-test = { version = "0.3.0-alpha.1", features=["openssl"] }
+futures = { version = "0.3.1" }
diff --git a/actix-web-codegen/src/lib.rs b/actix-web-codegen/src/lib.rs
index 88fa4dfda..0a727ed69 100644
--- a/actix-web-codegen/src/lib.rs
+++ b/actix-web-codegen/src/lib.rs
@@ -35,8 +35,8 @@
 //! use futures::{future, Future};
 //!
 //! #[get("/test")]
-//! fn async_test() -> impl Future<Item=HttpResponse, Error=actix_web::Error> {
-//!     future::ok(HttpResponse::Ok().finish())
+//! async fn async_test() -> Result<HttpResponse, actix_web::Error> {
+//!     Ok(HttpResponse::Ok().finish())
 //! }
 //! ```
 
diff --git a/actix-web-codegen/tests/test_macro.rs b/actix-web-codegen/tests/test_macro.rs
index 8ecc81dc1..953de9cd5 100644
--- a/actix-web-codegen/tests/test_macro.rs
+++ b/actix-web-codegen/tests/test_macro.rs
@@ -1,5 +1,5 @@
 use actix_http::HttpService;
-use actix_http_test::TestServer;
+use actix_http_test::{block_on, TestServer};
 use actix_web::{http, web::Path, App, HttpResponse, Responder};
 use actix_web_codegen::{connect, delete, get, head, options, patch, post, put, trace};
 use futures::{future, Future};
@@ -45,12 +45,12 @@ fn trace_test() -> impl Responder {
 }
 
 #[get("/test")]
-fn auto_async() -> impl Future<Item = HttpResponse, Error = actix_web::Error> {
+fn auto_async() -> impl Future<Output = Result<HttpResponse, actix_web::Error>> {
     future::ok(HttpResponse::Ok().finish())
 }
 
 #[get("/test")]
-fn auto_sync() -> impl Future<Item = HttpResponse, Error = actix_web::Error> {
+fn auto_sync() -> impl Future<Output = Result<HttpResponse, actix_web::Error>> {
     future::ok(HttpResponse::Ok().finish())
 }
 
@@ -71,87 +71,93 @@ fn get_param_test(_: Path<String>) -> impl Responder {
 
 #[test]
 fn test_params() {
-    let mut srv = TestServer::new(|| {
-        HttpService::new(
-            App::new()
-                .service(get_param_test)
-                .service(put_param_test)
-                .service(delete_param_test),
-        )
-    });
+    block_on(async {
+        let srv = TestServer::start(|| {
+            HttpService::new(
+                App::new()
+                    .service(get_param_test)
+                    .service(put_param_test)
+                    .service(delete_param_test),
+            )
+        });
 
-    let request = srv.request(http::Method::GET, srv.url("/test/it"));
-    let response = srv.block_on(request.send()).unwrap();
-    assert_eq!(response.status(), http::StatusCode::OK);
+        let request = srv.request(http::Method::GET, srv.url("/test/it"));
+        let response = request.send().await.unwrap();
+        assert_eq!(response.status(), http::StatusCode::OK);
 
-    let request = srv.request(http::Method::PUT, srv.url("/test/it"));
-    let response = srv.block_on(request.send()).unwrap();
-    assert_eq!(response.status(), http::StatusCode::CREATED);
+        let request = srv.request(http::Method::PUT, srv.url("/test/it"));
+        let response = request.send().await.unwrap();
+        assert_eq!(response.status(), http::StatusCode::CREATED);
 
-    let request = srv.request(http::Method::DELETE, srv.url("/test/it"));
-    let response = srv.block_on(request.send()).unwrap();
-    assert_eq!(response.status(), http::StatusCode::NO_CONTENT);
+        let request = srv.request(http::Method::DELETE, srv.url("/test/it"));
+        let response = request.send().await.unwrap();
+        assert_eq!(response.status(), http::StatusCode::NO_CONTENT);
+    })
 }
 
 #[test]
 fn test_body() {
-    let mut srv = TestServer::new(|| {
-        HttpService::new(
-            App::new()
-                .service(post_test)
-                .service(put_test)
-                .service(head_test)
-                .service(connect_test)
-                .service(options_test)
-                .service(trace_test)
-                .service(patch_test)
-                .service(test),
-        )
-    });
-    let request = srv.request(http::Method::GET, srv.url("/test"));
-    let response = srv.block_on(request.send()).unwrap();
-    assert!(response.status().is_success());
+    block_on(async {
+        let srv = TestServer::start(|| {
+            HttpService::new(
+                App::new()
+                    .service(post_test)
+                    .service(put_test)
+                    .service(head_test)
+                    .service(connect_test)
+                    .service(options_test)
+                    .service(trace_test)
+                    .service(patch_test)
+                    .service(test),
+            )
+        });
+        let request = srv.request(http::Method::GET, srv.url("/test"));
+        let response = request.send().await.unwrap();
+        assert!(response.status().is_success());
 
-    let request = srv.request(http::Method::HEAD, srv.url("/test"));
-    let response = srv.block_on(request.send()).unwrap();
-    assert!(response.status().is_success());
+        let request = srv.request(http::Method::HEAD, srv.url("/test"));
+        let response = request.send().await.unwrap();
+        assert!(response.status().is_success());
 
-    let request = srv.request(http::Method::CONNECT, srv.url("/test"));
-    let response = srv.block_on(request.send()).unwrap();
-    assert!(response.status().is_success());
+        let request = srv.request(http::Method::CONNECT, srv.url("/test"));
+        let response = request.send().await.unwrap();
+        assert!(response.status().is_success());
 
-    let request = srv.request(http::Method::OPTIONS, srv.url("/test"));
-    let response = srv.block_on(request.send()).unwrap();
-    assert!(response.status().is_success());
+        let request = srv.request(http::Method::OPTIONS, srv.url("/test"));
+        let response = request.send().await.unwrap();
+        assert!(response.status().is_success());
 
-    let request = srv.request(http::Method::TRACE, srv.url("/test"));
-    let response = srv.block_on(request.send()).unwrap();
-    assert!(response.status().is_success());
+        let request = srv.request(http::Method::TRACE, srv.url("/test"));
+        let response = request.send().await.unwrap();
+        assert!(response.status().is_success());
 
-    let request = srv.request(http::Method::PATCH, srv.url("/test"));
-    let response = srv.block_on(request.send()).unwrap();
-    assert!(response.status().is_success());
+        let request = srv.request(http::Method::PATCH, srv.url("/test"));
+        let response = request.send().await.unwrap();
+        assert!(response.status().is_success());
 
-    let request = srv.request(http::Method::PUT, srv.url("/test"));
-    let response = srv.block_on(request.send()).unwrap();
-    assert!(response.status().is_success());
-    assert_eq!(response.status(), http::StatusCode::CREATED);
+        let request = srv.request(http::Method::PUT, srv.url("/test"));
+        let response = request.send().await.unwrap();
+        assert!(response.status().is_success());
+        assert_eq!(response.status(), http::StatusCode::CREATED);
 
-    let request = srv.request(http::Method::POST, srv.url("/test"));
-    let response = srv.block_on(request.send()).unwrap();
-    assert!(response.status().is_success());
-    assert_eq!(response.status(), http::StatusCode::NO_CONTENT);
+        let request = srv.request(http::Method::POST, srv.url("/test"));
+        let response = request.send().await.unwrap();
+        assert!(response.status().is_success());
+        assert_eq!(response.status(), http::StatusCode::NO_CONTENT);
 
-    let request = srv.request(http::Method::GET, srv.url("/test"));
-    let response = srv.block_on(request.send()).unwrap();
-    assert!(response.status().is_success());
+        let request = srv.request(http::Method::GET, srv.url("/test"));
+        let response = request.send().await.unwrap();
+        assert!(response.status().is_success());
+    })
 }
 
 #[test]
 fn test_auto_async() {
-    let mut srv = TestServer::new(|| HttpService::new(App::new().service(auto_async)));
+    block_on(async {
+        let srv = TestServer::start(|| HttpService::new(App::new().service(auto_async)));
 
-    let request = srv.request(http::Method::GET, srv.url("/test"));
-    let response = srv.block_on(request.send()).unwrap();
-    assert!(response.status().is_success());
+        let request = srv.request(http::Method::GET, srv.url("/test"));
+        let response = request.send().await.unwrap();
+        assert!(response.status().is_success());
+    })
 }