berkus
/
actix-web
mirror of https://github.com/fafhrd91/actix-web
1
0
Fork 0
Code Issues Releases Wiki Activity

Merge branch 'master' into master

This commit is contained in:
jairinhohw 2019-05-24 14:05:19 -03:00 committed by GitHub
parent a4de813adc 801cc2ed5d
commit a40e84d6de
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
22 changed files with 369 additions and 102 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

27
CHANGES.md
View File

@ -1,13 +1,39 @@
# Changes
## [1.0.0] - 2019-05-xx
### Add
* Add `ServiceRequest::set_payload()` method.
* Add `test::TestRequest::set_json()` convenience method to automatically
serialize data and set header in test requests.
### Changes
* Drop an unnecessary `Option<_>` indirection around `ServerBuilder` from `HttpServer`. #863
### Fixed
* Clear http requests pool on app service drop #860
## [1.0.0-rc] - 2019-05-18
### Add
* Add `Query<T>::from_query()` to extract parameters from a query string. #846
* `QueryConfig`, similar to `JsonConfig` for customizing error handling of query extractors.
### Changes
* `JsonConfig` is now `Send + Sync`, this implies that `error_handler` must be `Send + Sync` too.
### Fixed
* Codegen with parameters in the path only resolves the first registered endpoint #841
## [1.0.0-beta.4] - 2019-05-12
### Add
@ -19,6 +45,7 @@
* `App::configure` take an `FnOnce` instead of `Fn`
* Upgrade actix-net crates
## [1.0.0-beta.3] - 2019-05-04
### Added

21
Cargo.toml
View File

@ -1,6 +1,6 @@
[package]
name = "actix-web"
version = "1.0.0-beta.5"
version = "1.0.0-rc"
authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
description = "Actix web is a simple, pragmatic and extremely fast web framework for Rust."
readme = "README.md"
@ -41,7 +41,7 @@ members = [
]
[features]
default = ["brotli", "flate2-zlib", "secure-cookies", "client"]
default = ["brotli", "flate2-zlib", "secure-cookies", "client", "fail"]
# http client
client = ["awc"]
@ -58,6 +58,8 @@ flate2-rust = ["actix-http/flate2-rust"]
# sessions feature, session require "ring" crate and c compiler
secure-cookies = ["actix-http/secure-cookies"]
fail = ["actix-http/fail"]
# openssl
ssl = ["openssl", "actix-server/ssl", "awc/ssl"]
@ -67,21 +69,20 @@ rust-tls = ["rustls", "actix-server/rust-tls"]
[dependencies]
actix-codec = "0.1.2"
actix-service = "0.4.0"
actix-utils = "0.4.0"
actix-router = "0.1.3"
actix-utils = "0.4.1"
actix-router = "0.1.5"
actix-rt = "0.2.2"
actix-web-codegen = "0.1.0-beta.1"
actix-http = { version = "0.2.0", features=["fail"] }
actix-server = "0.5.0"
actix-web-codegen = "0.1.0"
actix-http = "0.2.0"
actix-server = "0.5.1"
actix-server-config = "0.1.1"
actix-threadpool = "0.1.0"
actix = { version = "0.8.1", features=["http"], optional = true }
awc = { version = "0.2.0", optional = true }
bytes = "0.4"
derive_more = "0.14"
encoding = "0.2"
futures = "0.1"
futures = "0.1.25"
hashbrown = "0.3.0"
log = "0.4"
mime = "0.3"
@ -96,7 +97,7 @@ url = { version="1.7", features=["query_encoding"] }
# ssl support
openssl = { version="0.10", optional = true }
rustls = { version = "^0.15", optional = true }
rustls = { version = "0.15", optional = true }
[dev-dependencies]
actix-http = { version = "0.2.0", features=["ssl", "brotli", "flate2-zlib"] }

5
actix-files/CHANGES.md
View File

@ -1,5 +1,10 @@
# Changes
## [0.1.0] - 2019-05-xx
* NamedFile last-modified check always fails due to nano-seconds
in file modified date #820
## [0.1.0-beta.4] - 2019-05-12
* Update actix-web to beta.4

14
actix-files/src/named.rs
View File

