Testing is done-ish.

examples/testing/Cargo.toml

@@ -7,3 +7,5 @@ edition = "2018"
 actix-web = "1.0"
 futures = "0.1"
 bytes = "0.4"
+serde = "1.0"
+serde_json = "1.0"

examples/testing/src/integration_one.rs

@@ -1,22 +1,33 @@
+use actix_web::{HttpRequest, Responder};
+
+#[allow(dead_code)]
+fn index(_req: HttpRequest) -> impl Responder {
+    "Hello world!"
+}
+
 // <integration-one>
-// use actix_web::test::TestServer;
-// use actix_web::HttpRequest;
-// use std::str;
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use actix_web::dev::Service;
+    use actix_web::{test, web, App};
 
-// fn index(req: HttpRequest) -> &'static str {
-//     "Hello world!"
-// }
+    #[test]
+    fn test_index_get() {
+        let mut app = test::init_service(App::new().route("/", web::get().to(index)));
+        let req = test::TestRequest::get().uri("/").to_request();
+        let resp = test::block_on(app.call(req)).unwrap();
 
-// fn main() {
-//     // start new test server
-//     let mut srv = TestServer::new(|app| app.handler(index));
+        assert!(resp.status().is_success());
+    }
 
-//     let request = srv.get().finish().unwrap();
-//     let response = srv.execute(request.send()).unwrap();
-//     assert!(response.status().is_success());
+    #[test]
+    fn test_index_post() {
+        let mut app = test::init_service(App::new().route("/", web::get().to(index)));
+        let req = test::TestRequest::post().uri("/").to_request();
+        let resp = test::block_on(app.call(req)).unwrap();
 
-//     let bytes = srv.execute(response.body()).unwrap();
-//     let body = str::from_utf8(&bytes).unwrap();
-//     assert_eq!(body, "Hello world!");
-// }
+        assert!(resp.status().is_client_error());
+    }
+}
 // </integration-one>

examples/testing/src/integration_three.rs

@@ -1,21 +0,0 @@
-// <integration-three>
-// #[test]
-// fn test() {
-//     let srv = TestServer::build_with_state(|| {
-//         // we can start diesel actors
-//         let addr = SyncArbiter::start(3, || {
-//             DbExecutor(SqliteConnection::establish("test.db").unwrap())
-//         });
-//         // then we can construct custom state, or it could be `()`
-//         MyState{addr: addr}
-//    })
-
-//    // register server handlers and start test server
-//    .start(|app| {
-//         app.resource(
-//             "/{username}/index.html", |r| r.with(
-//                 |p: Path<PParam>| format!("Welcome {}!", p.username)));
-//     });
-//     // now we can run our test code
-// );
-// </integration-three>

examples/testing/src/integration_two.rs

@@ -1,21 +1,33 @@
+use actix_web::{web, HttpResponse, Responder};
+use serde::{Deserialize, Serialize};
+
+#[derive(Deserialize, Serialize, Debug)]
+struct AppState {
+    count: i32,
+}
+
+#[allow(dead_code)]
+fn index(data: web::Data<AppState>) -> impl Responder {
+    HttpResponse::Ok().json(data.get_ref())
+}
+
 // <integration-two>
-// use actix_web::{http, test, App, HttpRequest, HttpResponse};
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use actix_web::{test, web, App};
 
-// fn index(req: &HttpRequest) -> HttpResponse {
-//     HttpResponse::Ok().into()
-// }
+    #[test]
+    fn test_index_get() {
+        let mut app = test::init_service(
+            App::new()
+                .data(AppState { count: 4 })
+                .route("/", web::get().to(index)),
+        );
+        let req = test::TestRequest::get().uri("/").to_request();
+        let resp: AppState = test::read_response_json(&mut app, req);
 
-// /// This function get called by http server.
-// fn create_app() -> App {
-//     App::new().resource("/test", |r| r.h(index))
-// }
-
-// fn main() {
-//     let mut srv = test::TestServer::with_factory(create_app);
-
-//     let request = srv.client(http::Method::GET, "/test").finish().unwrap();
-//     let response = srv.execute(request.send()).unwrap();
-
-//     assert!(response.status().is_success());
-// }
+        assert!(resp.count == 4);
+    }
+}
 // </integration-two>

examples/testing/src/main.rs

