1
0
Fork 0
mirror of https://github.com/actix/actix-web.git synced 2024-12-24 00:50:36 +00:00
actix-web/tests/test_server.rs

836 lines
26 KiB
Rust
Raw Normal View History

extern crate actix;
extern crate actix_web;
2018-04-13 23:02:01 +00:00
extern crate bytes;
extern crate flate2;
2017-12-27 20:58:32 +00:00
extern crate futures;
2018-01-09 20:49:46 +00:00
extern crate h2;
2018-03-31 00:31:18 +00:00
extern crate http as modhttp;
extern crate rand;
2018-04-13 23:02:01 +00:00
extern crate tokio_core;
2018-04-13 23:02:01 +00:00
#[cfg(feature = "brotli")]
extern crate brotli2;
2018-04-13 23:02:01 +00:00
#[cfg(feature = "brotli")]
use brotli2::write::{BrotliDecoder, BrotliEncoder};
use bytes::{Bytes, BytesMut};
2018-02-19 21:18:18 +00:00
use flate2::read::GzDecoder;
2018-04-13 23:02:01 +00:00
use flate2::write::{DeflateDecoder, DeflateEncoder, GzEncoder};
2018-04-29 05:55:47 +00:00
use flate2::Compression;
2018-01-11 23:26:46 +00:00
use futures::stream::once;
use futures::{Future, Stream};
2018-02-19 21:18:18 +00:00
use h2::client as h2client;
2018-03-31 00:31:18 +00:00
use modhttp::Request;
2018-04-13 23:02:01 +00:00
use rand::Rng;
use std::io::{Read, Write};
use std::sync::{mpsc, Arc};
use std::{net, thread, time};
2018-01-09 20:49:46 +00:00
use tokio_core::net::TcpStream;
use tokio_core::reactor::Core;
2017-12-27 04:07:31 +00:00
use actix::System;
2018-02-19 21:18:18 +00:00
use actix_web::*;
2018-04-13 23:02:01 +00:00
const STR: &str = "Hello World Hello World Hello World Hello World Hello World \
Hello World Hello World Hello World Hello World Hello World \
Hello World Hello World Hello World Hello World Hello World \
Hello World Hello World Hello World Hello World Hello World \
Hello World Hello World Hello World Hello World Hello World \
Hello World Hello World Hello World Hello World Hello World \
Hello World Hello World Hello World Hello World Hello World \
Hello World Hello World Hello World Hello World Hello World \
Hello World Hello World Hello World Hello World Hello World \
Hello World Hello World Hello World Hello World Hello World \
Hello World Hello World Hello World Hello World Hello World \
Hello World Hello World Hello World Hello World Hello World \
Hello World Hello World Hello World Hello World Hello World \
Hello World Hello World Hello World Hello World Hello World \
Hello World Hello World Hello World Hello World Hello World \
Hello World Hello World Hello World Hello World Hello World \
Hello World Hello World Hello World Hello World Hello World \
Hello World Hello World Hello World Hello World Hello World \
Hello World Hello World Hello World Hello World Hello World \
Hello World Hello World Hello World Hello World Hello World \
Hello World Hello World Hello World Hello World Hello World";
2018-01-11 05:47:30 +00:00
2017-12-27 04:07:31 +00:00
#[test]
2018-05-22 04:01:52 +00:00
#[cfg(unix)]
2017-12-27 04:07:31 +00:00
fn test_start() {
2017-12-27 19:22:27 +00:00
let _ = test::TestServer::unused_addr();
let (tx, rx) = mpsc::channel();
2017-12-27 04:07:31 +00:00
thread::spawn(move || {
let sys = System::new("test");
2018-04-13 23:02:01 +00:00
let srv = server::new(|| {
2018-04-29 05:55:47 +00:00
vec![App::new().resource("/", |r| {
r.method(http::Method::GET).f(|_| HttpResponse::Ok())
})]
2018-04-13 23:02:01 +00:00
});
2017-12-27 20:58:32 +00:00
2017-12-27 19:22:27 +00:00
let srv = srv.bind("127.0.0.1:0").unwrap();
2017-12-28 20:38:37 +00:00
let addr = srv.addrs()[0];
2017-12-27 20:58:32 +00:00
let srv_addr = srv.start();
let _ = tx.send((addr, srv_addr));
2017-12-27 04:07:31 +00:00
sys.run();
});
2017-12-27 20:58:32 +00:00
let (addr, srv_addr) = rx.recv().unwrap();
2018-02-19 21:18:18 +00:00
let mut sys = System::new("test-server");
{
2018-04-13 23:02:01 +00:00
let req = client::ClientRequest::get(format!("http://{}/", addr).as_str())
.finish()
.unwrap();
2018-02-19 21:18:18 +00:00
let response = sys.run_until_complete(req.send()).unwrap();
assert!(response.status().is_success());
}
2017-12-27 20:58:32 +00:00
// pause
2018-02-13 06:56:47 +00:00
let _ = srv_addr.send(server::PauseServer).wait();
2018-04-07 02:45:14 +00:00
thread::sleep(time::Duration::from_millis(200));
2018-05-21 04:09:54 +00:00
{
let req = client::ClientRequest::get(format!("http://{}/", addr).as_str())
.timeout(time::Duration::from_millis(200))
.finish()
.unwrap();
assert!(sys.run_until_complete(req.send()).is_err());
}
2017-12-27 20:58:32 +00:00
// resume
2018-02-13 06:56:47 +00:00
let _ = srv_addr.send(server::ResumeServer).wait();
2018-05-21 23:12:33 +00:00
thread::sleep(time::Duration::from_millis(400));
2018-02-19 21:18:18 +00:00
{
2018-04-13 23:02:01 +00:00
let req = client::ClientRequest::get(format!("http://{}/", addr).as_str())
.finish()
.unwrap();
2018-02-19 21:18:18 +00:00
let response = sys.run_until_complete(req.send()).unwrap();
assert!(response.status().is_success());
}
2017-12-27 04:07:31 +00:00
}
2018-02-28 04:04:01 +00:00
#[test]
2018-03-04 02:50:00 +00:00
#[cfg(unix)]
2018-02-28 04:04:01 +00:00
fn test_shutdown() {
let _ = test::TestServer::unused_addr();
let (tx, rx) = mpsc::channel();
thread::spawn(move || {
let sys = System::new("test");
2018-04-13 23:02:01 +00:00
let srv = server::new(|| {
2018-04-29 05:55:47 +00:00
vec![App::new().resource("/", |r| {
r.method(http::Method::GET).f(|_| HttpResponse::Ok())
})]
2018-04-13 23:02:01 +00:00
});
2018-02-28 04:04:01 +00:00
let srv = srv.bind("127.0.0.1:0").unwrap();
let addr = srv.addrs()[0];
let srv_addr = srv.shutdown_timeout(1).start();
let _ = tx.send((addr, srv_addr));
sys.run();
});
let (addr, srv_addr) = rx.recv().unwrap();
let mut sys = System::new("test-server");
{
2018-04-13 23:02:01 +00:00
let req = client::ClientRequest::get(format!("http://{}/", addr).as_str())
.finish()
.unwrap();
2018-02-28 04:04:01 +00:00
let response = sys.run_until_complete(req.send()).unwrap();
2018-04-29 16:09:08 +00:00
srv_addr.do_send(server::StopServer { graceful: true });
2018-02-28 04:04:01 +00:00
assert!(response.status().is_success());
}
2018-03-02 19:32:37 +00:00
thread::sleep(time::Duration::from_millis(1000));
2018-02-28 04:04:01 +00:00
assert!(net::TcpStream::connect(addr).is_err());
}
#[test]
fn test_simple() {
let mut srv = test::TestServer::new(|app| app.handler(|_| HttpResponse::Ok()));
2018-02-19 21:18:18 +00:00
let req = srv.get().finish().unwrap();
let response = srv.execute(req.send()).unwrap();
assert!(response.status().is_success());
}
2017-10-23 00:33:24 +00:00
2018-02-28 04:49:53 +00:00
#[test]
fn test_headers() {
2018-03-05 01:54:58 +00:00
let data = STR.repeat(10);
let srv_data = Arc::new(data.clone());
2018-04-13 23:02:01 +00:00
let mut srv = test::TestServer::new(move |app| {
let data = srv_data.clone();
app.handler(move |_| {
let mut builder = HttpResponse::Ok();
for idx in 0..90 {
builder.header(
format!("X-TEST-{}", idx).as_str(),
"TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST ",
);
}
builder.body(data.as_ref())
})
});
2018-02-28 04:49:53 +00:00
let request = srv.get().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(data));
2018-02-28 04:49:53 +00:00
}
2018-01-11 05:47:30 +00:00
#[test]
fn test_body() {
2018-04-13 23:02:01 +00:00
let mut srv =
test::TestServer::new(|app| app.handler(|_| HttpResponse::Ok().body(STR)));
2018-02-19 21:18:18 +00:00
let request = srv.get().finish().unwrap();
let response = srv.execute(request.send()).unwrap();
assert!(response.status().is_success());
// read response
let bytes = srv.execute(response.body()).unwrap();
2018-01-11 06:42:26 +00:00
assert_eq!(bytes, Bytes::from_static(STR.as_ref()));
}
#[test]
fn test_body_gzip() {
2018-04-13 23:02:01 +00:00
let mut srv = test::TestServer::new(|app| {
app.handler(|_| {
2018-04-29 16:09:08 +00:00
HttpResponse::Ok()
.content_encoding(http::ContentEncoding::Gzip)
.body(STR)
2018-04-13 23:02:01 +00:00
})
});
2018-02-19 21:18:18 +00:00
2018-02-24 04:29:35 +00:00
let request = srv.get().disable_decompress().finish().unwrap();
2018-02-19 21:18:18 +00:00
let response = srv.execute(request.send()).unwrap();
assert!(response.status().is_success());
// read response
let bytes = srv.execute(response.body()).unwrap();
// decode
let mut e = GzDecoder::new(&bytes[..]);
let mut dec = Vec::new();
e.read_to_end(&mut dec).unwrap();
assert_eq!(Bytes::from(dec), Bytes::from_static(STR.as_ref()));
2018-01-11 05:47:30 +00:00
}
#[test]
fn test_body_gzip_large() {
2018-03-05 01:54:58 +00:00
let data = STR.repeat(10);
let srv_data = Arc::new(data.clone());
2018-04-13 23:02:01 +00:00
let mut srv = test::TestServer::new(move |app| {
let data = srv_data.clone();
app.handler(move |_| {
HttpResponse::Ok()
.content_encoding(http::ContentEncoding::Gzip)
.body(data.as_ref())
})
});
let request = srv.get().disable_decompress().finish().unwrap();
let response = srv.execute(request.send()).unwrap();
assert!(response.status().is_success());
// read response
let bytes = srv.execute(response.body()).unwrap();
// decode
let mut e = GzDecoder::new(&bytes[..]);
let mut dec = Vec::new();
e.read_to_end(&mut dec).unwrap();
assert_eq!(Bytes::from(dec), Bytes::from(data));
}
#[test]
fn test_body_gzip_large_random() {
2018-04-29 16:09:08 +00:00
let data = rand::thread_rng()
.gen_ascii_chars()
.take(70_000)
.collect::<String>();
let srv_data = Arc::new(data.clone());
2018-04-13 23:02:01 +00:00
let mut srv = test::TestServer::new(move |app| {
let data = srv_data.clone();
app.handler(move |_| {
HttpResponse::Ok()
.content_encoding(http::ContentEncoding::Gzip)
.body(data.as_ref())
})
});
let request = srv.get().disable_decompress().finish().unwrap();
let response = srv.execute(request.send()).unwrap();
assert!(response.status().is_success());
// read response
let bytes = srv.execute(response.body()).unwrap();
// decode
let mut e = GzDecoder::new(&bytes[..]);
let mut dec = Vec::new();
e.read_to_end(&mut dec).unwrap();
assert_eq!(dec.len(), data.len());
assert_eq!(Bytes::from(dec), Bytes::from(data));
}
2018-01-11 23:26:46 +00:00
#[test]
2018-02-24 04:29:35 +00:00
fn test_body_chunked_implicit() {
2018-04-13 23:02:01 +00:00
let mut srv = test::TestServer::new(|app| {
app.handler(|_| {
2018-01-11 23:26:46 +00:00
let body = once(Ok(Bytes::from_static(STR.as_ref())));
HttpResponse::Ok()
2018-03-31 00:31:18 +00:00
.content_encoding(http::ContentEncoding::Gzip)
2018-04-13 23:02:01 +00:00
.body(Body::Streaming(Box::new(body)))
})
});
2018-01-11 23:26:46 +00:00
2018-02-24 04:29:35 +00:00
let request = srv.get().disable_decompress().finish().unwrap();
2018-02-19 21:18:18 +00:00
let response = srv.execute(request.send()).unwrap();
assert!(response.status().is_success());
// read response
let bytes = srv.execute(response.body()).unwrap();
// decode
let mut e = GzDecoder::new(&bytes[..]);
let mut dec = Vec::new();
e.read_to_end(&mut dec).unwrap();
assert_eq!(Bytes::from(dec), Bytes::from_static(STR.as_ref()));
2018-01-11 23:26:46 +00:00
}
2018-04-13 23:02:01 +00:00
#[cfg(feature = "brotli")]
2018-01-12 00:22:27 +00:00
#[test]
fn test_body_br_streaming() {
2018-04-13 23:02:01 +00:00
let mut srv = test::TestServer::new(|app| {
app.handler(|_| {
2018-01-12 00:22:27 +00:00
let body = once(Ok(Bytes::from_static(STR.as_ref())));
HttpResponse::Ok()
2018-03-31 00:31:18 +00:00
.content_encoding(http::ContentEncoding::Br)
2018-04-13 23:02:01 +00:00
.body(Body::Streaming(Box::new(body)))
})
});
2018-01-12 00:22:27 +00:00
2018-02-24 04:29:35 +00:00
let request = srv.get().disable_decompress().finish().unwrap();
2018-02-19 21:18:18 +00:00
let response = srv.execute(request.send()).unwrap();
assert!(response.status().is_success());
// read response
let bytes = srv.execute(response.body()).unwrap();
2018-01-12 00:22:27 +00:00
2018-02-19 21:18:18 +00:00
// decode br
2018-01-12 00:22:27 +00:00
let mut e = BrotliDecoder::new(Vec::with_capacity(2048));
e.write_all(bytes.as_ref()).unwrap();
let dec = e.finish().unwrap();
assert_eq!(Bytes::from(dec), Bytes::from_static(STR.as_ref()));
}
2018-01-21 00:12:38 +00:00
#[test]
fn test_head_empty() {
2018-04-13 23:02:01 +00:00
let mut srv = test::TestServer::new(|app| {
2018-05-17 19:20:20 +00:00
app.handler(|_| HttpResponse::Ok().content_length(STR.len() as u64).finish())
2018-04-13 23:02:01 +00:00
});
2018-01-21 00:12:38 +00:00
2018-02-19 21:18:18 +00:00
let request = srv.head().finish().unwrap();
let response = srv.execute(request.send()).unwrap();
assert!(response.status().is_success());
{
2018-04-29 16:09:08 +00:00
let len = response
.headers()
.get(http::header::CONTENT_LENGTH)
.unwrap();
2018-02-19 21:18:18 +00:00
assert_eq!(format!("{}", STR.len()), len.to_str().unwrap());
}
// read response
//let bytes = srv.execute(response.body()).unwrap();
//assert!(bytes.is_empty());
2018-01-21 00:12:38 +00:00
}
#[test]
fn test_head_binary() {
2018-04-13 23:02:01 +00:00
let mut srv = test::TestServer::new(|app| {
app.handler(|_| {
HttpResponse::Ok()
2018-03-31 00:31:18 +00:00
.content_encoding(http::ContentEncoding::Identity)
2018-04-13 23:02:01 +00:00
.content_length(100)
.body(STR)
})
});
2018-01-21 00:12:38 +00:00
2018-02-19 21:18:18 +00:00
let request = srv.head().finish().unwrap();
let response = srv.execute(request.send()).unwrap();
assert!(response.status().is_success());
{
2018-04-29 16:09:08 +00:00
let len = response
.headers()
.get(http::header::CONTENT_LENGTH)
.unwrap();
2018-02-19 21:18:18 +00:00
assert_eq!(format!("{}", STR.len()), len.to_str().unwrap());
}
// read response
//let bytes = srv.execute(response.body()).unwrap();
//assert!(bytes.is_empty());
2018-01-21 00:12:38 +00:00
}
#[test]
fn test_head_binary2() {
2018-04-13 23:02:01 +00:00
let mut srv = test::TestServer::new(|app| {
app.handler(|_| {
HttpResponse::Ok()
2018-03-31 00:31:18 +00:00
.content_encoding(http::ContentEncoding::Identity)
2018-01-21 00:12:38 +00:00
.body(STR)
2018-04-13 23:02:01 +00:00
})
});
2018-01-21 00:12:38 +00:00
2018-02-19 21:18:18 +00:00
let request = srv.head().finish().unwrap();
let response = srv.execute(request.send()).unwrap();
assert!(response.status().is_success());
{
2018-04-29 16:09:08 +00:00
let len = response
.headers()
.get(http::header::CONTENT_LENGTH)
.unwrap();
2018-02-19 21:18:18 +00:00
assert_eq!(format!("{}", STR.len()), len.to_str().unwrap());
}
2018-01-21 00:12:38 +00:00
}
2018-01-12 00:22:27 +00:00
#[test]
fn test_body_length() {
2018-04-13 23:02:01 +00:00
let mut srv = test::TestServer::new(|app| {
app.handler(|_| {
2018-01-12 00:22:27 +00:00
let body = once(Ok(Bytes::from_static(STR.as_ref())));
HttpResponse::Ok()
2018-01-12 00:22:27 +00:00
.content_length(STR.len() as u64)
2018-03-31 00:31:18 +00:00
.content_encoding(http::ContentEncoding::Identity)
2018-04-13 23:02:01 +00:00
.body(Body::Streaming(Box::new(body)))
})
});
2018-01-12 00:22:27 +00:00
2018-02-19 21:18:18 +00:00
let request = srv.get().finish().unwrap();
let response = srv.execute(request.send()).unwrap();
assert!(response.status().is_success());
// read response
let bytes = srv.execute(response.body()).unwrap();
2018-01-12 00:22:27 +00:00
assert_eq!(bytes, Bytes::from_static(STR.as_ref()));
}
2018-01-11 23:26:46 +00:00
#[test]
2018-02-24 04:29:35 +00:00
fn test_body_chunked_explicit() {
2018-04-13 23:02:01 +00:00
let mut srv = test::TestServer::new(|app| {
app.handler(|_| {
2018-01-11 23:26:46 +00:00
let body = once(Ok(Bytes::from_static(STR.as_ref())));
HttpResponse::Ok()
2018-01-11 23:26:46 +00:00
.chunked()
2018-03-31 00:31:18 +00:00
.content_encoding(http::ContentEncoding::Gzip)
2018-04-13 23:02:01 +00:00
.body(Body::Streaming(Box::new(body)))
})
});
2018-01-11 23:26:46 +00:00
2018-02-24 04:29:35 +00:00
let request = srv.get().disable_decompress().finish().unwrap();
2018-02-19 21:18:18 +00:00
let response = srv.execute(request.send()).unwrap();
assert!(response.status().is_success());
// read response
let bytes = srv.execute(response.body()).unwrap();
// decode
let mut e = GzDecoder::new(&bytes[..]);
let mut dec = Vec::new();
e.read_to_end(&mut dec).unwrap();
assert_eq!(Bytes::from(dec), Bytes::from_static(STR.as_ref()));
2018-01-11 23:26:46 +00:00
}
2018-01-11 05:47:30 +00:00
#[test]
fn test_body_deflate() {
2018-04-13 23:02:01 +00:00
let mut srv = test::TestServer::new(|app| {
app.handler(|_| {
2018-04-29 16:09:08 +00:00
HttpResponse::Ok()
.content_encoding(http::ContentEncoding::Deflate)
.body(STR)
2018-04-13 23:02:01 +00:00
})
});
2018-01-11 06:42:26 +00:00
2018-02-19 21:18:18 +00:00
// client request
2018-02-24 04:29:35 +00:00
let request = srv.get().disable_decompress().finish().unwrap();
2018-02-19 21:18:18 +00:00
let response = srv.execute(request.send()).unwrap();
assert!(response.status().is_success());
// read response
let bytes = srv.execute(response.body()).unwrap();
// decode deflate
2018-01-11 06:42:26 +00:00
let mut e = DeflateDecoder::new(Vec::new());
e.write_all(bytes.as_ref()).unwrap();
let dec = e.finish().unwrap();
assert_eq!(Bytes::from(dec), Bytes::from_static(STR.as_ref()));
2018-01-11 05:47:30 +00:00
}
2018-04-13 23:02:01 +00:00
#[cfg(feature = "brotli")]
2018-01-11 05:47:30 +00:00
#[test]
fn test_body_brotli() {
2018-04-13 23:02:01 +00:00
let mut srv = test::TestServer::new(|app| {
app.handler(|_| {
2018-04-29 16:09:08 +00:00
HttpResponse::Ok()
.content_encoding(http::ContentEncoding::Br)
.body(STR)
2018-04-13 23:02:01 +00:00
})
});
2018-01-11 06:42:26 +00:00
2018-02-19 21:18:18 +00:00
// client request
2018-02-24 04:29:35 +00:00
let request = srv.get().disable_decompress().finish().unwrap();
2018-02-19 21:18:18 +00:00
let response = srv.execute(request.send()).unwrap();
assert!(response.status().is_success());
// read response
let bytes = srv.execute(response.body()).unwrap();
// decode brotli
2018-01-11 06:42:26 +00:00
let mut e = BrotliDecoder::new(Vec::with_capacity(2048));
e.write_all(bytes.as_ref()).unwrap();
let dec = e.finish().unwrap();
assert_eq!(Bytes::from(dec), Bytes::from_static(STR.as_ref()));
2018-01-11 05:47:30 +00:00
}
#[test]
fn test_gzip_encoding() {
2018-04-13 23:02:01 +00:00
let mut srv = test::TestServer::new(|app| {
app.handler(|req: HttpRequest| {
req.body()
.and_then(|bytes: Bytes| {
Ok(HttpResponse::Ok()
.content_encoding(http::ContentEncoding::Identity)
.body(bytes))
})
.responder()
})
});
2018-01-11 05:47:30 +00:00
2018-02-19 21:18:18 +00:00
// client request
2018-01-11 05:47:30 +00:00
let mut e = GzEncoder::new(Vec::new(), Compression::default());
e.write_all(STR.as_ref()).unwrap();
let enc = e.finish().unwrap();
2018-05-17 19:20:20 +00:00
let request = srv
.post()
2018-03-31 00:31:18 +00:00
.header(http::header::CONTENT_ENCODING, "gzip")
2018-04-13 23:02:01 +00:00
.body(enc.clone())
.unwrap();
2018-02-19 21:18:18 +00:00
let response = srv.execute(request.send()).unwrap();
assert!(response.status().is_success());
// read response
let bytes = srv.execute(response.body()).unwrap();
2018-01-11 05:47:30 +00:00
assert_eq!(bytes, Bytes::from_static(STR.as_ref()));
}
#[test]
fn test_gzip_encoding_large() {
2018-03-05 01:54:58 +00:00
let data = STR.repeat(10);
2018-04-13 23:02:01 +00:00
let mut srv = test::TestServer::new(|app| {
app.handler(|req: HttpRequest| {
req.body()
.and_then(|bytes: Bytes| {
Ok(HttpResponse::Ok()
.content_encoding(http::ContentEncoding::Identity)
.body(bytes))
})
.responder()
})
});
// client request
let mut e = GzEncoder::new(Vec::new(), Compression::default());
e.write_all(data.as_ref()).unwrap();
let enc = e.finish().unwrap();
2018-05-17 19:20:20 +00:00
let request = srv
.post()
2018-03-31 00:31:18 +00:00
.header(http::header::CONTENT_ENCODING, "gzip")
2018-04-13 23:02:01 +00:00
.body(enc.clone())
.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(data));
}
#[test]
2018-03-06 19:02:03 +00:00
fn test_reading_gzip_encoding_large_random() {
2018-04-29 16:09:08 +00:00
let data = rand::thread_rng()
.gen_ascii_chars()
.take(60_000)
.collect::<String>();
2018-04-13 23:02:01 +00:00
let mut srv = test::TestServer::new(|app| {
app.handler(|req: HttpRequest| {
req.body()
.and_then(|bytes: Bytes| {
Ok(HttpResponse::Ok()
.content_encoding(http::ContentEncoding::Identity)
.body(bytes))
})
.responder()
})
});
// client request
let mut e = GzEncoder::new(Vec::new(), Compression::default());
e.write_all(data.as_ref()).unwrap();
let enc = e.finish().unwrap();
2018-05-17 19:20:20 +00:00
let request = srv
.post()
2018-03-31 00:31:18 +00:00
.header(http::header::CONTENT_ENCODING, "gzip")
2018-04-13 23:02:01 +00:00
.body(enc.clone())
.unwrap();
let response = srv.execute(request.send()).unwrap();
assert!(response.status().is_success());
// read response
let bytes = srv.execute(response.body()).unwrap();
2018-03-06 19:02:03 +00:00
assert_eq!(bytes.len(), data.len());
assert_eq!(bytes, Bytes::from(data));
}
2018-01-11 05:47:30 +00:00
#[test]
2018-03-06 19:02:03 +00:00
fn test_reading_deflate_encoding() {
2018-04-13 23:02:01 +00:00
let mut srv = test::TestServer::new(|app| {
app.handler(|req: HttpRequest| {
req.body()
.and_then(|bytes: Bytes| {
Ok(HttpResponse::Ok()
.content_encoding(http::ContentEncoding::Identity)
.body(bytes))
})
.responder()
})
});
2018-01-11 05:47:30 +00:00
let mut e = DeflateEncoder::new(Vec::new(), Compression::default());
e.write_all(STR.as_ref()).unwrap();
let enc = e.finish().unwrap();
2018-02-19 21:18:18 +00:00
// client request
2018-05-17 19:20:20 +00:00
let request = srv
.post()
2018-04-29 16:09:08 +00:00
.header(http::header::CONTENT_ENCODING, "deflate")
.body(enc)
.unwrap();
2018-02-19 21:18:18 +00:00
let response = srv.execute(request.send()).unwrap();
assert!(response.status().is_success());
// read response
let bytes = srv.execute(response.body()).unwrap();
2018-01-11 05:47:30 +00:00
assert_eq!(bytes, Bytes::from_static(STR.as_ref()));
}
#[test]
2018-03-06 19:02:03 +00:00
fn test_reading_deflate_encoding_large() {
2018-03-05 01:54:58 +00:00
let data = STR.repeat(10);
2018-04-13 23:02:01 +00:00
let mut srv = test::TestServer::new(|app| {
app.handler(|req: HttpRequest| {
req.body()
.and_then(|bytes: Bytes| {
Ok(HttpResponse::Ok()
.content_encoding(http::ContentEncoding::Identity)
.body(bytes))
})
.responder()
})
});
let mut e = DeflateEncoder::new(Vec::new(), Compression::default());
e.write_all(data.as_ref()).unwrap();
let enc = e.finish().unwrap();
// client request
2018-05-17 19:20:20 +00:00
let request = srv
.post()
2018-04-29 16:09:08 +00:00
.header(http::header::CONTENT_ENCODING, "deflate")
.body(enc)
.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(data));
}
2018-03-06 19:02:03 +00:00
#[test]
fn test_reading_deflate_encoding_large_random() {
2018-04-29 16:09:08 +00:00
let data = rand::thread_rng()
.gen_ascii_chars()
.take(160_000)
.collect::<String>();
2018-03-06 19:02:03 +00:00
2018-04-13 23:02:01 +00:00
let mut srv = test::TestServer::new(|app| {
app.handler(|req: HttpRequest| {
req.body()
.and_then(|bytes: Bytes| {
Ok(HttpResponse::Ok()
.content_encoding(http::ContentEncoding::Identity)
.body(bytes))
})
.responder()
})
});
2018-03-06 19:02:03 +00:00
let mut e = DeflateEncoder::new(Vec::new(), Compression::default());
e.write_all(data.as_ref()).unwrap();
let enc = e.finish().unwrap();
// client request
2018-05-17 19:20:20 +00:00
let request = srv
.post()
2018-04-29 16:09:08 +00:00
.header(http::header::CONTENT_ENCODING, "deflate")
.body(enc)
.unwrap();
2018-03-06 19:02:03 +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.len(), data.len());
assert_eq!(bytes, Bytes::from(data));
}
2018-04-13 23:02:01 +00:00
#[cfg(feature = "brotli")]
2018-01-11 05:47:30 +00:00
#[test]
fn test_brotli_encoding() {
2018-04-13 23:02:01 +00:00
let mut srv = test::TestServer::new(|app| {
app.handler(|req: HttpRequest| {
req.body()
.and_then(|bytes: Bytes| {
Ok(HttpResponse::Ok()
.content_encoding(http::ContentEncoding::Identity)
.body(bytes))
})
.responder()
})
});
2018-01-11 05:47:30 +00:00
let mut e = BrotliEncoder::new(Vec::new(), 5);
e.write_all(STR.as_ref()).unwrap();
let enc = e.finish().unwrap();
2018-02-19 21:18:18 +00:00
// client request
2018-05-17 19:20:20 +00:00
let request = srv
.post()
2018-04-29 16:09:08 +00:00
.header(http::header::CONTENT_ENCODING, "br")
.body(enc)
.unwrap();
2018-02-19 21:18:18 +00:00
let response = srv.execute(request.send()).unwrap();
assert!(response.status().is_success());
// read response
let bytes = srv.execute(response.body()).unwrap();
2018-01-11 05:47:30 +00:00
assert_eq!(bytes, Bytes::from_static(STR.as_ref()));
}
2018-04-13 23:02:01 +00:00
#[cfg(feature = "brotli")]
#[test]
fn test_brotli_encoding_large() {
2018-03-05 01:54:58 +00:00
let data = STR.repeat(10);
2018-04-13 23:02:01 +00:00
let mut srv = test::TestServer::new(|app| {
app.handler(|req: HttpRequest| {
req.body()
.and_then(|bytes: Bytes| {
Ok(HttpResponse::Ok()
.content_encoding(http::ContentEncoding::Identity)
.body(bytes))
})
.responder()
})
});
let mut e = BrotliEncoder::new(Vec::new(), 5);
e.write_all(data.as_ref()).unwrap();
let enc = e.finish().unwrap();
// client request
2018-05-17 19:20:20 +00:00
let request = srv
.post()
2018-04-29 16:09:08 +00:00
.header(http::header::CONTENT_ENCODING, "br")
.body(enc)
.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(data));
}
2018-01-11 23:26:46 +00:00
#[test]
fn test_h2() {
2018-04-13 23:02:01 +00:00
let srv = test::TestServer::new(|app| app.handler(|_| HttpResponse::Ok().body(STR)));
2018-01-11 23:26:46 +00:00
let addr = srv.addr();
let mut core = Core::new().unwrap();
let handle = core.handle();
let tcp = TcpStream::connect(&addr, &handle);
2018-05-17 19:20:20 +00:00
let tcp = tcp
.then(|res| h2client::handshake(res.unwrap()))
2018-04-29 16:09:08 +00:00
.then(move |res| {
let (mut client, h2) = res.unwrap();
2018-01-11 23:26:46 +00:00
2018-04-29 16:09:08 +00:00
let request = Request::builder()
.uri(format!("https://{}/", addr).as_str())
.body(())
.unwrap();
let (response, _) = client.send_request(request, false).unwrap();
2018-01-11 23:26:46 +00:00
2018-04-29 16:09:08 +00:00
// Spawn a task to run the conn...
handle.spawn(h2.map_err(|e| println!("GOT ERR={:?}", e)));
2018-01-11 23:26:46 +00:00
2018-04-29 16:09:08 +00:00
response.and_then(|response| {
assert_eq!(response.status(), http::StatusCode::OK);
2018-01-11 23:26:46 +00:00
2018-04-29 16:09:08 +00:00
let (_, body) = response.into_parts();
2018-01-11 23:26:46 +00:00
2018-04-29 16:09:08 +00:00
body.fold(BytesMut::new(), |mut b, c| -> Result<_, h2::Error> {
b.extend(c);
Ok(b)
})
2018-01-11 23:26:46 +00:00
})
2018-04-29 16:09:08 +00:00
});
2018-03-20 19:35:44 +00:00
let _res = core.run(tcp);
2018-05-08 22:44:50 +00:00
// assert_eq!(_res.unwrap(), Bytes::from_static(STR.as_ref()));
2018-01-11 23:26:46 +00:00
}
#[test]
fn test_application() {
2018-04-13 23:02:01 +00:00
let mut srv = test::TestServer::with_factory(|| {
App::new().resource("/", |r| r.f(|_| HttpResponse::Ok()))
});
2018-02-19 21:18:18 +00:00
let request = srv.get().finish().unwrap();
let response = srv.execute(request.send()).unwrap();
assert!(response.status().is_success());
}