examples/form/src/main.rs

#[macro_use]
extern crate serde_derive;

use actix_web::{
    middleware, web, App, HttpRequest, HttpResponse, HttpServer, Responder, Result,
};

struct AppState {
    foo: String,
}

#[actix_rt::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new()
            .wrap(middleware::Logger::default())
            .configure(app_config)
    })
    .bind("127.0.0.1:8080")?
    .start()
    .await
}

fn app_config(config: &mut web::ServiceConfig) {
    config.service(
        web::scope("")
            .data(AppState {
                foo: "bar".to_string(),
            })
            .service(web::resource("/").route(web::get().to(index)))
            .service(web::resource("/post1").route(web::post().to(handle_post_1)))
            .service(web::resource("/post2").route(web::post().to(handle_post_2)))
            .service(web::resource("/post3").route(web::post().to(handle_post_3))),
    );
}

async fn index() -> Result<HttpResponse> {
    Ok(HttpResponse::Ok()
        .content_type("text/html; charset=utf-8")
        .body(include_str!("../static/form.html")))
}

#[derive(Serialize, Deserialize)]
pub struct MyParams {
    name: String,
}

/// Simple handle POST request
async fn handle_post_1(params: web::Form<MyParams>) -> Result<HttpResponse> {
    Ok(HttpResponse::Ok()
        .content_type("text/plain")
        .body(format!("Your name is {}", params.name)))
}

/// State and POST Params
async fn handle_post_2(
    state: web::Data<AppState>,
    params: web::Form<MyParams>,
) -> HttpResponse {
    HttpResponse::Ok().content_type("text/plain").body(format!(
        "Your name is {}, and in AppState I have foo: {}",
        params.name, state.foo
    ))
}

/// Request and POST Params
async fn handle_post_3(req: HttpRequest, params: web::Form<MyParams>) -> impl Responder {
    println!("Handling POST request: {:?}", req);

    HttpResponse::Ok()
        .content_type("text/plain")
        .body(format!("Your name is {}", params.name))
}

#[cfg(test)]
mod tests {
    use super::*;

    use actix_web::body::{Body, ResponseBody};
    use actix_web::dev::{HttpResponseBuilder, Service, ServiceResponse};
    use actix_web::http::{header::CONTENT_TYPE, HeaderValue, StatusCode};
    use actix_web::test::{self, TestRequest};
    use actix_web::web::Form;

    trait BodyTest {
        fn as_str(&self) -> &str;
    }

    impl BodyTest for ResponseBody<Body> {
        fn as_str(&self) -> &str {
            match self {
                ResponseBody::Body(ref b) => match b {
                    Body::Bytes(ref by) => std::str::from_utf8(&by).unwrap(),
                    _ => panic!(),
                },
                ResponseBody::Other(ref b) => match b {
                    Body::Bytes(ref by) => std::str::from_utf8(&by).unwrap(),
                    _ => panic!(),
                },
            }
        }
    }

    #[actix_rt::test]
    async fn handle_post_1_unit_test() {
        let params = Form(MyParams {
            name: "John".to_string(),
        });
        let resp = handle_post_1(params).await.unwrap();

        assert_eq!(resp.status(), StatusCode::OK);
        assert_eq!(
            resp.headers().get(CONTENT_TYPE).unwrap(),
            HeaderValue::from_static("text/plain")
        );
        assert_eq!(resp.body().as_str(), "Your name is John");
    }

    #[actix_rt::test]
    async fn handle_post_1_integration_test() {
        let mut app = test::init_service(App::new().configure(app_config)).await;
        let req = test::TestRequest::post()
            .uri("/post1")
            .set_form(&MyParams {
                name: "John".to_string(),
            })
            .to_request();
        let resp: ServiceResponse = app.call(req).await.unwrap();

        assert_eq!(resp.status(), StatusCode::OK);
        assert_eq!(
            resp.headers().get(CONTENT_TYPE).unwrap(),
            HeaderValue::from_static("text/plain")
        );
        assert_eq!(resp.response().body().as_str(), "Your name is John");
    }