@@ -1,10 +1,7 @@
-mod integration_one;
-mod integration_three;
-mod integration_two;
-mod stream_response;
-mod websockets;
-// <unit-tests>
-use actix_web::{http, test, HttpRequest, HttpResponse};
+pub mod integration_one;
+pub mod integration_two;
+pub mod stream_response;
+use actix_web::{http, web, App, HttpRequest, HttpResponse};
 
 fn index(req: HttpRequest) -> HttpResponse {
     if let Some(hdr) = req.headers().get(http::header::CONTENT_TYPE) {
@@ -16,14 +13,29 @@ fn index(req: HttpRequest) -> HttpResponse {
 }
 
 fn main() {
-    let req =
-        test::TestRequest::with_header("content-type", "text/plain").to_http_request();
+    App::new().route("/", web::get().to(index));
+}
 
-    let resp = test::block_on(index(req)).unwrap();
-    assert_eq!(resp.status(), http::StatusCode::OK);
+// <unit-tests>
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use actix_web::test;
 
-    let req = test::TestRequest::default().to_http_request();
-    let resp = test::block_on(index(req)).unwrap();
-    assert_eq!(resp.status(), http::StatusCode::BAD_REQUEST);
+    #[test]
+    fn test_index_ok() {
+        let req = test::TestRequest::with_header("content-type", "text/plain")
+            .to_http_request();
+
+        let resp = test::block_on(index(req)).unwrap();
+        assert_eq!(resp.status(), http::StatusCode::OK);
+    }
+
+    #[test]
+    fn test_index_not_ok() {
+        let req = test::TestRequest::default().to_http_request();
+        let resp = test::block_on(index(req)).unwrap();
+        assert_eq!(resp.status(), http::StatusCode::BAD_REQUEST);
+    }
 }
 // </unit-tests>

examples/testing/src/stream_response.rs

@@ -1,50 +1,49 @@
 // <stream-response>
-// use bytes::Bytes;
-// use futures::stream::poll_fn;
-// use futures::{Async, Poll, Stream};
+use bytes::Bytes;
+use futures::stream::poll_fn;
+use futures::{Async, Poll};
 
-// use actix_web::http::{ContentEncoding, StatusCode};
-// use actix_web::test::TestServer;
-// use actix_web::{Error, HttpRequest, HttpResponse};
+use actix_web::http::{ContentEncoding, StatusCode};
+use actix_web::{middleware::BodyEncoding, web, App, Error, HttpRequest, HttpResponse};
 
-// fn sse(_req: &HttpRequest) -> HttpResponse {
-//     let mut counter = 5usize;
-//     // yields `data: N` where N in [5; 1]
-//     let server_events = poll_fn(move || -> Poll<Option<Bytes>, Error> {
-//         if counter == 0 {
-//             return Ok(Async::Ready(None));
-//         }
-//         let payload = format!("data: {}\n\n", counter);
-//         counter -= 1;
-//         Ok(Async::Ready(Some(Bytes::from(payload))))
-//     });
+fn sse(_req: HttpRequest) -> HttpResponse {
+    let mut counter: usize = 5;
 
-//     HttpResponse::build(StatusCode::OK)
-//         .content_encoding(ContentEncoding::Identity)
-//         .content_type("text/event-stream")
-//         .streaming(server_events)
-// }
+    // yields `data: N` where N in [5; 1]
+    let server_events = poll_fn(move || -> Poll<Option<Bytes>, Error> {
+        if counter == 0 {
+            return Ok(Async::Ready(None));
+        }
+        let payload = format!("data: {}\n\n", counter);
+        counter -= 1;
+        Ok(Async::Ready(Some(Bytes::from(payload))))
+    });
 
-// fn main() {
-//     // start new test server
-//     let mut srv = TestServer::new(|app| app.handler(sse));
+    HttpResponse::build(StatusCode::OK)
+        .encoding(ContentEncoding::Identity)
+        .content_type("text/event-stream")
+        .streaming(server_events)
+}
 
-//     // request stream
-//     let request = srv.get().finish().unwrap();
-//     let response = srv.execute(request.send()).unwrap();
-//     assert!(response.status().is_success());
+pub fn main() {
+    App::new().route("/", web::get().to(sse));
+}
 
-//     // convert ClientResponse to future, start read body and wait first chunk
-//     let mut stream = response.payload();
-//     loop {
-//         match srv.execute(stream.into_future()) {
-//             Ok((Some(bytes), remain)) => {
-//                 println!("{:?}", bytes);
-//                 stream = remain
-//             }
-//             Ok((None, _)) => break,
-//             Err(_) => panic!(),
-//         }
-//     }
-// }
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use actix_web::{test, web, App};
+
+    #[test]
+    fn test_stream() {
+        let mut app = test::init_service(App::new().route("/", web::get().to(sse)));
+        let req = test::TestRequest::get().to_request();
+        let resp = test::read_response(&mut app, req);
+        assert!(
+            resp == Bytes::from_static(
+                b"data: 5\n\ndata: 4\n\ndata: 3\n\ndata: 2\n\ndata: 1\n\n"
+            )
+        );
+    }
+}
 // </stream-response>

examples/testing/src/websockets.rs

@@ -1,30 +0,0 @@
-// <web-socket>
-use actix::{Actor, StreamHandler};
-use actix_web::*;
-use futures::Stream;
-
-struct Ws; // <- WebSocket actor
-
-impl Actor for Ws {
-    type Context = ws::WebsocketContext<Self>;
-}
-
-impl StreamHandler<ws::Message, ws::ProtocolError> for Ws {
-    fn handle(&mut self, msg: ws::Message, ctx: &mut Self::Context) {
-        match msg {
-            ws::Message::Text(text) => ctx.text(text),
-            _ => (),
-        }
-    }
-}
-
-fn main() {
-    let mut srv = test::TestServer::new(|app| app.handler(|req| ws::start(req, Ws)));
-
-    let (reader, mut writer) = srv.ws().unwrap();
-    writer.text("text");
-
-    let (item, reader) = srv.execute(reader.into_future()).unwrap();
-    assert_eq!(item, Some(ws::Message::Text("text".to_owned())));
-}
-// </web-socket>