actix/actix-extras
1
0
Fork 0
mirror of https://github.com/actix/actix-extras.git synced 2025-06-25 09:59:21 +02:00
Code Issues Releases Wiki Activity

Merge and fix PR comments

Browse Source
This commit is contained in:
Sven-Hendrik Haase
2018-04-29 14:02:50 +02:00
parent 492c072564 de49796fd1
commit de222fe33b
71 changed files with 1884 additions and 2779 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
tests/test.binary Normal file
View File

@ -0,0 +1 @@
<EFBFBD>TǑɂV<EFBFBD>2<EFBFBD>vI<EFBFBD><EFBFBD><EFBFBD>\<5C>R˙<52><CB99><EFBFBD>e<EFBFBD><04>vD<76>:藽<>RV<03>Yp<59><70>;<3B><>G<><47>p!2<7F>C<EFBFBD>.<2E> <0C><><EFBFBD><EFBFBD>pA !<21>ߦ<EFBFBD>x j+Uc<55><63><EFBFBD>X<13>c%<17>;<3B>"y<10><>AI

BIN
tests/test.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 168 B

45
tests/test_client.rs
View File

@ -9,8 +9,8 @@ use std::io::Read;
use bytes::Bytes;
use flate2::read::GzDecoder;
use futures::Future;
use futures::stream::once;
use futures::Future;
use rand::Rng;
use actix_web::*;
@ -72,10 +72,7 @@ fn test_with_query_parameter() {
})
});
let request = srv.get()
.uri(srv.url("/?qp=5").as_str())
.finish()
.unwrap();
let request = srv.get().uri(srv.url("/?qp=5").as_str()).finish().unwrap();
let response = srv.execute(request.send()).unwrap();
assert!(response.status().is_success());
@ -124,10 +121,8 @@ fn test_client_gzip_encoding() {
});
// client request
let request = srv.post()
.content_encoding(http::ContentEncoding::Gzip)
.body(STR)
.unwrap();
let request =
srv.post().content_encoding(http::ContentEncoding::Gzip).body(STR).unwrap();
let response = srv.execute(request.send()).unwrap();
assert!(response.status().is_success());
@ -167,10 +162,7 @@ fn test_client_gzip_encoding_large() {
#[test]
fn test_client_gzip_encoding_large_random() {
let data = rand::thread_rng()
.gen_ascii_chars()
.take(100_000)
.collect::<String>();
let data = rand::thread_rng().gen_ascii_chars().take(100_000).collect::<String>();
let mut srv = test::TestServer::new(|app| {
app.handler(|req: HttpRequest| {
@ -228,10 +220,7 @@ fn test_client_brotli_encoding() {
#[cfg(feature = "brotli")]
#[test]
fn test_client_brotli_encoding_large_random() {
let data = rand::thread_rng()
.gen_ascii_chars()
.take(70_000)
.collect::<String>();
let data = rand::thread_rng().gen_ascii_chars().take(70_000).collect::<String>();
let mut srv = test::TestServer::new(|app| {
app.handler(|req: HttpRequest| {
@ -275,10 +264,8 @@ fn test_client_deflate_encoding() {
});
// client request
let request = srv.post()
.content_encoding(http::ContentEncoding::Deflate)
.body(STR)
.unwrap();
let request =
srv.post().content_encoding(http::ContentEncoding::Deflate).body(STR).unwrap();
let response = srv.execute(request.send()).unwrap();
assert!(response.status().is_success());
@ -290,10 +277,7 @@ fn test_client_deflate_encoding() {
#[cfg(feature = "brotli")]
#[test]
fn test_client_deflate_encoding_large_random() {
let data = rand::thread_rng()
.gen_ascii_chars()
.take(70_000)
.collect::<String>();
let data = rand::thread_rng().gen_ascii_chars().take(70_000).collect::<String>();
let mut srv = test::TestServer::new(|app| {
app.handler(|req: HttpRequest| {
@ -338,9 +322,7 @@ fn test_client_streaming_explicit() {
let body = once(Ok(Bytes::from_static(STR.as_ref())));
let request = srv.get()
.body(Body::Streaming(Box::new(body)))
.unwrap();
let request = srv.get().body(Body::Streaming(Box::new(body))).unwrap();
let response = srv.execute(request.send()).unwrap();
assert!(response.status().is_success());
@ -413,11 +395,8 @@ fn test_client_cookie_handling() {
})
});
let request = srv.get()
.cookie(cookie1.clone())
.cookie(cookie2.clone())
.finish()
.unwrap();
let request =
srv.get().cookie(cookie1.clone()).cookie(cookie2.clone()).finish().unwrap();
let response = srv.execute(request.send()).unwrap();
assert!(response.status().is_success());
let c1 = response.cookie("cookie1").expect("Missing cookie1");

60
tests/test_handlers.rs
View File

@ -26,10 +26,7 @@ fn test_path_extractor() {
});
// client request
let request = srv.get()
.uri(srv.url("/test/index.html"))
.finish()
.unwrap();
let request = srv.get().uri(srv.url("/test/index.html")).finish().unwrap();
let response = srv.execute(request.send()).unwrap();
assert!(response.status().is_success());
@ -47,10 +44,7 @@ fn test_query_extractor() {
});
// client request
let request = srv.get()
.uri(srv.url("/index.html?username=test"))
.finish()
.unwrap();
let request = srv.get().uri(srv.url("/index.html?username=test")).finish().unwrap();
let response = srv.execute(request.send()).unwrap();
assert!(response.status().is_success());
@ -59,10 +53,7 @@ fn test_query_extractor() {
assert_eq!(bytes, Bytes::from_static(b"Welcome test!"));
// client request
let request = srv.get()
.uri(srv.url("/index.html"))
.finish()
.unwrap();
let request = srv.get().uri(srv.url("/index.html")).finish().unwrap();
let response = srv.execute(request.send()).unwrap();
assert_eq!(response.status(), StatusCode::BAD_REQUEST);
}
@ -78,10 +69,8 @@ fn test_path_and_query_extractor() {
});
// client request
let request = srv.get()
.uri(srv.url("/test1/index.html?username=test2"))
.finish()
.unwrap();
let request =
srv.get().uri(srv.url("/test1/index.html?username=test2")).finish().unwrap();
let response = srv.execute(request.send()).unwrap();
assert!(response.status().is_success());
@ -90,10 +79,7 @@ fn test_path_and_query_extractor() {
assert_eq!(bytes, Bytes::from_static(b"Welcome test1 - test2!"));
// client request
let request = srv.get()
.uri(srv.url("/test1/index.html"))
.finish()
.unwrap();
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);
}
@ -102,18 +88,15 @@ fn test_path_and_query_extractor() {
fn test_path_and_query_extractor2() {
let mut srv = test::TestServer::new(|app| {
app.resource("/{username}/index.html", |r| {
r.route()
.with3(|_: HttpRequest, p: Path<PParam>, q: Query<PParam>| {
format!("Welcome {} - {}!", p.username, q.username)
})
r.route().with3(|_: HttpRequest, p: Path<PParam>, q: Query<PParam>| {
format!("Welcome {} - {}!", p.username, q.username)
})
});
});
// client request
let request = srv.get()
.uri(srv.url("/test1/index.html?username=test2"))
.finish()
.unwrap();
let request =
srv.get().uri(srv.url("/test1/index.html?username=test2")).finish().unwrap();
let response = srv.execute(request.send()).unwrap();
assert!(response.status().is_success());
@ -122,10 +105,7 @@ fn test_path_and_query_extractor2() {
assert_eq!(bytes, Bytes::from_static(b"Welcome test1 - test2!"));
// client request
let request = srv.get()
.uri(srv.url("/test1/index.html"))
.finish()
.unwrap();
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);
}
@ -137,10 +117,7 @@ fn test_non_ascii_route() {
});
// client request
let request = srv.get()
.uri(srv.url("/中文/index.html"))
.finish()
.unwrap();
let request = srv.get().uri(srv.url("/中文/index.html")).finish().unwrap();
let response = srv.execute(request.send()).unwrap();
assert!(response.status().is_success());
@ -158,17 +135,12 @@ fn test_unsafe_path_route() {
});
// client request
let request = srv.get()
.uri(srv.url("/test/http%3A%2F%2Fexample.com"))
.finish()
.unwrap();
let request =
srv.get().uri(srv.url("/test/http%3A%2F%2Fexample.com")).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: http:%2F%2Fexample.com")
);
assert_eq!(bytes, Bytes::from_static(b"success: http:%2F%2Fexample.com"));
}

153
tests/test_server.rs
View File

@ -14,9 +14,9 @@ extern crate brotli2;
#[cfg(feature = "brotli")]
use brotli2::write::{BrotliDecoder, BrotliEncoder};
use bytes::{Bytes, BytesMut};
use flate2::Compression;
use flate2::read::GzDecoder;
use flate2::write::{DeflateDecoder, DeflateEncoder, GzEncoder};
use flate2::Compression;
use futures::stream::once;
use futures::{future, Future, Stream};
use h2::client as h2client;
@ -62,11 +62,9 @@ fn test_start() {
thread::spawn(move || {
let sys = System::new("test");
let srv = server::new(|| {
vec![
App::new().resource("/", |r| {
r.method(http::Method::GET).f(|_| HttpResponse::Ok())
}),
]
vec![App::new().resource("/", |r| {
r.method(http::Method::GET).f(|_| HttpResponse::Ok())
})]
});
let srv = srv.bind("127.0.0.1:0").unwrap();
@ -113,11 +111,9 @@ fn test_shutdown() {
thread::spawn(move || {
let sys = System::new("test");
let srv = server::new(|| {
vec![
App::new().resource("/", |r| {
r.method(http::Method::GET).f(|_| HttpResponse::Ok())
}),
]
vec![App::new().resource("/", |r| {
r.method(http::Method::GET).f(|_| HttpResponse::Ok())
})]
});
let srv = srv.bind("127.0.0.1:0").unwrap();
@ -135,7 +131,9 @@ fn test_shutdown() {
.finish()
.unwrap();
let response = sys.run_until_complete(req.send()).unwrap();
srv_addr.do_send(server::StopServer { graceful: true });
srv_addr.do_send(server::StopServer {
graceful: true,
});
assert!(response.status().is_success());
}
@ -208,9 +206,7 @@ fn test_body() {
fn test_body_gzip() {
let mut srv = test::TestServer::new(|app| {
app.handler(|_| {
HttpResponse::Ok()
.content_encoding(http::ContentEncoding::Gzip)
.body(STR)
HttpResponse::Ok().content_encoding(http::ContentEncoding::Gzip).body(STR)
})
});
@ -258,10 +254,7 @@ fn test_body_gzip_large() {
#[test]
fn test_body_gzip_large_random() {
let data = rand::thread_rng()
.gen_ascii_chars()
.take(70_000)
.collect::<String>();
let data = rand::thread_rng().gen_ascii_chars().take(70_000).collect::<String>();
let srv_data = Arc::new(data.clone());
let mut srv = test::TestServer::new(move |app| {
@ -342,11 +335,7 @@ fn test_body_br_streaming() {
#[test]
fn test_head_empty() {
let mut srv = test::TestServer::new(|app| {
app.handler(|_| {
HttpResponse::Ok()
.content_length(STR.len() as u64)
.finish()
})
app.handler(|_| HttpResponse::Ok().content_length(STR.len() as u64).finish())
});
let request = srv.head().finish().unwrap();
@ -354,10 +343,7 @@ fn test_head_empty() {
assert!(response.status().is_success());
{
let len = response
.headers()
.get(http::header::CONTENT_LENGTH)
.unwrap();
let len = response.headers().get(http::header::CONTENT_LENGTH).unwrap();
assert_eq!(format!("{}", STR.len()), len.to_str().unwrap());
}
@ -382,10 +368,7 @@ fn test_head_binary() {
assert!(response.status().is_success());
{
let len = response
.headers()
.get(http::header::CONTENT_LENGTH)
.unwrap();
let len = response.headers().get(http::header::CONTENT_LENGTH).unwrap();
assert_eq!(format!("{}", STR.len()), len.to_str().unwrap());
}
@ -409,10 +392,7 @@ fn test_head_binary2() {
assert!(response.status().is_success());
{
let len = response
.headers()
.get(http::header::CONTENT_LENGTH)
.unwrap();
let len = response.headers().get(http::header::CONTENT_LENGTH).unwrap();
assert_eq!(format!("{}", STR.len()), len.to_str().unwrap());
}
}
@ -468,9 +448,7 @@ fn test_body_chunked_explicit() {
fn test_body_deflate() {
let mut srv = test::TestServer::new(|app| {
app.handler(|_| {
HttpResponse::Ok()
.content_encoding(http::ContentEncoding::Deflate)
.body(STR)
HttpResponse::Ok().content_encoding(http::ContentEncoding::Deflate).body(STR)
})
});
@ -494,9 +472,7 @@ fn test_body_deflate() {
fn test_body_brotli() {
let mut srv = test::TestServer::new(|app| {
app.handler(|_| {
HttpResponse::Ok()
.content_encoding(http::ContentEncoding::Br)
.body(STR)
HttpResponse::Ok().content_encoding(http::ContentEncoding::Br).body(STR)
})
});
@ -580,10 +556,7 @@ fn test_gzip_encoding_large() {
#[test]
fn test_reading_gzip_encoding_large_random() {
let data = rand::thread_rng()
.gen_ascii_chars()
.take(60_000)
.collect::<String>();
let data = rand::thread_rng().gen_ascii_chars().take(60_000).collect::<String>();
let mut srv = test::TestServer::new(|app| {
app.handler(|req: HttpRequest| {
@ -634,10 +607,8 @@ fn test_reading_deflate_encoding() {
let enc = e.finish().unwrap();
// client request
let request = srv.post()
.header(http::header::CONTENT_ENCODING, "deflate")
.body(enc)
.unwrap();
let request =
srv.post().header(http::header::CONTENT_ENCODING, "deflate").body(enc).unwrap();
let response = srv.execute(request.send()).unwrap();
assert!(response.status().is_success());
@ -666,10 +637,8 @@ fn test_reading_deflate_encoding_large() {
let enc = e.finish().unwrap();
// client request
let request = srv.post()
.header(http::header::CONTENT_ENCODING, "deflate")
.body(enc)
.unwrap();
let request =
srv.post().header(http::header::CONTENT_ENCODING, "deflate").body(enc).unwrap();
let response = srv.execute(request.send()).unwrap();
assert!(response.status().is_success());
@ -680,10 +649,7 @@ fn test_reading_deflate_encoding_large() {
#[test]
fn test_reading_deflate_encoding_large_random() {
let data = rand::thread_rng()
.gen_ascii_chars()
.take(160_000)
.collect::<String>();
let data = rand::thread_rng().gen_ascii_chars().take(160_000).collect::<String>();
let mut srv = test::TestServer::new(|app| {
app.handler(|req: HttpRequest| {
@ -702,10 +668,8 @@ fn test_reading_deflate_encoding_large_random() {
let enc = e.finish().unwrap();
// client request
let request = srv.post()
.header(http::header::CONTENT_ENCODING, "deflate")
.body(enc)
.unwrap();
let request =
srv.post().header(http::header::CONTENT_ENCODING, "deflate").body(enc).unwrap();
let response = srv.execute(request.send()).unwrap();
assert!(response.status().is_success());
@ -735,10 +699,8 @@ fn test_brotli_encoding() {
let enc = e.finish().unwrap();
// client request
let request = srv.post()
.header(http::header::CONTENT_ENCODING, "br")
.body(enc)
.unwrap();
let request =
srv.post().header(http::header::CONTENT_ENCODING, "br").body(enc).unwrap();
let response = srv.execute(request.send()).unwrap();
assert!(response.status().is_success());
@ -768,10 +730,8 @@ fn test_brotli_encoding_large() {
let enc = e.finish().unwrap();
// client request
let request = srv.post()
.header(http::header::CONTENT_ENCODING, "br")
.body(enc)
.unwrap();
let request =
srv.post().header(http::header::CONTENT_ENCODING, "br").body(enc).unwrap();
let response = srv.execute(request.send()).unwrap();
assert!(response.status().is_success());
@ -789,30 +749,29 @@ fn test_h2() {
let handle = core.handle();
let tcp = TcpStream::connect(&addr, &handle);
let tcp = tcp.then(|res| h2client::handshake(res.unwrap()))
.then(move |res| {
let (mut client, h2) = res.unwrap();
let tcp = tcp.then(|res| h2client::handshake(res.unwrap())).then(move |res| {
let (mut client, h2) = res.unwrap();
let request = Request::builder()
.uri(format!("https://{}/", addr).as_str())
.body(())
.unwrap();
let (response, _) = client.send_request(request, false).unwrap();
let request = Request::builder()
.uri(format!("https://{}/", addr).as_str())
.body(())
.unwrap();
let (response, _) = client.send_request(request, false).unwrap();
// Spawn a task to run the conn...
handle.spawn(h2.map_err(|e| println!("GOT ERR={:?}", e)));
// Spawn a task to run the conn...
handle.spawn(h2.map_err(|e| println!("GOT ERR={:?}", e)));
response.and_then(|response| {
assert_eq!(response.status(), http::StatusCode::OK);
response.and_then(|response| {
assert_eq!(response.status(), http::StatusCode::OK);
let (_, body) = response.into_parts();
let (_, body) = response.into_parts();
body.fold(BytesMut::new(), |mut b, c| -> Result<_, h2::Error> {
b.extend(c);
Ok(b)
})
body.fold(BytesMut::new(), |mut b, c| -> Result<_, h2::Error> {
b.extend(c);
Ok(b)
})
});
})
});
let _res = core.run(tcp);
// assert_eq!(res.unwrap(), Bytes::from_static(STR.as_ref()));
}
@ -836,28 +795,20 @@ struct MiddlewareTest {
impl<S> middleware::Middleware<S> for MiddlewareTest {
fn start(&self, _: &mut HttpRequest<S>) -> Result<middleware::Started> {
self.start.store(
self.start.load(Ordering::Relaxed) + 1,
Ordering::Relaxed,
);
self.start.store(self.start.load(Ordering::Relaxed) + 1, Ordering::Relaxed);
Ok(middleware::Started::Done)
}
fn response(
&self, _: &mut HttpRequest<S>, resp: HttpResponse
&self, _: &mut HttpRequest<S>, resp: HttpResponse,
) -> Result<middleware::Response> {
self.response.store(
self.response.load(Ordering::Relaxed) + 1,
Ordering::Relaxed,
);
self.response
.store(self.response.load(Ordering::Relaxed) + 1, Ordering::Relaxed);
Ok(middleware::Response::Done(resp))
}
fn finish(&self, _: &mut HttpRequest<S>, _: &HttpResponse) -> middleware::Finished {
self.finish.store(
self.finish.load(Ordering::Relaxed) + 1,
Ordering::Relaxed,
);
self.finish.store(self.finish.load(Ordering::Relaxed) + 1, Ordering::Relaxed);
middleware::Finished::Done
}
}

57
tests/test_ws.rs
View File

@ -44,12 +44,7 @@ fn test_simple() {
writer.binary(b"text".as_ref());
let (item, reader) = srv.execute(reader.into_future()).unwrap();
assert_eq!(
item,
Some(ws::Message::Binary(
Bytes::from_static(b"text").into()
))
);
assert_eq!(item, Some(ws::Message::Binary(Bytes::from_static(b"text").into())));
writer.ping("ping");
let (item, reader) = srv.execute(reader.into_future()).unwrap();
@ -75,7 +70,8 @@ fn test_close_description() {
let mut srv = test::TestServer::new(|app| app.handler(|req| ws::start(req, Ws)));
let (reader, mut writer) = srv.ws().unwrap();
let close_reason:ws::CloseReason = (ws::CloseCode::Normal, "close description").into();
let close_reason: ws::CloseReason =
(ws::CloseCode::Normal, "close description").into();
writer.close(Some(close_reason.clone()));
let (item, _) = srv.execute(reader.into_future()).unwrap();
assert_eq!(item, Some(ws::Message::Close(Some(close_reason))));
@ -83,10 +79,7 @@ fn test_close_description() {
#[test]
fn test_large_text() {
let data = rand::thread_rng()
.gen_ascii_chars()
.take(65_536)
.collect::<String>();
let data = rand::thread_rng().gen_ascii_chars().take(65_536).collect::<String>();
let mut srv = test::TestServer::new(|app| app.handler(|req| ws::start(req, Ws)));
let (mut reader, mut writer) = srv.ws().unwrap();
@ -101,10 +94,7 @@ fn test_large_text() {
#[test]
fn test_large_bin() {
let data = rand::thread_rng()
.gen_ascii_chars()
.take(65_536)
.collect::<String>();
let data = rand::thread_rng().gen_ascii_chars().take(65_536).collect::<String>();
let mut srv = test::TestServer::new(|app| app.handler(|req| ws::start(req, Ws)));
let (mut reader, mut writer) = srv.ws().unwrap();
@ -113,10 +103,7 @@ fn test_large_bin() {
writer.binary(data.clone());
let (item, r) = srv.execute(reader.into_future()).unwrap();
reader = r;
assert_eq!(
item,
Some(ws::Message::Binary(Binary::from(data.clone())))
);
assert_eq!(item, Some(ws::Message::Binary(Binary::from(data.clone()))));
}
}
@ -220,26 +207,20 @@ fn test_ws_server_ssl() {
// load ssl keys
let mut builder = SslAcceptor::mozilla_intermediate(SslMethod::tls()).unwrap();
builder
.set_private_key_file("tests/key.pem", SslFiletype::PEM)
.unwrap();
builder
.set_certificate_chain_file("tests/cert.pem")
.unwrap();
builder.set_private_key_file("tests/key.pem", SslFiletype::PEM).unwrap();
builder.set_certificate_chain_file("tests/cert.pem").unwrap();
let mut srv = test::TestServer::build()
.ssl(builder.build())
.start(|app| {
app.handler(|req| {
ws::start(
req,
Ws2 {
count: 0,
bin: false,
},
)
})
});
let mut srv = test::TestServer::build().ssl(builder.build()).start(|app| {
app.handler(|req| {
ws::start(
req,
Ws2 {
count: 0,
bin: false,
},
)
})
});
let (mut reader, _writer) = srv.ws().unwrap();
let data = Some(ws::Message::Text("0".repeat(65_536)));