1
0
Fork 0
mirror of https://github.com/actix/actix-web.git synced 2024-12-30 12:00:38 +00:00
actix-web/tests/test_handlers.rs

557 lines
17 KiB
Rust
Raw Normal View History

2018-03-28 21:24:32 +00:00
extern crate actix;
extern crate actix_web;
2018-04-13 23:02:01 +00:00
extern crate bytes;
2018-03-28 21:24:32 +00:00
extern crate futures;
extern crate h2;
extern crate http;
2018-04-13 23:02:01 +00:00
extern crate tokio_core;
#[macro_use]
extern crate serde_derive;
2018-05-06 22:11:36 +00:00
extern crate serde_json;
2018-03-28 21:24:32 +00:00
use std::io;
2018-05-06 22:11:36 +00:00
use std::time::Duration;
use actix::*;
2018-03-28 21:24:32 +00:00
use actix_web::*;
use bytes::Bytes;
2018-05-06 22:11:36 +00:00
use futures::Future;
2018-03-28 21:24:32 +00:00
use http::StatusCode;
2018-05-06 22:11:36 +00:00
use serde_json::Value;
use tokio_core::reactor::Timeout;
2018-03-28 21:24:32 +00:00
#[derive(Deserialize)]
struct PParam {
username: String,
}
#[test]
fn test_path_extractor() {
let mut srv = test::TestServer::new(|app| {
2018-04-13 23:02:01 +00:00
app.resource("/{username}/index.html", |r| {
r.with(|p: Path<PParam>| format!("Welcome {}!", p.username))
});
});
2018-03-28 21:24:32 +00:00
// client request
2018-05-17 19:20:20 +00:00
let request = srv.get().uri(srv.url("/test/index.html")).finish().unwrap();
2018-03-28 21:24:32 +00:00
let response = srv.execute(request.send()).unwrap();
assert!(response.status().is_success());
// read response
let bytes = srv.execute(response.body()).unwrap();
assert_eq!(bytes, Bytes::from_static(b"Welcome test!"));
}
#[test]
fn test_query_extractor() {
let mut srv = test::TestServer::new(|app| {
2018-04-13 23:02:01 +00:00
app.resource("/index.html", |r| {
r.with(|p: Query<PParam>| format!("Welcome {}!", p.username))
});
});
2018-03-28 21:24:32 +00:00
// client request
2018-05-17 19:20:20 +00:00
let request = srv
.get()
2018-04-29 16:09:08 +00:00
.uri(srv.url("/index.html?username=test"))
.finish()
.unwrap();
2018-03-28 21:24:32 +00:00
let response = srv.execute(request.send()).unwrap();
assert!(response.status().is_success());
// read response
let bytes = srv.execute(response.body()).unwrap();
assert_eq!(bytes, Bytes::from_static(b"Welcome test!"));
// client request
2018-05-17 19:20:20 +00:00
let request = srv.get().uri(srv.url("/index.html")).finish().unwrap();
2018-03-28 21:24:32 +00:00
let response = srv.execute(request.send()).unwrap();
assert_eq!(response.status(), StatusCode::BAD_REQUEST);
}
2018-05-07 03:05:31 +00:00
#[test]
fn test_async_extractor_async() {
let mut srv = test::TestServer::new(|app| {
app.resource("/{username}/index.html", |r| {
r.route().with(|data: Json<Value>| {
Timeout::new(Duration::from_millis(10), &Arbiter::handle())
.unwrap()
.and_then(move |_| Ok(format!("{}", data.0)))
.responder()
})
});
});
// client request
2018-05-17 19:20:20 +00:00
let request = srv
.post()
2018-05-07 03:05:31 +00:00
.uri(srv.url("/test1/index.html"))
.header("content-type", "application/json")
.body("{\"test\": 1}")
.unwrap();
let response = srv.execute(request.send()).unwrap();
assert!(response.status().is_success());
// read response
let bytes = srv.execute(response.body()).unwrap();
assert_eq!(bytes, Bytes::from_static(b"{\"test\":1}"));
}
#[test]
fn test_path_and_query_extractor() {
let mut srv = test::TestServer::new(|app| {
2018-04-13 23:02:01 +00:00
app.resource("/{username}/index.html", |r| {
r.route().with2(|p: Path<PParam>, q: Query<PParam>| {
format!("Welcome {} - {}!", p.username, q.username)
})
});
});
// client request
2018-05-17 19:20:20 +00:00
let request = srv
.get()
2018-04-29 16:09:08 +00:00
.uri(srv.url("/test1/index.html?username=test2"))
.finish()
.unwrap();
let response = srv.execute(request.send()).unwrap();
assert!(response.status().is_success());
// read response
let bytes = srv.execute(response.body()).unwrap();
assert_eq!(bytes, Bytes::from_static(b"Welcome test1 - test2!"));
// client request
2018-05-17 19:20:20 +00:00
let request = srv
.get()
2018-04-29 16:09:08 +00:00
.uri(srv.url("/test1/index.html"))
.finish()
.unwrap();
let response = srv.execute(request.send()).unwrap();
assert_eq!(response.status(), StatusCode::BAD_REQUEST);
}
#[test]
fn test_path_and_query_extractor2() {
let mut srv = test::TestServer::new(|app| {
2018-04-13 23:02:01 +00:00
app.resource("/{username}/index.html", |r| {
2018-04-29 16:09:08 +00:00
r.route()
.with3(|_: HttpRequest, p: Path<PParam>, q: Query<PParam>| {
format!("Welcome {} - {}!", p.username, q.username)
})
2018-04-13 23:02:01 +00:00
});
});
// client request
2018-05-17 19:20:20 +00:00
let request = srv
.get()
2018-04-29 16:09:08 +00:00
.uri(srv.url("/test1/index.html?username=test2"))
.finish()
.unwrap();
let response = srv.execute(request.send()).unwrap();
assert!(response.status().is_success());
// read response
let bytes = srv.execute(response.body()).unwrap();
assert_eq!(bytes, Bytes::from_static(b"Welcome test1 - test2!"));
// client request
2018-05-17 19:20:20 +00:00
let request = srv
.get()
2018-04-29 16:09:08 +00:00
.uri(srv.url("/test1/index.html"))
.finish()
.unwrap();
let response = srv.execute(request.send()).unwrap();
assert_eq!(response.status(), StatusCode::BAD_REQUEST);
}
2018-05-06 22:11:36 +00:00
#[test]
fn test_path_and_query_extractor2_async() {
let mut srv = test::TestServer::new(|app| {
app.resource("/{username}/index.html", |r| {
2018-05-17 19:20:20 +00:00
r.route()
.with3(|p: Path<PParam>, _: Query<PParam>, data: Json<Value>| {
2018-05-06 22:11:36 +00:00
Timeout::new(Duration::from_millis(10), &Arbiter::handle())
.unwrap()
.and_then(move |_| {
Ok(format!("Welcome {} - {}!", p.username, data.0))
})
.responder()
2018-05-17 19:20:20 +00:00
})
2018-05-06 22:11:36 +00:00
});
});
// client request
2018-05-17 19:20:20 +00:00
let request = srv
.post()
2018-05-06 22:11:36 +00:00
.uri(srv.url("/test1/index.html?username=test2"))
.header("content-type", "application/json")
.body("{\"test\": 1}")
.unwrap();
let response = srv.execute(request.send()).unwrap();
assert!(response.status().is_success());
// read response
let bytes = srv.execute(response.body()).unwrap();
2018-05-17 19:20:20 +00:00
assert_eq!(bytes, Bytes::from_static(b"Welcome test1 - {\"test\":1}!"));
2018-05-06 22:11:36 +00:00
}
#[test]
fn test_path_and_query_extractor3_async() {
let mut srv = test::TestServer::new(|app| {
app.resource("/{username}/index.html", |r| {
r.route().with2(|p: Path<PParam>, data: Json<Value>| {
Timeout::new(Duration::from_millis(10), &Arbiter::handle())
.unwrap()
.and_then(move |_| {
Ok(format!("Welcome {} - {}!", p.username, data.0))
})
.responder()
})
});
});
// client request
2018-05-17 19:20:20 +00:00
let request = srv
.post()
2018-05-06 22:11:36 +00:00
.uri(srv.url("/test1/index.html"))
.header("content-type", "application/json")
.body("{\"test\": 1}")
.unwrap();
let response = srv.execute(request.send()).unwrap();
assert!(response.status().is_success());
}
#[test]
fn test_path_and_query_extractor4_async() {
let mut srv = test::TestServer::new(|app| {
app.resource("/{username}/index.html", |r| {
r.route().with2(|data: Json<Value>, p: Path<PParam>| {
Timeout::new(Duration::from_millis(10), &Arbiter::handle())
.unwrap()
.and_then(move |_| {
Ok(format!("Welcome {} - {}!", p.username, data.0))
})
.responder()
})
});
});
// client request
2018-05-17 19:20:20 +00:00
let request = srv
.post()
2018-05-06 22:11:36 +00:00
.uri(srv.url("/test1/index.html"))
.header("content-type", "application/json")
.body("{\"test\": 1}")
.unwrap();
let response = srv.execute(request.send()).unwrap();
assert!(response.status().is_success());
}
#[test]
fn test_path_and_query_extractor2_async2() {
let mut srv = test::TestServer::new(|app| {
app.resource("/{username}/index.html", |r| {
2018-05-17 19:20:20 +00:00
r.route()
.with3(|p: Path<PParam>, data: Json<Value>, _: Query<PParam>| {
2018-05-06 22:11:36 +00:00
Timeout::new(Duration::from_millis(10), &Arbiter::handle())
.unwrap()
.and_then(move |_| {
Ok(format!("Welcome {} - {}!", p.username, data.0))
})
.responder()
2018-05-17 19:20:20 +00:00
})
2018-05-06 22:11:36 +00:00
});
});
// client request
2018-05-17 19:20:20 +00:00
let request = srv
.post()
2018-05-06 22:11:36 +00:00
.uri(srv.url("/test1/index.html?username=test2"))
.header("content-type", "application/json")
.body("{\"test\": 1}")
.unwrap();
let response = srv.execute(request.send()).unwrap();
assert!(response.status().is_success());
// read response
let bytes = srv.execute(response.body()).unwrap();
2018-05-17 19:20:20 +00:00
assert_eq!(bytes, Bytes::from_static(b"Welcome test1 - {\"test\":1}!"));
2018-05-06 22:11:36 +00:00
// client request
2018-05-17 19:20:20 +00:00
let request = srv
.get()
2018-05-06 22:11:36 +00:00
.uri(srv.url("/test1/index.html"))
.finish()
.unwrap();
let response = srv.execute(request.send()).unwrap();
assert_eq!(response.status(), StatusCode::BAD_REQUEST);
}
2018-05-07 03:05:31 +00:00
#[test]
fn test_path_and_query_extractor2_async3() {
let mut srv = test::TestServer::new(|app| {
app.resource("/{username}/index.html", |r| {
2018-05-17 19:20:20 +00:00
r.route()
.with3(|data: Json<Value>, p: Path<PParam>, _: Query<PParam>| {
2018-05-07 03:05:31 +00:00
Timeout::new(Duration::from_millis(10), &Arbiter::handle())
.unwrap()
.and_then(move |_| {
Ok(format!("Welcome {} - {}!", p.username, data.0))
})
.responder()
2018-05-17 19:20:20 +00:00
})
2018-05-07 03:05:31 +00:00
});
});
// client request
2018-05-17 19:20:20 +00:00
let request = srv
.post()
2018-05-07 03:05:31 +00:00
.uri(srv.url("/test1/index.html?username=test2"))
.header("content-type", "application/json")
.body("{\"test\": 1}")
.unwrap();
let response = srv.execute(request.send()).unwrap();
assert!(response.status().is_success());
// read response
let bytes = srv.execute(response.body()).unwrap();
2018-05-17 19:20:20 +00:00
assert_eq!(bytes, Bytes::from_static(b"Welcome test1 - {\"test\":1}!"));
2018-05-07 03:05:31 +00:00
// client request
2018-05-17 19:20:20 +00:00
let request = srv
.get()
2018-05-07 03:05:31 +00:00
.uri(srv.url("/test1/index.html"))
.finish()
.unwrap();
let response = srv.execute(request.send()).unwrap();
assert_eq!(response.status(), StatusCode::BAD_REQUEST);
}
#[test]
fn test_path_and_query_extractor2_async4() {
let mut srv = test::TestServer::new(|app| {
app.resource("/{username}/index.html", |r| {
r.route()
.with(|data: (Json<Value>, Path<PParam>, Query<PParam>)| {
Timeout::new(Duration::from_millis(10), &Arbiter::handle())
.unwrap()
.and_then(move |_| {
2018-05-17 19:20:20 +00:00
Ok(format!("Welcome {} - {}!", data.1.username, (data.0).0))
2018-05-07 03:05:31 +00:00
})
.responder()
})
});
});
// client request
2018-05-17 19:20:20 +00:00
let request = srv
.post()
2018-05-07 03:05:31 +00:00
.uri(srv.url("/test1/index.html?username=test2"))
.header("content-type", "application/json")
.body("{\"test\": 1}")
.unwrap();
let response = srv.execute(request.send()).unwrap();
assert!(response.status().is_success());
// read response
let bytes = srv.execute(response.body()).unwrap();
2018-05-17 19:20:20 +00:00
assert_eq!(bytes, Bytes::from_static(b"Welcome test1 - {\"test\":1}!"));
2018-05-07 03:05:31 +00:00
// client request
2018-05-17 19:20:20 +00:00
let request = srv
.get()
2018-05-07 03:05:31 +00:00
.uri(srv.url("/test1/index.html"))
.finish()
.unwrap();
let response = srv.execute(request.send()).unwrap();
assert_eq!(response.status(), StatusCode::BAD_REQUEST);
}
2018-05-21 00:04:08 +00:00
#[test]
fn test_scope_and_path_extractor() {
let mut srv = test::TestServer::with_factory(move || {
App::new().scope("/sc", |scope| {
scope.resource("/{num}/index.html", |r| {
r.route()
.with(|p: Path<(usize,)>| format!("Welcome {}!", p.0))
2018-05-21 00:04:08 +00:00
})
})
});
// client request
let request = srv
.get()
.uri(srv.url("/sc/10/index.html"))
.finish()
.unwrap();
let response = srv.execute(request.send()).unwrap();
assert!(response.status().is_success());
// read response
let bytes = srv.execute(response.body()).unwrap();
assert_eq!(bytes, Bytes::from_static(b"Welcome 10!"));
// client request
let request = srv
.get()
.uri(srv.url("/sc/test1/index.html"))
.finish()
.unwrap();
let response = srv.execute(request.send()).unwrap();
assert_eq!(response.status(), StatusCode::NOT_FOUND);
}
#[test]
fn test_nested_scope_and_path_extractor() {
let mut srv = test::TestServer::with_factory(move || {
App::new().scope("/sc", |scope| {
scope.nested("/{num}", |scope| {
scope.resource("/{num}/index.html", |r| {
r.route().with(|p: Path<(usize, usize)>| {
format!("Welcome {} {}!", p.0, p.1)
})
2018-05-21 00:04:08 +00:00
})
})
})
});
// client request
let request = srv
.get()
.uri(srv.url("/sc/10/12/index.html"))
.finish()
.unwrap();
let response = srv.execute(request.send()).unwrap();
assert!(response.status().is_success());
// read response
let bytes = srv.execute(response.body()).unwrap();
assert_eq!(bytes, Bytes::from_static(b"Welcome 10 12!"));
// client request
let request = srv
.get()
.uri(srv.url("/sc/10/test1/index.html"))
.finish()
.unwrap();
let response = srv.execute(request.send()).unwrap();
assert_eq!(response.status(), StatusCode::NOT_FOUND);
}
#[cfg(actix_impl_trait)]
fn test_impl_trait(
data: (Json<Value>, Path<PParam>, Query<PParam>),
) -> impl Future<Item = String, Error = io::Error> {
Timeout::new(Duration::from_millis(10), &Arbiter::handle())
.unwrap()
2018-05-17 19:20:20 +00:00
.and_then(move |_| Ok(format!("Welcome {} - {}!", data.1.username, (data.0).0)))
}
#[cfg(actix_impl_trait)]
fn test_impl_trait_err(
_data: (Json<Value>, Path<PParam>, Query<PParam>),
) -> impl Future<Item = String, Error = io::Error> {
Timeout::new(Duration::from_millis(10), &Arbiter::handle())
.unwrap()
.and_then(move |_| Err(io::Error::new(io::ErrorKind::Other, "other")))
}
#[cfg(actix_impl_trait)]
#[test]
fn test_path_and_query_extractor2_async4_impl_trait() {
let mut srv = test::TestServer::new(|app| {
app.resource("/{username}/index.html", |r| {
r.route().with_async(test_impl_trait)
});
});
// client request
2018-05-17 19:20:20 +00:00
let request = srv
.post()
.uri(srv.url("/test1/index.html?username=test2"))
.header("content-type", "application/json")
.body("{\"test\": 1}")
.unwrap();
let response = srv.execute(request.send()).unwrap();
assert!(response.status().is_success());
// read response
let bytes = srv.execute(response.body()).unwrap();
2018-05-17 19:20:20 +00:00
assert_eq!(bytes, Bytes::from_static(b"Welcome test1 - {\"test\":1}!"));
// client request
2018-05-17 19:20:20 +00:00
let request = srv
.get()
.uri(srv.url("/test1/index.html"))
.finish()
.unwrap();
let response = srv.execute(request.send()).unwrap();
assert_eq!(response.status(), StatusCode::BAD_REQUEST);
}
#[cfg(actix_impl_trait)]
#[test]
fn test_path_and_query_extractor2_async4_impl_trait_err() {
let mut srv = test::TestServer::new(|app| {
app.resource("/{username}/index.html", |r| {
r.route().with_async(test_impl_trait_err)
});
});
// client request
2018-05-17 19:20:20 +00:00
let request = srv
.post()
.uri(srv.url("/test1/index.html?username=test2"))
.header("content-type", "application/json")
.body("{\"test\": 1}")
.unwrap();
let response = srv.execute(request.send()).unwrap();
assert_eq!(response.status(), StatusCode::INTERNAL_SERVER_ERROR);
}
#[test]
fn test_non_ascii_route() {
let mut srv = test::TestServer::new(|app| {
app.resource("/中文/index.html", |r| r.f(|_| "success"));
});
// client request
2018-05-17 19:20:20 +00:00
let request = srv
.get()
2018-04-29 16:09:08 +00:00
.uri(srv.url("/中文/index.html"))
.finish()
.unwrap();
let response = srv.execute(request.send()).unwrap();
assert!(response.status().is_success());
// read response
let bytes = srv.execute(response.body()).unwrap();
assert_eq!(bytes, Bytes::from_static(b"success"));
}
2018-04-17 19:55:13 +00:00
#[test]
fn test_unsafe_path_route() {
let mut srv = test::TestServer::new(|app| {
app.resource("/test/{url}", |r| {
r.f(|r| format!("success: {}", &r.match_info()["url"]))
});
});
// client request
2018-05-17 19:20:20 +00:00
let request = srv
.get()
2018-04-29 16:09:08 +00:00
.uri(srv.url("/test/http%3A%2F%2Fexample.com"))
.finish()
.unwrap();
2018-04-17 19:55:13 +00:00
let response = srv.execute(request.send()).unwrap();
assert!(response.status().is_success());
// read response
let bytes = srv.execute(response.body()).unwrap();
2018-04-29 16:09:08 +00:00
assert_eq!(
bytes,
Bytes::from_static(b"success: http:%2F%2Fexample.com")
);
2018-04-17 19:55:13 +00:00
}