@ -337,7 +337,12 @@ impl Responder for NamedFile {
} else if let (Some(ref m), Some(header::IfUnmodifiedSince(ref since))) =
(last_modified, req.get_header())
{
m > since
let t1: SystemTime = m.clone().into();
let t2: SystemTime = since.clone().into();
match (t1.duration_since(UNIX_EPOCH), t2.duration_since(UNIX_EPOCH)) {
(Ok(t1), Ok(t2)) => t1 > t2,
_ => false,
}
} else {
false
};
@ -350,7 +355,12 @@ impl Responder for NamedFile {
} else if let (Some(ref m), Some(header::IfModifiedSince(ref since))) =
(last_modified, req.get_header())
{
m <= since
let t1: SystemTime = m.clone().into();
let t2: SystemTime = since.clone().into();
match (t1.duration_since(UNIX_EPOCH), t2.duration_since(UNIX_EPOCH)) {
(Ok(t1), Ok(t2)) => t1 <= t2,
_ => false,
}
} else {
false
};

4
actix-multipart/CHANGES.md
View File

@ -1,5 +1,9 @@
# Changes
## [0.1.0] - 2019-05-18
* Release
## [0.1.0-beta.4] - 2019-05-12
* Handle cancellation of uploads #834 #736

4
actix-multipart/Cargo.toml
View File

@ -1,6 +1,6 @@
[package]
name = "actix-multipart"
version = "0.1.0-beta.4"
version = "0.1.0"
authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
description = "Multipart support for actix web framework."
readme = "README.md"
@ -18,7 +18,7 @@ name = "actix_multipart"
path = "src/lib.rs"
[dependencies]
actix-web = "1.0.0-beta.5"
actix-web = "1.0.0-rc"
actix-service = "0.4.0"
bytes = "0.4"
derive_more = "0.14"

4
actix-session/CHANGES.md
View File

@ -1,5 +1,9 @@
# Changes
## [0.1.0] - 2019-05-18
* Use actix-web 1.0.0-rc
## [0.1.0-beta.4] - 2019-05-12
* Use actix-web 1.0.0-beta.4

4
actix-session/Cargo.toml
View File

@ -1,6 +1,6 @@
[package]
name = "actix-session"
version = "0.1.0-beta.4"
version = "0.1.0"
authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
description = "Session for actix web framework."
readme = "README.md"
@ -24,7 +24,7 @@ default = ["cookie-session"]
cookie-session = ["actix-web/secure-cookies"]
[dependencies]
actix-web = "1.0.0-beta.5"
actix-web = "1.0.0-rc"
actix-service = "0.4.0"
bytes = "0.4"
derive_more = "0.14"

2
actix-web-actors/Cargo.toml
View File

@ -18,7 +18,7 @@ name = "actix_web_actors"
path = "src/lib.rs"
[dependencies]
actix = "0.8.0"
actix = "0.8.2"
actix-web = "1.0.0-beta.5"
actix-http = "0.2.0"
actix-codec = "0.1.2"

4
actix-web-codegen/CHANGES.md
View File

@ -1,5 +1,9 @@
# Changes
## [0.1.0] - 2019-05-18
* Release
## [0.1.0-beta.1] - 2019-04-20
* Gen code for actix-web 1.0.0-beta.1

2
actix-web-codegen/Cargo.toml
View File

@ -1,6 +1,6 @@
[package]
name = "actix-web-codegen"
version = "0.1.0-beta.1"
version = "0.1.0"
description = "Actix web proc macros"
readme = "README.md"
authors = ["Nikolay Kim <fafhrd91@gmail.com>"]

43
actix-web-codegen/tests/test_macro.rs
View File

