actix/examples
1
0
Fork 0
mirror of https://github.com/actix/examples synced 2025-02-02 17:39:05 +01:00
Code Issues Releases Wiki Activity
examples/form/src/main.rs

230 lines
6.7 KiB
Rust
Raw Normal View History

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,
}
post cookie-auth and form examples
2019-03-09 21:08:08 -08:00
fn main() -> std::io::Result<()> {
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")?
.run()
}
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)))
.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
}
post cookie-auth and form examples
2019-03-09 21:08:08 -08:00
fn index() -> Result<HttpResponse> {
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
post cookie-auth and form examples
2019-03-09 21:08:08 -08:00
fn handle_post_1(params: web::Form<MyParams>) -> Result<HttpResponse> {
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
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
post cookie-auth and form examples
2019-03-09 21:08:08 -08:00
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::*;
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, block_on, 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!(),
},
}
}
}
#[test]
fn handle_post_1_unit_test() {
let params = Form(MyParams {
name: "John".to_string(),
});
let result = handle_post_1(params);
let resp = block_on(result).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"
);
}
#[test]
fn handle_post_1_integration_test() {
let mut app = test::init_service(App::new().configure(app_config));
let req = test::TestRequest::post()
.uri("/post1")
.set_form(&MyParams {name: "John".to_string()})
.to_request();
let resp: ServiceResponse = block_on(app.call(req)).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"
);
}
#[test]
fn handle_post_2_unit_test() {
let state = TestRequest::default()
.data(AppState {
foo: "bar".to_string(),
})
.to_http_request()
.get_app_data()
.unwrap();
let params = Form(MyParams {
name: "John".to_string(),
});
let result = handle_post_2(state, params);
let resp = block_on(result).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, and in AppState I have foo: bar"
);
}
#[test]
fn handle_post_2_integration_test() {
let mut app = test::init_service(App::new().configure(app_config));
let req = test::TestRequest::post()
.uri("/post2")
.set_form(&MyParams {name: "John".to_string()})
.to_request();
let resp: ServiceResponse = block_on(app.call(req)).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"
);
}
#[test]
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);
let resp = match block_on(result.respond_to(&req)) {
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"
);
}
#[test]
fn handle_post_3_integration_test() {
let mut app = test::init_service(App::new().configure(app_config));
let req = test::TestRequest::post()
.uri("/post3")
.set_form(&MyParams {name: "John".to_string()})
.to_request();
let resp: ServiceResponse = block_on(app.call(req)).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"
);
}
}
Reference in New Issue Copy Permalink