actix/actix-web
1
0
Fork 0
mirror of https://github.com/fafhrd91/actix-web synced 2025-06-25 06:39:22 +02:00
Code Issues Releases Wiki Activity

clippy warnings

Browse Source
This commit is contained in:
Nikolay Kim
2018-04-29 09:09:08 -07:00
parent d98d723f97
commit c72d1381a6
62 changed files with 1742 additions and 818 deletions
Download Patch File Download Diff File Expand all files Collapse all files

43
tests/test_client.rs
View File

@ -72,7 +72,10 @@ 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());
@ -121,8 +124,10 @@ 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());
@ -162,7 +167,10 @@ 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| {
@ -220,7 +228,10 @@ 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| {
@ -264,8 +275,10 @@ 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());
@ -277,7 +290,10 @@ 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| {
@ -322,7 +338,9 @@ 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());
@ -395,8 +413,11 @@ 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,7 +26,10 @@ 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());
@ -44,7 +47,10 @@ 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());
@ -53,7 +59,10 @@ 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);
}
@ -69,8 +78,10 @@ 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());
@ -79,7 +90,10 @@ 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);
}
@ -88,15 +102,18 @@ 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());
@ -105,7 +122,10 @@ 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);
}
@ -117,7 +137,10 @@ 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());
@ -135,12 +158,17 @@ 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")
);
}

133
tests/test_server.rs
View File

@ -131,9 +131,7 @@ 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());
}
@ -206,7 +204,9 @@ 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)
})
});
@ -254,7 +254,10 @@ 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| {
@ -335,7 +338,11 @@ 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();
@ -343,7 +350,10 @@ 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());
}
@ -368,7 +378,10 @@ 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());
}
@ -392,7 +405,10 @@ 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());
}
}
@ -448,7 +464,9 @@ 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)
})
});
@ -472,7 +490,9 @@ 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)
})
});
@ -556,7 +576,10 @@ 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| {
@ -607,8 +630,10 @@ 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());
@ -637,8 +662,10 @@ 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());
@ -649,7 +676,10 @@ 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| {
@ -668,8 +698,10 @@ 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());
@ -699,8 +731,10 @@ 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());
@ -730,8 +764,10 @@ 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());
@ -749,29 +785,30 @@ 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()));
}
@ -795,20 +832,28 @@ 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,
) -> 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
}
}

59
tests/test_ws.rs
View File

@ -44,7 +44,12 @@ 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();
@ -52,7 +57,10 @@ fn test_simple() {
writer.close(Some(ws::CloseCode::Normal.into()));
let (item, _) = srv.execute(reader.into_future()).unwrap();
assert_eq!(item, Some(ws::Message::Close(Some(ws::CloseCode::Normal.into()))));
assert_eq!(
item,
Some(ws::Message::Close(Some(ws::CloseCode::Normal.into())))
);
}
#[test]
@ -79,7 +87,10 @@ 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();
@ -94,7 +105,10 @@ 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();
@ -103,7 +117,10 @@ 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())))
);
}
}
@ -207,20 +224,26 @@ 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)));