@ -1,7 +1,7 @@
use actix_http::HttpService;
use actix_http_test::TestServer;
use actix_web::{http, App, HttpResponse, Responder};
use actix_web_codegen::{get, post, put};
use actix_web::{http, web::Path, App, HttpResponse, Responder};
use actix_web_codegen::{delete, get, post, put};
use futures::{future, Future};
#[get("/test")]
@ -29,6 +29,45 @@ fn auto_sync() -> impl Future<Item = HttpResponse, Error = actix_web::Error> {
future::ok(HttpResponse::Ok().finish())
}
#[put("/test/{param}")]
fn put_param_test(_: Path<String>) -> impl Responder {
HttpResponse::Created()
}
#[delete("/test/{param}")]
fn delete_param_test(_: Path<String>) -> impl Responder {
HttpResponse::NoContent()
}
#[get("/test/{param}")]
fn get_param_test(_: Path<String>) -> impl Responder {
HttpResponse::Ok()
}
#[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),
)
});
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::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::DELETE, srv.url("/test/it"));
let response = srv.block_on(request.send()).unwrap();
assert_eq!(response.status(), http::StatusCode::NO_CONTENT);
}
#[test]
fn test_body() {
let mut srv = TestServer::new(|| {

51
src/app_service.rs
View File

@ -183,7 +183,7 @@ where
}
/// Service to convert `Request` to a `ServiceRequest<S>`
pub struct AppInitService<T: Service, B>
pub struct AppInitService<T, B>
where
T: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
{
@ -215,19 +215,31 @@ where
inner.path.get_mut().update(&head.uri);
inner.path.reset();
inner.head = head;
inner.payload = payload;
inner.app_data = self.data.clone();
req
} else {
HttpRequest::new(
Path::new(Url::new(head.uri.clone())),
head,
payload,
self.rmap.clone(),
self.config.clone(),
self.data.clone(),
self.pool,
)
};
self.service.call(ServiceRequest::from_parts(req, payload))
self.service.call(ServiceRequest::new(req))
}
}
impl<T, B> Drop for AppInitService<T, B>
where
T: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
{
fn drop(&mut self) {
self.pool.clear();
println!("DROP: APP-INIT-ENTRY");
}
}
@ -408,3 +420,38 @@ impl NewService for AppEntry {
self.factory.borrow_mut().as_mut().unwrap().new_service(&())
}
}
#[cfg(test)]
mod tests {
use actix_service::Service;
use std::sync::{
atomic::{AtomicBool, Ordering},
Arc,
};
use crate::{test, web, App, HttpResponse};
struct DropData(Arc<AtomicBool>);
impl Drop for DropData {
fn drop(&mut self) {
self.0.store(true, Ordering::Relaxed);
println!("Dropping!");
}
}
#[test]
fn drop_data() {
let data = Arc::new(AtomicBool::new(false));
{
let mut app = test::init_service(
App::new()
.data(DropData(data.clone()))
.service(web::resource("/test").to(|| HttpResponse::Ok())),
);
let req = test::TestRequest::with_uri("/test").to_request();
let _ = test::block_on(app.call(req)).unwrap();
}
assert!(data.load(Ordering::Relaxed));
}
}

9
src/error.rs
View File

@ -104,7 +104,9 @@ pub enum QueryPayloadError {
impl ResponseError for QueryPayloadError {
fn error_response(&self) -> HttpResponse {
match *self {
QueryPayloadError::Deserialize(_) => HttpResponse::new(StatusCode::BAD_REQUEST),
QueryPayloadError::Deserialize(_) => {
HttpResponse::new(StatusCode::BAD_REQUEST)
}
}
}
}
@ -163,7 +165,10 @@ mod tests {
#[test]
fn test_query_payload_error() {
let resp: HttpResponse = QueryPayloadError::Deserialize(serde_urlencoded::from_str::<i32>("bad query").unwrap_err()).error_response();
let resp: HttpResponse = QueryPayloadError::Deserialize(
serde_urlencoded::from_str::<i32>("bad query").unwrap_err(),
)
.error_response();
assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
}

11
src/handler.rs
View File

@ -1,7 +1,7 @@
use std::convert::Infallible;
use std::marker::PhantomData;
use actix_http::{Error, Payload, Response};
use actix_http::{Error, Response};
use actix_service::{NewService, Service};
use futures::future::{ok, FutureResult};
use futures::{try_ready, Async, Future, IntoFuture, Poll};
@ -331,15 +331,15 @@ where
ExtractResponse {
fut,
req,
fut_s: None,
req: Some((req, payload)),
service: self.service.clone(),
}
}
}
pub struct ExtractResponse<T: FromRequest, S: Service> {
req: Option<(HttpRequest, Payload)>,
req: HttpRequest,
service: S,
fut: <T::Future as IntoFuture>::Future,
fut_s: Option<S::Future>,
@ -362,12 +362,11 @@ where
}
let item = try_ready!(self.fut.poll().map_err(|e| {
let (req, payload) = self.req.take().unwrap();
let req = ServiceRequest::from_parts(req, payload);
let req = ServiceRequest::new(self.req.clone());
(e.into(), req)
}));
self.fut_s = Some(self.service.call((item, self.req.take().unwrap().0)));
self.fut_s = Some(self.service.call((item, self.req.clone())));
self.poll()
}
}