    #[actix_rt::test]
    async fn handle_post_2_unit_test() {
        let state = TestRequest::default()
            .data(AppState {
                foo: "bar".to_string(),
            })
            .to_http_request();
        let data = state
            .app_data::<actix_web::web::Data<AppState>>()
            .unwrap();
        let params = Form(MyParams {
            name: "John".to_string(),
        });
        let resp = handle_post_2(data.clone(), params).await;

        assert_eq!(resp.status(), StatusCode::OK);
        assert_eq!(
            resp.headers().get(CONTENT_TYPE).unwrap(),
            HeaderValue::from_static("text/plain")
        );
        assert_eq!(
            resp.body().as_str(),
            "Your name is John, and in AppState I have foo: bar"
        );
    }

    #[actix_rt::test]
    async fn handle_post_2_integration_test() {
        let mut app = test::init_service(App::new().configure(app_config)).await;
        let req = test::TestRequest::post()
            .uri("/post2")
            .set_form(&MyParams {
                name: "John".to_string(),
            })
            .to_request();
        let resp: ServiceResponse = app.call(req).await.unwrap();

        assert_eq!(resp.status(), StatusCode::OK);
        assert_eq!(
            resp.headers().get(CONTENT_TYPE).unwrap(),
            HeaderValue::from_static("text/plain")
        );
        assert_eq!(
            resp.response().body().as_str(),
            "Your name is John, and in AppState I have foo: bar"
        );
    }

    #[actix_rt::test]
    async fn handle_post_3_unit_test() {
        let req = TestRequest::default().to_http_request();
        let params = Form(MyParams {
            name: "John".to_string(),
        });
        let result = handle_post_3(req.clone(), params).await;
        let resp = match result.respond_to(&req).await {
            Ok(t) => t,
            Err(_) => {
                HttpResponseBuilder::new(StatusCode::INTERNAL_SERVER_ERROR).finish()
            }
        };

        assert_eq!(resp.status(), StatusCode::OK);
        assert_eq!(
            resp.headers().get(CONTENT_TYPE).unwrap(),
            HeaderValue::from_static("text/plain")
        );
        assert_eq!(resp.body().as_str(), "Your name is John");
    }

    #[actix_rt::test]
    async fn handle_post_3_integration_test() {
        let mut app = test::init_service(App::new().configure(app_config)).await;
        let req = test::TestRequest::post()
            .uri("/post3")
            .set_form(&MyParams {
                name: "John".to_string(),
            })
            .to_request();
        let resp: ServiceResponse = app.call(req).await.unwrap();

        assert_eq!(resp.status(), StatusCode::OK);
        assert_eq!(
            resp.headers().get(CONTENT_TYPE).unwrap(),
            HeaderValue::from_static("text/plain")
        );
        assert_eq!(resp.response().body().as_str(), "Your name is John");
    }
}
create form example 2018-07-04 17:12:33 +02:00			`#[macro_use]`
			`extern crate serde_derive;`

			`use actix_web::{`
post cookie-auth and form examples 2019-03-09 21:08:08 -08:00			`middleware, web, App, HttpRequest, HttpResponse, HttpServer, Responder, Result,`
create form example 2018-07-04 17:12:33 +02:00			`};`

			`struct AppState {`
			`foo: String,`
			`}`

upgrade to 2.0 alpha.3 2019-12-07 23:59:24 +06:00			`#[actix_rt::main]`
			`async fn main() -> std::io::Result<()> {`
post cookie-auth and form examples 2019-03-09 21:08:08 -08:00			`HttpServer::new(\|\| {`
			`App::new()`
Provide tests for the form example. 2019-09-29 15:39:17 +03:00			`.wrap(middleware::Logger::default())`
			`.configure(app_config)`
			`})`
			`.bind("127.0.0.1:8080")?`
upgrade to 2.0 alpha.3 2019-12-07 23:59:24 +06:00			`.start()`
			`.await`
Provide tests for the form example. 2019-09-29 15:39:17 +03:00			`}`

			`fn app_config(config: &mut web::ServiceConfig) {`
			`config.service(`
			`web::scope("")`
Update to master (#90) 2019-03-26 04:29:00 +01:00			`.data(AppState {`
post cookie-auth and form examples 2019-03-09 21:08:08 -08:00			`foo: "bar".to_string(),`
			`})`
			`.service(web::resource("/").route(web::get().to(index)))`
			`.service(web::resource("/post1").route(web::post().to(handle_post_1)))`
			`.service(web::resource("/post2").route(web::post().to(handle_post_2)))`
upgrade to 2.0 alpha.3 2019-12-07 23:59:24 +06:00			`.service(web::resource("/post3").route(web::post().to(handle_post_3))),`
Provide tests for the form example. 2019-09-29 15:39:17 +03:00			`);`
create form example 2018-07-04 17:12:33 +02:00			`}`

upgrade to 2.0 alpha.3 2019-12-07 23:59:24 +06:00			`async fn index() -> Result<HttpResponse> {`
post cookie-auth and form examples 2019-03-09 21:08:08 -08:00			`Ok(HttpResponse::Ok()`
create form example 2018-07-04 17:12:33 +02:00			`.content_type("text/html; charset=utf-8")`
			`.body(include_str!("../static/form.html")))`
			`}`

Provide tests for the form example. 2019-09-29 15:39:17 +03:00			`#[derive(Serialize, Deserialize)]`
create form example 2018-07-04 17:12:33 +02:00			`pub struct MyParams {`
			`name: String,`
			`}`

			`/// Simple handle POST request`
upgrade to 2.0 alpha.3 2019-12-07 23:59:24 +06:00			`async fn handle_post_1(params: web::Form<MyParams>) -> Result<HttpResponse> {`
post cookie-auth and form examples 2019-03-09 21:08:08 -08:00			`Ok(HttpResponse::Ok()`
create form example 2018-07-04 17:12:33 +02:00			`.content_type("text/plain")`
			`.body(format!("Your name is {}", params.name)))`
			`}`

			`/// State and POST Params`
upgrade to 2.0 alpha.3 2019-12-07 23:59:24 +06:00			`async fn handle_post_2(`
rename web::State to web::Data 2019-03-16 20:23:09 -07:00			`state: web::Data<AppState>,`
post cookie-auth and form examples 2019-03-09 21:08:08 -08:00			`params: web::Form<MyParams>,`
			`) -> HttpResponse {`
			`HttpResponse::Ok().content_type("text/plain").body(format!(`
			`"Your name is {}, and in AppState I have foo: {}",`
			`params.name, state.foo`
			`))`
create form example 2018-07-04 17:12:33 +02:00			`}`

			`/// Request and POST Params`
upgrade to 2.0 alpha.3 2019-12-07 23:59:24 +06:00			`async fn handle_post_3(req: HttpRequest, params: web::Form<MyParams>) -> impl Responder {`
create form example 2018-07-04 17:12:33 +02:00			`println!("Handling POST request: {:?}", req);`
post cookie-auth and form examples 2019-03-09 21:08:08 -08:00
			`HttpResponse::Ok()`
create form example 2018-07-04 17:12:33 +02:00			`.content_type("text/plain")`
post cookie-auth and form examples 2019-03-09 21:08:08 -08:00			`.body(format!("Your name is {}", params.name))`
create form example 2018-07-04 17:12:33 +02:00			`}`
Provide tests for the form example. 2019-09-29 15:39:17 +03:00
			`#[cfg(test)]`
			`mod tests {`
			`use super::*;`

upgrade to 2.0 alpha.3 2019-12-07 23:59:24 +06:00			`use actix_web::body::{Body, ResponseBody};`
Provide tests for the form example. 2019-09-29 15:39:17 +03:00			`use actix_web::dev::{HttpResponseBuilder, Service, ServiceResponse};`
			`use actix_web::http::{header::CONTENT_TYPE, HeaderValue, StatusCode};`
upgrade to 2.0 alpha.3 2019-12-07 23:59:24 +06:00			`use actix_web::test::{self, TestRequest};`
Provide tests for the form example. 2019-09-29 15:39:17 +03:00			`use actix_web::web::Form;`

			`trait BodyTest {`
			`fn as_str(&self) -> &str;`
			`}`

			`impl BodyTest for ResponseBody<Body> {`
			`fn as_str(&self) -> &str {`
			`match self {`
			`ResponseBody::Body(ref b) => match b {`
			`Body::Bytes(ref by) => std::str::from_utf8(&by).unwrap(),`
			`_ => panic!(),`
			`},`
			`ResponseBody::Other(ref b) => match b {`
			`Body::Bytes(ref by) => std::str::from_utf8(&by).unwrap(),`
			`_ => panic!(),`
			`},`
			`}`
			`}`
			`}`

upgrade to 2.0 alpha.3 2019-12-07 23:59:24 +06:00			`#[actix_rt::test]`
			`async fn handle_post_1_unit_test() {`
Provide tests for the form example. 2019-09-29 15:39:17 +03:00			`let params = Form(MyParams {`
			`name: "John".to_string(),`
			`});`
upgrade to 2.0 alpha.3 2019-12-07 23:59:24 +06:00			`let resp = handle_post_1(params).await.unwrap();`
Provide tests for the form example. 2019-09-29 15:39:17 +03:00
			`assert_eq!(resp.status(), StatusCode::OK);`
			`assert_eq!(`
			`resp.headers().get(CONTENT_TYPE).unwrap(),`
			`HeaderValue::from_static("text/plain")`
			`);`
upgrade to 2.0 alpha.3 2019-12-07 23:59:24 +06:00			`assert_eq!(resp.body().as_str(), "Your name is John");`
Provide tests for the form example. 2019-09-29 15:39:17 +03:00			`}`

upgrade to 2.0 alpha.3 2019-12-07 23:59:24 +06:00			`#[actix_rt::test]`
			`async fn handle_post_1_integration_test() {`
			`let mut app = test::init_service(App::new().configure(app_config)).await;`
Provide tests for the form example. 2019-09-29 15:39:17 +03:00			`let req = test::TestRequest::post()`
			`.uri("/post1")`
upgrade to 2.0 alpha.3 2019-12-07 23:59:24 +06:00			`.set_form(&MyParams {`
			`name: "John".to_string(),`
			`})`
Provide tests for the form example. 2019-09-29 15:39:17 +03:00			`.to_request();`
upgrade to 2.0 alpha.3 2019-12-07 23:59:24 +06:00			`let resp: ServiceResponse = app.call(req).await.unwrap();`
Provide tests for the form example. 2019-09-29 15:39:17 +03:00
			`assert_eq!(resp.status(), StatusCode::OK);`
			`assert_eq!(`
			`resp.headers().get(CONTENT_TYPE).unwrap(),`
			`HeaderValue::from_static("text/plain")`
			`);`
upgrade to 2.0 alpha.3 2019-12-07 23:59:24 +06:00			`assert_eq!(resp.response().body().as_str(), "Your name is John");`
Provide tests for the form example. 2019-09-29 15:39:17 +03:00			`}`

upgrade to 2.0 alpha.3 2019-12-07 23:59:24 +06:00			`#[actix_rt::test]`
			`async fn handle_post_2_unit_test() {`
Provide tests for the form example. 2019-09-29 15:39:17 +03:00			`let state = TestRequest::default()`
			`.data(AppState {`
			`foo: "bar".to_string(),`
			`})`
Fix form example's test (#216) * Update method name * Fix typo 2019-12-23 03:51:33 +09:00			`.to_http_request();`
			`let data = state`
			`.app_data::<actix_web::web::Data<AppState>>()`
Provide tests for the form example. 2019-09-29 15:39:17 +03:00			`.unwrap();`
			`let params = Form(MyParams {`
			`name: "John".to_string(),`
			`});`
Fix form example's test (#216) * Update method name * Fix typo 2019-12-23 03:51:33 +09:00			`let resp = handle_post_2(data.clone(), params).await;`
Provide tests for the form example. 2019-09-29 15:39:17 +03:00
			`assert_eq!(resp.status(), StatusCode::OK);`
			`assert_eq!(`
			`resp.headers().get(CONTENT_TYPE).unwrap(),`
			`HeaderValue::from_static("text/plain")`
			`);`
			`assert_eq!(`
			`resp.body().as_str(),`
			`"Your name is John, and in AppState I have foo: bar"`
			`);`
			`}`

upgrade to 2.0 alpha.3 2019-12-07 23:59:24 +06:00			`#[actix_rt::test]`
			`async fn handle_post_2_integration_test() {`
			`let mut app = test::init_service(App::new().configure(app_config)).await;`
Provide tests for the form example. 2019-09-29 15:39:17 +03:00			`let req = test::TestRequest::post()`
			`.uri("/post2")`
upgrade to 2.0 alpha.3 2019-12-07 23:59:24 +06:00			`.set_form(&MyParams {`
			`name: "John".to_string(),`
			`})`
Provide tests for the form example. 2019-09-29 15:39:17 +03:00			`.to_request();`
upgrade to 2.0 alpha.3 2019-12-07 23:59:24 +06:00			`let resp: ServiceResponse = app.call(req).await.unwrap();`
Provide tests for the form example. 2019-09-29 15:39:17 +03:00
			`assert_eq!(resp.status(), StatusCode::OK);`
			`assert_eq!(`
			`resp.headers().get(CONTENT_TYPE).unwrap(),`
			`HeaderValue::from_static("text/plain")`
			`);`
			`assert_eq!(`
			`resp.response().body().as_str(),`
			`"Your name is John, and in AppState I have foo: bar"`
			`);`
			`}`

upgrade to 2.0 alpha.3 2019-12-07 23:59:24 +06:00			`#[actix_rt::test]`
			`async fn handle_post_3_unit_test() {`
Provide tests for the form example. 2019-09-29 15:39:17 +03:00			`let req = TestRequest::default().to_http_request();`
			`let params = Form(MyParams {`
			`name: "John".to_string(),`
			`});`
upgrade to 2.0 alpha.3 2019-12-07 23:59:24 +06:00			`let result = handle_post_3(req.clone(), params).await;`
			`let resp = match result.respond_to(&req).await {`
Provide tests for the form example. 2019-09-29 15:39:17 +03:00			`Ok(t) => t,`
upgrade to 2.0 alpha.3 2019-12-07 23:59:24 +06:00			`Err(_) => {`
			`HttpResponseBuilder::new(StatusCode::INTERNAL_SERVER_ERROR).finish()`
			`}`
Provide tests for the form example. 2019-09-29 15:39:17 +03:00			`};`

			`assert_eq!(resp.status(), StatusCode::OK);`
			`assert_eq!(`
			`resp.headers().get(CONTENT_TYPE).unwrap(),`
			`HeaderValue::from_static("text/plain")`
			`);`
upgrade to 2.0 alpha.3 2019-12-07 23:59:24 +06:00			`assert_eq!(resp.body().as_str(), "Your name is John");`
Provide tests for the form example. 2019-09-29 15:39:17 +03:00			`}`

upgrade to 2.0 alpha.3 2019-12-07 23:59:24 +06:00			`#[actix_rt::test]`
			`async fn handle_post_3_integration_test() {`
			`let mut app = test::init_service(App::new().configure(app_config)).await;`
Provide tests for the form example. 2019-09-29 15:39:17 +03:00			`let req = test::TestRequest::post()`
			`.uri("/post3")`
upgrade to 2.0 alpha.3 2019-12-07 23:59:24 +06:00			`.set_form(&MyParams {`
			`name: "John".to_string(),`
			`})`
Provide tests for the form example. 2019-09-29 15:39:17 +03:00			`.to_request();`
upgrade to 2.0 alpha.3 2019-12-07 23:59:24 +06:00			`let resp: ServiceResponse = app.call(req).await.unwrap();`
Provide tests for the form example. 2019-09-29 15:39:17 +03:00
			`assert_eq!(resp.status(), StatusCode::OK);`
			`assert_eq!(`
			`resp.headers().get(CONTENT_TYPE).unwrap(),`
			`HeaderValue::from_static("text/plain")`
			`);`
upgrade to 2.0 alpha.3 2019-12-07 23:59:24 +06:00			`assert_eq!(resp.response().body().as_str(), "Your name is John");`
Provide tests for the form example. 2019-09-29 15:39:17 +03:00			`}`
			`}`