1
src/lib.rs
View File

@ -151,6 +151,7 @@ pub mod dev {
};
pub use actix_router::{Path, ResourceDef, ResourcePath, Url};
pub use actix_server::Server;
pub use actix_service::{Service, Transform};
pub(crate) fn insert_slash(path: &str) -> String {
let mut path = path.to_owned();

7
src/request.rs
View File

@ -20,6 +20,7 @@ pub struct HttpRequest(pub(crate) Rc<HttpRequestInner>);
pub(crate) struct HttpRequestInner {
pub(crate) head: Message<RequestHead>,
pub(crate) path: Path<Url>,
pub(crate) payload: Payload,
pub(crate) app_data: Rc<Extensions>,
rmap: Rc<ResourceMap>,
config: AppConfig,
@ -31,6 +32,7 @@ impl HttpRequest {
pub(crate) fn new(
path: Path<Url>,
head: Message<RequestHead>,
payload: Payload,
rmap: Rc<ResourceMap>,
config: AppConfig,
app_data: Rc<Extensions>,
@ -39,6 +41,7 @@ impl HttpRequest {
HttpRequest(Rc::new(HttpRequestInner {
head,
path,
payload,
rmap,
config,
app_data,
@ -325,6 +328,10 @@ impl HttpRequestPool {
None
}
}
pub(crate) fn clear(&self) {
self.0.borrow_mut().clear()
}
}
#[cfg(test)]

43
src/resource.rs
View File

@ -606,7 +606,7 @@ mod tests {
use crate::http::{header, HeaderValue, Method, StatusCode};
use crate::service::{ServiceRequest, ServiceResponse};
use crate::test::{call_service, init_service, TestRequest};
use crate::{web, App, Error, HttpResponse};
use crate::{guard, web, App, Error, HttpResponse};
fn md<S, B>(
req: ServiceRequest,
@ -723,4 +723,45 @@ mod tests {
let resp = call_service(&mut srv, req);
assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
}
#[test]
fn test_resource_guards() {
let mut srv = init_service(
App::new()
.service(
web::resource("/test/{p}")
.guard(guard::Get())
.to(|| HttpResponse::Ok()),
)
.service(
web::resource("/test/{p}")
.guard(guard::Put())
.to(|| HttpResponse::Created()),
)
.service(
web::resource("/test/{p}")
.guard(guard::Delete())
.to(|| HttpResponse::NoContent()),
),
);
let req = TestRequest::with_uri("/test/it")
.method(Method::GET)
.to_request();
let resp = call_service(&mut srv, req);
assert_eq!(resp.status(), StatusCode::OK);
let req = TestRequest::with_uri("/test/it")
.method(Method::PUT)
.to_request();
let resp = call_service(&mut srv, req);
assert_eq!(resp.status(), StatusCode::CREATED);
let req = TestRequest::with_uri("/test/it")
.method(Method::DELETE)
.to_request();
let resp = call_service(&mut srv, req);
assert_eq!(resp.status(), StatusCode::NO_CONTENT);
}
}

63
src/server.rs
View File

@ -64,7 +64,7 @@ where
config: Arc<Mutex<Config>>,
backlog: i32,
sockets: Vec<Socket>,
builder: Option<ServerBuilder>,
builder: ServerBuilder,
_t: PhantomData<(S, B)>,
}
@ -91,7 +91,7 @@ where
})),
backlog: 1024,
sockets: Vec::new(),
builder: Some(ServerBuilder::default()),
builder: ServerBuilder::default(),
_t: PhantomData,
}
}
@ -101,7 +101,7 @@ where
/// By default http server uses number of available logical cpu as threads
/// count.
pub fn workers(mut self, num: usize) -> Self {
self.builder = Some(self.builder.take().unwrap().workers(num));
self.builder = self.builder.workers(num);
self
}
@ -117,7 +117,7 @@ where
/// This method should be called before `bind()` method call.
pub fn backlog(mut self, backlog: i32) -> Self {
self.backlog = backlog;
self.builder = Some(self.builder.take().unwrap().backlog(backlog));
self.builder = self.builder.backlog(backlog);
self
}
@ -128,7 +128,7 @@ where
///
/// By default max connections is set to a 25k.
pub fn maxconn(mut self, num: usize) -> Self {
self.builder = Some(self.builder.take().unwrap().maxconn(num));
self.builder = self.builder.maxconn(num);
self
}
@ -139,7 +139,7 @@ where
///
/// By default max connections is set to a 256.
pub fn maxconnrate(mut self, num: usize) -> Self {
self.builder = Some(self.builder.take().unwrap().maxconnrate(num));
self.builder = self.builder.maxconnrate(num);
self
}
@ -190,13 +190,13 @@ where
/// Stop actix system.
pub fn system_exit(mut self) -> Self {
self.builder = Some(self.builder.take().unwrap().system_exit());
self.builder = self.builder.system_exit();
self
}
/// Disable signal handling
pub fn disable_signals(mut self) -> Self {
self.builder = Some(self.builder.take().unwrap().disable_signals());
self.builder = self.builder.disable_signals();
self
}
@ -207,8 +207,8 @@ where
/// dropped.
///
/// By default shutdown timeout sets to 30 seconds.
pub fn shutdown_timeout(mut self, sec: u16) -> Self {
self.builder = Some(self.builder.take().unwrap().shutdown_timeout(sec));
pub fn shutdown_timeout(mut self, sec: u64) -> Self {
self.builder = self.builder.shutdown_timeout(sec);
self
}
@ -240,7 +240,7 @@ where
scheme: "http",
});
self.builder = Some(self.builder.take().unwrap().listen(
self.builder = self.builder.listen(
format!("actix-web-service-{}", addr),
lst,
move || {
@ -250,8 +250,7 @@ where
.client_timeout(c.client_timeout)
.finish(factory())
},
)?);
)?;
Ok(self)
}
@ -260,20 +259,19 @@ where
///
/// This method sets alpn protocols to "h2" and "http/1.1"
pub fn listen_ssl(
mut self,
self,
lst: net::TcpListener,
builder: SslAcceptorBuilder,
) -> io::Result<Self> {
self.listen_ssl_inner(lst, openssl_acceptor(builder)?)?;
Ok(self)
self.listen_ssl_inner(lst, openssl_acceptor(builder)?)
}
#[cfg(feature = "ssl")]
fn listen_ssl_inner(
&mut self,
mut self,
lst: net::TcpListener,
acceptor: SslAcceptor,
) -> io::Result<()> {
) -> io::Result<Self> {
use actix_server::ssl::{OpensslAcceptor, SslError};
let acceptor = OpensslAcceptor::new(acceptor);
@ -285,7 +283,7 @@ where
scheme: "https",
});
self.builder = Some(self.builder.take().unwrap().listen(
self.builder = self.builder.listen(
format!("actix-web-service-{}", addr),
lst,
move || {
@ -300,8 +298,8 @@ where
.map_init_err(|_| ()),
)
},
)?);
Ok(())
)?;
Ok(self)
}
#[cfg(feature = "rust-tls")]
@ -309,20 +307,19 @@ where
///
/// This method sets alpn protocols to "h2" and "http/1.1"
pub fn listen_rustls(
mut self,
self,
lst: net::TcpListener,
config: RustlsServerConfig,
) -> io::Result<Self> {
self.listen_rustls_inner(lst, config)?;
Ok(self)
self.listen_rustls_inner(lst, config)
}
#[cfg(feature = "rust-tls")]
fn listen_rustls_inner(
&mut self,
mut self,
lst: net::TcpListener,
mut config: RustlsServerConfig,
) -> io::Result<()> {
) -> io::Result<Self> {
use actix_server::ssl::{RustlsAcceptor, SslError};
let protos = vec!["h2".to_string().into(), "http/1.1".to_string().into()];
@ -337,7 +334,7 @@ where
scheme: "https",
});
self.builder = Some(self.builder.take().unwrap().listen(
self.builder = self.builder.listen(
format!("actix-web-service-{}", addr),
lst,
move || {
@ -352,8 +349,8 @@ where
.map_init_err(|_| ()),
)
},
)?);
Ok(())
)?;
Ok(self)
}
/// The socket address to bind
@ -416,7 +413,7 @@ where
let acceptor = openssl_acceptor(builder)?;
for lst in sockets {
self.listen_ssl_inner(lst, acceptor.clone())?;
self = self.listen_ssl_inner(lst, acceptor.clone())?;
}
Ok(self)
@ -433,7 +430,7 @@ where
) -> io::Result<Self> {
let sockets = self.bind2(addr)?;
for lst in sockets {
self.listen_rustls_inner(lst, config.clone())?;
self = self.listen_rustls_inner(lst, config.clone())?;
}
Ok(self)
}
@ -473,8 +470,8 @@ where
/// sys.run() // <- Run actix system, this method starts all async processes
/// }
/// ```
pub fn start(mut self) -> Server {
self.builder.take().unwrap().start()
pub fn start(self) -> Server {
self.builder.start()
}
/// Spawn new thread and start listening for incoming connections.

48
src/service.rs
View File

@ -50,45 +50,46 @@ where
}
}
pub struct ServiceRequest {
req: HttpRequest,
payload: Payload,
}
/// An service http request
///
/// ServiceRequest allows mutable access to request's internal structures
pub struct ServiceRequest(HttpRequest);
impl ServiceRequest {
/// Construct service request from parts
pub(crate) fn from_parts(req: HttpRequest, payload: Payload) -> Self {
ServiceRequest { req, payload }
/// Construct service request
pub(crate) fn new(req: HttpRequest) -> Self {
ServiceRequest(req)
}
/// Deconstruct request into parts
pub fn into_parts(self) -> (HttpRequest, Payload) {
(self.req, self.payload)
pub fn into_parts(mut self) -> (HttpRequest, Payload) {
let pl = Rc::get_mut(&mut (self.0).0).unwrap().payload.take();
(self.0, pl)
}
/// Create service response
#[inline]
pub fn into_response<B, R: Into<Response<B>>>(self, res: R) -> ServiceResponse<B> {
ServiceResponse::new(self.req, res.into())
ServiceResponse::new(self.0, res.into())
}
/// Create service response for error
#[inline]
pub fn error_response<B, E: Into<Error>>(self, err: E) -> ServiceResponse<B> {
let res: Response = err.into().into();
ServiceResponse::new(self.req, res.into_body())
ServiceResponse::new(self.0, res.into_body())
}
/// This method returns reference to the request head
#[inline]
pub fn head(&self) -> &RequestHead {
&self.req.head()
&self.0.head()
}
/// This method returns reference to the request head
#[inline]
pub fn head_mut(&mut self) -> &mut RequestHead {
self.req.head_mut()
self.0.head_mut()
}
/// Request's uri.
@ -164,34 +165,39 @@ impl ServiceRequest {
/// access the matched value for that segment.
#[inline]
pub fn match_info(&self) -> &Path<Url> {
self.req.match_info()
self.0.match_info()
}
#[inline]
pub fn match_info_mut(&mut self) -> &mut Path<Url> {
self.req.match_info_mut()
self.0.match_info_mut()
}
/// Service configuration
#[inline]
pub fn app_config(&self) -> &AppConfig {
self.req.app_config()
self.0.app_config()
}
/// Get an application data stored with `App::data()` method during
/// application configuration.
pub fn app_data<T: 'static>(&self) -> Option<Data<T>> {
if let Some(st) = self.req.0.app_data.get::<Data<T>>() {
if let Some(st) = (self.0).0.app_data.get::<Data<T>>() {
Some(st.clone())
} else {
None
}
}
/// Set request payload.
pub fn set_payload(&mut self, payload: Payload) {
Rc::get_mut(&mut (self.0).0).unwrap().payload = payload;
}
#[doc(hidden)]
/// Set new app data container
pub fn set_data_container(&mut self, extensions: Rc<Extensions>) {
Rc::get_mut(&mut self.req.0).unwrap().app_data = extensions;
Rc::get_mut(&mut (self.0).0).unwrap().app_data = extensions;
}
}
@ -213,18 +219,18 @@ impl HttpMessage for ServiceRequest {
/// Request extensions
#[inline]
fn extensions(&self) -> Ref<Extensions> {
self.req.extensions()
self.0.extensions()
}
/// Mutable reference to a the request's extensions
#[inline]
fn extensions_mut(&self) -> RefMut<Extensions> {
self.req.extensions_mut()
self.0.extensions_mut()
}
#[inline]
fn take_payload(&mut self) -> Payload<Self::Stream> {
std::mem::replace(&mut self.payload, Payload::None)
Rc::get_mut(&mut (self.0).0).unwrap().payload.take()
}
}

52
src/test.rs
View File

@ -2,7 +2,7 @@
use std::cell::RefCell;
use std::rc::Rc;
use actix_http::http::header::{Header, HeaderName, IntoHeaderValue};
use actix_http::http::header::{ContentType, Header, HeaderName, IntoHeaderValue};
use actix_http::http::{HttpTryFrom, Method, StatusCode, Uri, Version};
use actix_http::test::TestRequest as HttpTestRequest;
use actix_http::{cookie::Cookie, Extensions, Request};
@ -14,6 +14,7 @@ use bytes::{Bytes, BytesMut};
use futures::future::{lazy, ok, Future, IntoFuture};
use futures::Stream;
use serde::de::DeserializeOwned;
use serde::Serialize;
use serde_json;
pub use actix_http::test::TestBuffer;
@ -248,7 +249,7 @@ where
/// .header(header::CONTENT_TYPE, "application/json")
/// .to_request();
///
/// let resp = call_service(&mut srv, req);
/// let resp = test::call_service(&mut app, req);
/// let result = test::read_body(resp);
/// assert_eq!(result, Bytes::from_static(b"welcome!"));
/// }
@ -477,6 +478,16 @@ impl TestRequest {
self
}
/// Serialize `data` to JSON and set it as the request payload. The `Content-Type` header is
/// set to `application/json`.
pub fn set_json<T: Serialize>(mut self, data: &T) -> Self {
let bytes =
serde_json::to_string(data).expect("Failed to serialize test data to json");
self.req.set_payload(bytes);
self.req.set(ContentType::json());
self
}
/// Set application data. This is equivalent of `App::data()` method
/// for testing purpose.
pub fn data<T: 'static>(mut self, data: T) -> Self {
@ -501,16 +512,15 @@ impl TestRequest {
let (head, payload) = self.req.finish().into_parts();
self.path.get_mut().update(&head.uri);
let req = HttpRequest::new(
ServiceRequest::new(HttpRequest::new(
self.path,
head,
payload,
Rc::new(self.rmap),
AppConfig::new(self.config),
Rc::new(self.app_data),
HttpRequestPool::create(),
);
ServiceRequest::from_parts(req, payload)
))
}
/// Complete request creation and generate `ServiceResponse` instance
@ -520,12 +530,13 @@ impl TestRequest {
/// Complete request creation and generate `HttpRequest` instance
pub fn to_http_request(mut self) -> HttpRequest {
let (head, _) = self.req.finish().into_parts();
let (head, payload) = self.req.finish().into_parts();
self.path.get_mut().update(&head.uri);
HttpRequest::new(
self.path,
head,
payload,
Rc::new(self.rmap),
AppConfig::new(self.config),
Rc::new(self.app_data),
@ -541,6 +552,7 @@ impl TestRequest {
let req = HttpRequest::new(
self.path,
head,
Payload::None,
Rc::new(self.rmap),
AppConfig::new(self.config),
Rc::new(self.app_data),
@ -553,6 +565,7 @@ impl TestRequest {
#[cfg(test)]
mod tests {
use actix_http::httpmessage::HttpMessage;
use serde::{Deserialize, Serialize};
use std::time::SystemTime;
@ -657,6 +670,31 @@ mod tests {
assert_eq!(&result.id, "12345");
}
#[test]
fn test_request_response_json() {
let mut app = init_service(App::new().service(web::resource("/people").route(
web::post().to(|person: web::Json<Person>| {
HttpResponse::Ok().json(person.into_inner())
}),
)));
let payload = Person {
id: "12345".to_string(),
name: "User name".to_string(),
};
let req = TestRequest::post()
.uri("/people")
.set_json(&payload)
.to_request();
assert_eq!(req.content_type(), "application/json");
let result: Person = read_response_json(&mut app, req);
assert_eq!(&result.id, "12345");
assert_eq!(&result.name, "User name");
}
#[test]
fn test_async_with_block() {
fn async_with_block() -> impl Future<Item = HttpResponse, Error = Error> {

52
src/types/query.rs
View File

@ -8,9 +8,9 @@ use serde::de;
use serde_urlencoded;
use crate::dev::Payload;
use crate::error::QueryPayloadError;
use crate::extract::FromRequest;
use crate::request::HttpRequest;
use crate::error::QueryPayloadError;
#[derive(PartialEq, Eq, PartialOrd, Ord)]
/// Extract typed information from from the request's query.
@ -52,6 +52,16 @@ impl<T> Query<T> {
pub fn into_inner(self) -> T {
self.0
}
/// Get query parameters from the path
pub fn from_query(query_str: &str) -> Result<Self, QueryPayloadError>
where
T: de::DeserializeOwned,
{
serde_urlencoded::from_str::<T>(query_str)
.map(|val| Ok(Query(val)))
.unwrap_or_else(move |e| Err(QueryPayloadError::Deserialize(e)))
}
}
impl<T> ops::Deref for Query<T> {
@ -188,8 +198,8 @@ pub struct QueryConfig {
impl QueryConfig {
/// Set custom error handler
pub fn error_handler<F>(mut self, f: F) -> Self
where
F: Fn(QueryPayloadError, &HttpRequest) -> Error + Send + Sync + 'static,
where
F: Fn(QueryPayloadError, &HttpRequest) -> Error + Send + Sync + 'static,
{
self.ehandler = Some(Arc::new(f));
self
@ -198,21 +208,19 @@ impl QueryConfig {
impl Default for QueryConfig {
fn default() -> Self {
QueryConfig {
ehandler: None,
}
QueryConfig { ehandler: None }
}
}
#[cfg(test)]
mod tests {
use actix_http::http::StatusCode;
use derive_more::Display;
use serde_derive::Deserialize;
use actix_http::http::StatusCode;
use super::*;
use crate::test::TestRequest;
use crate::error::InternalError;
use crate::test::TestRequest;
use crate::HttpResponse;
#[derive(Deserialize, Debug, Display)]
@ -220,6 +228,22 @@ mod tests {
id: String,
}
#[test]
fn test_service_request_extract() {
let req = TestRequest::with_uri("/name/user1/").to_srv_request();
assert!(Query::<Id>::from_query(&req.query_string()).is_err());
let req = TestRequest::with_uri("/name/user1/?id=test").to_srv_request();
let mut s = Query::<Id>::from_query(&req.query_string()).unwrap();
assert_eq!(s.id, "test");
assert_eq!(format!("{}, {:?}", s, s), "test, Id { id: \"test\" }");
s.id = "test1".to_string();
let s = s.into_inner();
assert_eq!(s.id, "test1");
}
#[test]
fn test_request_extract() {
let req = TestRequest::with_uri("/name/user1/").to_srv_request();
@ -244,12 +268,20 @@ mod tests {
.data(QueryConfig::default().error_handler(|e, _| {
let resp = HttpResponse::UnprocessableEntity().finish();
InternalError::from_response(e, resp).into()
})).to_srv_request();
}))
.to_srv_request();
let (req, mut pl) = req.into_parts();
let query = Query::<Id>::from_request(&req, &mut pl);
assert!(query.is_err());
assert_eq!(query.unwrap_err().as_response_error().error_response().status(), StatusCode::UNPROCESSABLE_ENTITY);
assert_eq!(
query
.unwrap_err()
.as_response_error()
.error_response()
.status(),
StatusCode::UNPROCESSABLE_ENTITY
);
}
}