use std::task::{Context, Poll};
use std::{io, io::Read, io::Write, pin::Pin};
use flate2::Compression;
use flate2::read::GzDecoder;
use flate2::write::{GzEncoder, ZlibDecoder, ZlibEncoder};
use rand::{Rng, distr::Alphanumeric};
use ntex::http::header::{
ACCEPT_ENCODING, CONTENT_ENCODING, CONTENT_LENGTH, CONTENT_TYPE, ContentEncoding,
TRANSFER_ENCODING,
};
use ntex::http::{self, ConnectionType, HttpServiceConfig, Method, StatusCode, body::Body};
#[cfg(all(feature = "rustls", feature = "openssl"))]
use ntex::time::Millis;
use ntex::time::Seconds;
use ntex::util::{Bytes, Stream};
use ntex::{Service, SharedCfg, client, io::IoConfig, service::State};
use ntex::web::{self, middleware::Compress, test};
use ntex::web::{App, BodyEncoding, HttpResponse, WebResponseError};
#[cfg(feature = "rustls")]
mod rustls_utils;
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";
struct TestBody {
data: Bytes,
chunk_size: usize,
ready: bool,
}
impl TestBody {
fn new(data: Bytes, chunk_size: usize) -> Self {
TestBody {
data,
chunk_size,
ready: false,
}
}
}
impl Stream for TestBody {
type Item = Result<Bytes, io::Error>;
fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
if !self.ready {
self.ready = true;
cx.waker().wake_by_ref();
return Poll::Pending;
}
self.ready = false;
let chunk_size = std::cmp::min(self.chunk_size, self.data.len());
let chunk = self.data.split_to(chunk_size);
if chunk.is_empty() {
Poll::Ready(None)
} else {
Poll::Ready(Some(Ok(chunk)))
}
}
}
#[ntex::test]
async fn test_cached_service_binding_scopes() {
use std::cell::{Cell, RefCell};
use std::future::{Future, poll_fn};
use std::{convert::Infallible, rc::Rc, task::Waker};
use ntex::service::{BindCtx, Ctx, ReadyNotifier, fn_factory};
use ntex::web::WebRequest;
#[derive(Default)]
struct Gate {
available: Cell<bool>,
binds: Cell<usize>,
checks: Cell<usize>,
changed: ReadyNotifier,
waker: RefCell<Option<Waker>>,
}
struct Gated(Rc<Gate>);
impl Service<(), WebRequest<()>> for Gated {
type Res = WebRequest<()>;
type Error = Infallible;
fn bind(&self, ctx: BindCtx<'_>) {
self.0.binds.set(self.0.binds.get() + 1);
ctx.subscribe(&self.0.changed);
}
async fn ready(&self, _: Ctx<'_, Self>) -> Result<(), Infallible> {
self.0.checks.set(self.0.checks.get() + 1);
poll_fn(|cx| {
if self.0.available.get() {
Poll::Ready(Ok(()))
} else {
*self.0.waker.borrow_mut() = Some(cx.waker().clone());
Poll::Pending
}
})
.await
}
async fn call(
&self,
req: WebRequest<()>,
_: Ctx<'_, Self>,
) -> Result<WebRequest<()>, Infallible> {
Ok(req)
}
}
let gates: [_; 4] = std::array::from_fn(|_| {
Rc::new(Gate {
available: Cell::new(true),
..Gate::default()
})
});
let [filter, first, second, default] = &gates;
let factory = |gate: Rc<Gate>| {
ntex::factory(fn_factory(async move |(): &()| {
Ok::<_, Infallible>(Gated(gate.clone()))
}))
};
let handler =
|gate| factory(gate).map(|req: WebRequest<()>| req.into_response(HttpResponse::Ok()));
let srv = test::init_service(
App::new()
.filter(factory(filter.clone()))
.service(web::service("/one").build(handler(first.clone())))
.service(web::service("/two").build(handler(second.clone())))
.default_service(handler(default.clone())),
)
.await;
srv.ready().await.unwrap();
assert_eq!(filter.binds.get(), 1);
assert_eq!(
(first.binds.get(), second.binds.get(), default.binds.get()),
(0, 0, 0)
);
filter.available.set(false);
filter.changed.notify();
let mut cx = Context::from_waker(Waker::noop());
let mut ready = Box::pin(srv.ready());
assert!(ready.as_mut().poll(&mut cx).is_pending());
filter.available.set(true);
filter.changed.notify();
ready.await.unwrap();
for path in ["/one", "/two", "/missing"] {
let response = srv
.call(test::TestRequest::with_uri(path).to_request())
.await
.unwrap();
assert!(response.status().is_success());
}
srv.ready().await.unwrap();
for gate in &gates {
assert_eq!(gate.binds.get(), 1);
}
let filter_checks = filter.checks.get();
first.available.set(false);
first.changed.notify();
let mut ready = Box::pin(srv.ready());
assert!(ready.as_mut().poll(&mut cx).is_pending());
assert_eq!(filter.checks.get(), filter_checks);
assert_eq!((second.checks.get(), default.checks.get()), (1, 1));
first.available.set(true);
first.changed.notify();
ready.await.unwrap();
assert_eq!(filter.checks.get(), filter_checks);
assert_eq!((second.checks.get(), default.checks.get()), (1, 1));
let before = (first.checks.get(), second.checks.get());
first.changed.notify();
second.changed.notify();
srv.ready().await.unwrap();
assert_eq!(
(first.checks.get(), second.checks.get()),
(before.0 + 1, before.1 + 1)
);
for invalidated in [filter, second, default] {
first.available.set(false);
first.changed.notify();
let mut ready = Box::pin(srv.ready());
assert!(ready.as_mut().poll(&mut cx).is_pending());
invalidated.available.set(false);
invalidated.changed.notify();
first.available.set(true);
first.waker.borrow_mut().take().unwrap().wake();
assert!(ready.as_mut().poll(&mut cx).is_pending());
invalidated.available.set(true);
invalidated.changed.notify();
ready.await.unwrap();
}
default.available.set(false);
default.changed.notify();
let mut ready = Box::pin(srv.ready());
assert!(ready.as_mut().poll(&mut cx).is_pending());
srv.shutdown().await;
drop(ready);
}
#[ntex::test]
async fn test_body() {
let srv = test::server(async |_| {
App::new().service(web::resource("/").route(web::to(async || HttpResponse::Ok().body(STR))))
});
let response = srv.get("/").send().await.unwrap();
assert!(response.status().is_success());
let bytes = response.body().await.unwrap();
assert_eq!(bytes, Bytes::from_static(STR.as_ref()));
}
#[ntex::test]
async fn test_body_gzip() {
let srv = test::server_with(test::config().h1(), async |_| {
App::new()
.middleware(Compress::new(ContentEncoding::Gzip))
.service(web::resource("/").route(web::to(async || HttpResponse::Ok().body(STR))))
});
let response = srv
.get("/")
.no_decompress()
.header(ACCEPT_ENCODING, "gzip")
.send()
.await
.unwrap();
assert!(response.status().is_success());
let bytes = response.body().await.unwrap();
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()));
}
#[ntex::test]
async fn test_body_gzip2() {
let srv = test::server_with(test::config().h1(), async |_| {
App::new()
.middleware(Compress::new(ContentEncoding::Gzip))
.service(web::resource("/").route(web::to(async || {
HttpResponse::Ok().body(STR).into_body::<Body>()
})))
});
let response = srv
.get("/")
.no_decompress()
.header(ACCEPT_ENCODING, "gzip")
.send()
.await
.unwrap();
assert!(response.status().is_success());
let bytes = response.body().await.unwrap();
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()));
}
#[ntex::test]
async fn test_body_auto_skips_brotli() {
let srv = test::server_with(test::config().h1(), async |_| {
App::new()
.middleware(Compress::default())
.service(web::resource("/").route(web::to(async || HttpResponse::Ok().body(STR))))
});
let response = srv
.get("/")
.no_decompress()
.header(ACCEPT_ENCODING, "gzip, deflate, br, zstd")
.send()
.await
.unwrap();
assert!(response.status().is_success());
assert_eq!(response.headers().get(CONTENT_ENCODING).unwrap(), "zstd");
let bytes = response.body().await.unwrap();
assert_eq!(zstd::decode_all(&bytes[..]).unwrap(), STR.as_bytes());
let response = srv
.get("/")
.no_decompress()
.header(ACCEPT_ENCODING, "gzip, deflate, br")
.send()
.await
.unwrap();
assert!(response.status().is_success());
assert_eq!(response.headers().get(CONTENT_ENCODING).unwrap(), "gzip");
let bytes = response.body().await.unwrap();
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()));
}
#[ntex::test]
async fn test_body_zstd_large() {
let data: String = rand::rng()
.sample_iter(&Alphanumeric)
.take(1024 * 1024)
.map(char::from)
.collect();
let srv_data = data.clone();
let srv = test::server_with(test::config().h1(), async move |_| {
let data = srv_data.clone();
App::new()
.middleware(Compress::new(ContentEncoding::Zstd))
.service(
web::resource("/")
.route(web::to(async move || HttpResponse::Ok().body(data.clone()))),
)
});
let response = srv
.get("/")
.no_decompress()
.header(ACCEPT_ENCODING, "zstd")
.send()
.await
.unwrap();
assert!(response.status().is_success());
assert_eq!(response.headers().get(CONTENT_ENCODING).unwrap(), "zstd");
let bytes = response.body().limit(2 * 1024 * 1024).await.unwrap();
assert_eq!(zstd::decode_all(&bytes[..]).unwrap(), data.as_bytes());
}
#[ntex::test]
async fn test_zstd_encoding() {
let srv = test::server_with(test::config().h1(), async |_| {
App::new().service(web::resource("/").route(web::to(async move |body: Bytes| {
HttpResponse::Ok().body(body)
})))
});
for data in [
STR.to_string(),
rand::rng()
.sample_iter(&Alphanumeric)
.take(200_000)
.map(char::from)
.collect(),
] {
let enc = zstd::encode_all(data.as_bytes(), 0).unwrap();
let response = srv
.post("/")
.header(CONTENT_ENCODING, "zstd")
.send_body(enc)
.await
.unwrap();
assert!(response.status().is_success());
let bytes = response.body().await.unwrap();
assert_eq!(bytes, Bytes::from(data));
}
}
#[ntex::test]
async fn test_body_encoding_override() {
let srv = test::server_with(test::config().h1(), async |_| {
App::new()
.middleware(Compress::new(ContentEncoding::Gzip))
.service(web::resource("/").route(web::to(async || {
HttpResponse::Ok()
.encoding(ContentEncoding::Deflate)
.body(STR)
})))
.service(web::resource("/raw").route(web::to(async || {
let body = Body::Bytes(STR.into());
let mut response = HttpResponse::with_body(StatusCode::OK, body);
response.encoding(ContentEncoding::Deflate);
response
})))
});
let response = srv
.get("/")
.no_decompress()
.header(ACCEPT_ENCODING, "deflate")
.send()
.await
.unwrap();
assert!(response.status().is_success());
let bytes = response.body().await.unwrap();
let mut e = ZlibDecoder::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()));
let response = srv
.request(Method::GET, srv.url("/raw"))
.no_decompress()
.header(ACCEPT_ENCODING, "deflate")
.send()
.await
.unwrap();
assert!(response.status().is_success());
let bytes = response.body().await.unwrap();
let mut e = ZlibDecoder::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()));
}
#[ntex::test]
async fn test_body_gzip_large() {
let data = STR.repeat(10);
let srv_data = data.clone();
let srv = test::server_with(test::config().h1(), async move |_| {
let data = srv_data.clone();
App::new()
.middleware(Compress::new(ContentEncoding::Gzip))
.service(web::resource("/").route(web::to(async move || {
Ok::<_, io::Error>(HttpResponse::Ok().body(data.clone()))
})))
});
let response = srv
.get("/")
.no_decompress()
.header(ACCEPT_ENCODING, "gzip")
.send()
.await
.unwrap();
assert!(response.status().is_success());
let bytes = response.body().await.unwrap();
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));
}
#[ntex::test]
async fn test_body_gzip_large_random() {
let data = rand::rng()
.sample_iter(&Alphanumeric)
.take(70_000)
.map(char::from)
.collect::<String>();
let srv_data = data.clone();
let srv = test::server_with(test::config().h1(), async move |_| {
let data = srv_data.clone();
App::new()
.middleware(Compress::new(ContentEncoding::Gzip))
.service(web::resource("/").route(web::to(async move || {
Ok::<_, io::Error>(HttpResponse::Ok().body(data.clone()))
})))
});
let response = srv
.get("/")
.no_decompress()
.header(ACCEPT_ENCODING, "gzip")
.send()
.await
.unwrap();
assert!(response.status().is_success());
let bytes = response.body().await.unwrap();
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));
}
#[ntex::test]
async fn test_body_chunked_implicit() {
let srv = test::server_with(test::config().h1(), async |_| {
App::new()
.middleware(Compress::new(ContentEncoding::Gzip))
.service(web::resource("/").route(web::get().to(async move || {
HttpResponse::Ok().streaming(TestBody::new(Bytes::from_static(STR.as_ref()), 24))
})))
});
let response = srv
.get("/")
.no_decompress()
.header(ACCEPT_ENCODING, "gzip")
.send()
.await
.unwrap();
assert!(response.status().is_success());
assert_eq!(
response.headers().get(TRANSFER_ENCODING).unwrap(),
&b"chunked"[..]
);
let bytes = response.body().await.unwrap();
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()));
}
#[ntex::test]
async fn test_head_binary() {
let srv =
test::server_with(test::config().h1(), async |_| {
App::new().service(web::resource("/").route(
web::head().to(async move || HttpResponse::Ok().content_length(100).body(STR)),
))
});
let response = srv.head("/").send().await.unwrap();
assert!(response.status().is_success());
{
let len = response.headers().get(CONTENT_LENGTH).unwrap();
assert_eq!(format!("{}", STR.len()), len.to_str().unwrap());
}
let bytes = response.body().await.unwrap();
assert!(bytes.is_empty());
}
#[ntex::test]
async fn test_no_chunking() {
let srv = test::server_with(test::config().h1(), async |_| {
App::new().service(web::resource("/").route(web::to(async move || {
HttpResponse::Ok()
.no_chunking()
.content_length(STR.len() as u64)
.streaming(TestBody::new(Bytes::from_static(STR.as_ref()), 24))
})))
});
let response = srv.get("/").send().await.unwrap();
assert!(response.status().is_success());
assert!(!response.headers().contains_key(TRANSFER_ENCODING));
let bytes = response.body().await.unwrap();
assert_eq!(bytes, Bytes::from_static(STR.as_ref()));
}
#[ntex::test]
async fn test_body_deflate() {
let srv = test::server_with(test::config().h1(), async |_| {
App::new()
.middleware(Compress::new(ContentEncoding::Deflate))
.service(web::resource("/").route(web::to(async move || HttpResponse::Ok().body(STR))))
});
let response = srv
.get("/")
.header(ACCEPT_ENCODING, "deflate")
.no_decompress()
.send()
.await
.unwrap();
assert!(response.status().is_success());
let bytes = response.body().await.unwrap();
let mut e = ZlibDecoder::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()));
}
#[ntex::test]
async fn test_encoding() {
let srv = test::server_with(test::config().h1(), async |_| {
App::new()
.middleware(Compress::default())
.service(web::resource("/").route(web::to(async move |body: Bytes| {
HttpResponse::Ok().body(body)
})))
});
let mut e = GzEncoder::new(Vec::new(), Compression::default());
e.write_all(STR.as_ref()).unwrap();
let enc = e.finish().unwrap();
let request = srv
.post("/")
.header(CONTENT_ENCODING, "gzip")
.send_body(enc.clone());
let response = request.await.unwrap();
assert!(response.status().is_success());
let bytes = response.body().await.unwrap();
assert_eq!(bytes, Bytes::from_static(STR.as_ref()));
}
#[ntex::test]
async fn test_gzip_encoding() {
let srv = test::server_with(test::config().h1(), async |_| {
App::new().service(web::resource("/").route(web::to(async move |body: Bytes| {
HttpResponse::Ok().body(body)
})))
});
let mut e = GzEncoder::new(Vec::new(), Compression::default());
e.write_all(STR.as_ref()).unwrap();
let enc = e.finish().unwrap();
let request = srv
.post("/")
.header(CONTENT_ENCODING, "gzip")
.send_body(enc.clone());
let response = request.await.unwrap();
assert!(response.status().is_success());
let bytes = response.body().await.unwrap();
assert_eq!(bytes, Bytes::from_static(STR.as_ref()));
}
#[ntex::test]
async fn test_gzip_encoding_large() {
let data = STR.repeat(10);
let srv = test::server_with(test::config().h1(), async |_| {
App::new().service(web::resource("/").route(web::to(async move |body: Bytes| {
HttpResponse::Ok().body(body)
})))
});
let mut e = GzEncoder::new(Vec::new(), Compression::default());
e.write_all(data.as_ref()).unwrap();
let enc = e.finish().unwrap();
let request = srv
.post("/")
.header(CONTENT_ENCODING, "gzip")
.send_body(enc.clone());
let response = request.await.unwrap();
assert!(response.status().is_success());
let bytes = response.body().await.unwrap();
assert_eq!(bytes, Bytes::from(data));
}
#[ntex::test]
async fn test_reading_gzip_encoding_large_random() {
let data = rand::rng()
.sample_iter(&Alphanumeric)
.take(60_000)
.map(char::from)
.collect::<String>();
let srv = test::server_with(test::config().h1(), async |_| {
App::new().service(web::resource("/").route(web::to(async move |body: Bytes| {
HttpResponse::Ok().body(body)
})))
});
let mut e = GzEncoder::new(Vec::new(), Compression::default());
e.write_all(data.as_ref()).unwrap();
let enc = e.finish().unwrap();
let request = srv
.post("/")
.header(CONTENT_ENCODING, "gzip")
.send_body(enc.clone());
let response = request.await.unwrap();
assert!(response.status().is_success());
let bytes = response.body().await.unwrap();
assert_eq!(bytes.len(), data.len());
assert_eq!(bytes, Bytes::from(data));
}
#[ntex::test]
async fn test_reading_deflate_encoding() {
let srv = test::server_with(test::config().h1(), async |_| {
App::new().service(web::resource("/").route(web::to(async move |body: Bytes| {
HttpResponse::Ok().body(body)
})))
});
let mut e = ZlibEncoder::new(Vec::new(), Compression::default());
e.write_all(STR.as_ref()).unwrap();
let enc = e.finish().unwrap();
let request = srv
.post("/")
.header(CONTENT_ENCODING, "deflate")
.send_body(enc.clone());
let response = request.await.unwrap();
assert!(response.status().is_success());
let bytes = response.body().await.unwrap();
assert_eq!(bytes, Bytes::from_static(STR.as_ref()));
}
#[ntex::test]
async fn test_reading_deflate_encoding_large() {
let data = STR.repeat(10);
let srv = test::server_with(test::config().h1(), async |_| {
App::new().service(web::resource("/").route(web::to(async move |body: Bytes| {
HttpResponse::Ok().body(body)
})))
});
let mut e = ZlibEncoder::new(Vec::new(), Compression::default());
e.write_all(data.as_ref()).unwrap();
let enc = e.finish().unwrap();
let request = srv
.post("/")
.header(CONTENT_ENCODING, "deflate")
.send_body(enc.clone());
let response = request.await.unwrap();
assert!(response.status().is_success());
let bytes = response.body().await.unwrap();
assert_eq!(bytes, Bytes::from(data));
}
#[ntex::test]
async fn test_reading_deflate_encoding_large_random() {
let data = rand::rng()
.sample_iter(&Alphanumeric)
.take(160_000)
.map(char::from)
.collect::<String>();
let srv = test::server_with(test::config().h1(), async |_| {
App::new().service(web::resource("/").route(web::to(async move |body: Bytes| {
HttpResponse::Ok().body(body)
})))
});
let mut e = ZlibEncoder::new(Vec::new(), Compression::default());
e.write_all(data.as_ref()).unwrap();
let enc = e.finish().unwrap();
let request = srv
.post("/")
.header(CONTENT_ENCODING, "deflate")
.send_body(enc.clone());
let response = request.await.unwrap();
assert!(response.status().is_success());
let bytes = response.body().await.unwrap();
assert_eq!(bytes.len(), data.len());
assert_eq!(bytes, Bytes::from(data));
}
#[cfg(all(feature = "rustls", feature = "openssl"))]
#[ntex::test]
async fn test_reading_deflate_encoding_large_random_rustls() {
let data = rand::rng()
.sample_iter(&Alphanumeric)
.take(160_000)
.map(char::from)
.collect::<String>();
let srv = test::server_with(
test::config().rustls(rustls_utils::tls_acceptor()),
async |_| {
App::new().service(web::resource("/").route(web::to(async |bytes: Bytes| {
HttpResponse::Ok()
.encoding(ContentEncoding::Identity)
.body(bytes)
})))
},
);
let mut e = ZlibEncoder::new(Vec::new(), Compression::default());
e.write_all(data.as_ref()).unwrap();
let enc = e.finish().unwrap();
let req = srv
.post("/")
.timeout(Millis(30_000))
.header(CONTENT_ENCODING, "deflate")
.send_stream(TestBody::new(Bytes::from(enc), 16 * 1024));
let response = req.await.unwrap();
assert!(response.status().is_success());
let bytes = response.body().await.unwrap();
assert_eq!(bytes.len(), data.len());
assert_eq!(bytes, Bytes::from(data));
}
#[cfg(all(feature = "rustls", feature = "openssl"))]
#[ntex::test]
async fn test_reading_deflate_encoding_large_random_rustls_h1() {
let data = rand::rng()
.sample_iter(&Alphanumeric)
.take(160_000)
.map(char::from)
.collect::<String>();
let srv = test::server_with(
test::config().rustls(rustls_utils::tls_acceptor()).h1(),
async |_| {
App::new().service(web::resource("/").route(web::to(async |bytes: Bytes| {
HttpResponse::Ok()
.encoding(ContentEncoding::Identity)
.body(bytes)
})))
},
);
let mut e = ZlibEncoder::new(Vec::new(), Compression::default());
e.write_all(data.as_ref()).unwrap();
let enc = e.finish().unwrap();
let req = srv
.post("/")
.timeout(Millis(30_000))
.header(CONTENT_ENCODING, "deflate")
.send_stream(TestBody::new(Bytes::from(enc), 16 * 1024));
let response = req.await.unwrap();
assert!(response.status().is_success());
let bytes = response.body().await.unwrap();
assert_eq!(bytes.len(), data.len());
assert_eq!(bytes, Bytes::from(data));
}
#[cfg(all(feature = "rustls", feature = "openssl"))]
#[ntex::test]
async fn test_reading_deflate_encoding_large_random_rustls_h2() {
let data = rand::rng()
.sample_iter(&Alphanumeric)
.take(160_000)
.map(char::from)
.collect::<String>();
let srv = test::server_with(
test::config().rustls(rustls_utils::tls_acceptor()).h2(),
async |_| {
App::new().service(web::resource("/").route(web::to(async |bytes: Bytes| {
HttpResponse::Ok()
.encoding(ContentEncoding::Identity)
.body(bytes)
})))
},
);
let mut e = ZlibEncoder::new(Vec::new(), Compression::default());
e.write_all(data.as_ref()).unwrap();
let enc = e.finish().unwrap();
let req = srv
.post("/")
.timeout(Millis(30_000))
.header(CONTENT_ENCODING, "deflate")
.send_stream(TestBody::new(Bytes::from(enc), 16 * 1024));
let response = req.await.unwrap();
assert!(response.status().is_success());
let bytes = response.body().await.unwrap();
assert_eq!(bytes.len(), data.len());
assert_eq!(bytes, Bytes::from(data));
}
#[ntex::test]
async fn test_server_cookies() {
use ntex::http::HttpMessage;
use ntex::http::header::SET_COOKIE;
let srv = test::server(async |_| {
App::new().service(web::resource("/").to(async || {
HttpResponse::Ok()
.cookie(coo_kie::Cookie::build(("first", "first_value")).http_only(true))
.cookie(coo_kie::Cookie::new("second", "first_value"))
.cookie(coo_kie::Cookie::new("second", "second_value"))
.build()
}))
});
let first_cookie = coo_kie::Cookie::build(("first", "first_value")).http_only(true);
let second_cookie = coo_kie::Cookie::new("second", "second_value");
let response = srv.get("/").send().await.unwrap();
assert!(response.status().is_success());
let cookies = response.cookies().expect("To have cookies");
assert_eq!(cookies.len(), 2);
if cookies[0] == first_cookie {
assert_eq!(cookies[1], second_cookie);
} else {
assert_eq!(cookies[0], second_cookie);
assert_eq!(cookies[1], first_cookie);
}
let first_cookie = first_cookie.to_string();
let second_cookie = second_cookie.to_string();
let cookies = response
.headers()
.get_all(SET_COOKIE)
.map(|header| header.to_str().expect("To str").to_string())
.collect::<Vec<_>>();
assert_eq!(cookies.len(), 2);
if cookies[0] == first_cookie {
assert_eq!(cookies[1], second_cookie);
} else {
assert_eq!(cookies[0], second_cookie);
assert_eq!(cookies[1], first_cookie);
}
}
#[ntex::test]
async fn test_slow_request() {
use std::net;
let srv = test::server_with(test::config().client_timeout(Seconds(1)), async |_| {
App::new().service(web::resource("/").route(web::to(async || HttpResponse::Ok())))
});
let addr = srv.addr();
let no_request = std::thread::spawn(move || {
let mut stream = net::TcpStream::connect(addr).unwrap();
let mut data = String::new();
let _ = stream.read_to_string(&mut data);
data
});
let partial_head = std::thread::spawn(move || {
let mut stream = net::TcpStream::connect(addr).unwrap();
let _ = stream.write_all(b"GET /test/tests/test HTTP/1.1\r\nhost: localhost\r\n");
let mut data = String::new();
let _ = stream.read_to_string(&mut data);
data
});
let data = no_request.join().unwrap();
assert!(data.starts_with("HTTP/1.1 408 Request Timeout"), "{data:?}");
let data = partial_head.join().unwrap();
assert!(data.starts_with("HTTP/1.1 408 Request Timeout"), "{data:?}");
}
#[ntex::test]
async fn test_custom_error() {
#[derive(Debug, thiserror::Error)]
#[error("TestError")]
struct TestError;
#[derive(Debug, thiserror::Error)]
#[error("JsonContainer")]
struct JsonContainer;
#[derive(Copy, Clone, Default)]
struct TestAppState;
impl web::State for TestAppState {
type Error = JsonContainer;
}
impl ntex::http::ResponseError for JsonContainer {}
impl<St> WebResponseError<St, JsonContainer> for TestError {
fn error_response(&self, _: &St) -> HttpResponse {
HttpResponse::BadRequest()
.header(CONTENT_TYPE, "application/json")
.body("Error")
}
}
async fn test() -> Result<HttpResponse, TestError> {
Ok(HttpResponse::Ok().body(STR))
}
async fn test_err() -> Result<HttpResponse, TestError> {
Err(TestError)
}
let srv = http::test::server(async |_| {
ntex::fn_service(async |req| {
Ok(State {
req,
state: TestAppState,
})
})
.and_then(http::HttpService::new(
App::new()
.service(web::resource("/").route(web::get().to(test)))
.service(web::resource("/err").route(web::get().to(test_err))),
))
});
let response = srv.request(Method::GET, "/").send().await.unwrap();
assert!(response.status().is_success());
let len = response.headers().get(CONTENT_LENGTH).unwrap();
assert_eq!(format!("{}", STR.len()), len.to_str().unwrap());
let bytes = response.body().await.unwrap();
assert_eq!(bytes, Bytes::from_static(STR.as_ref()));
let response = srv.request(Method::GET, "/err").send().await.unwrap();
assert_eq!(response.status(), StatusCode::BAD_REQUEST);
let tp = response.headers().get(CONTENT_TYPE).unwrap();
assert_eq!("application/json", tp.to_str().unwrap());
}
#[ntex::test]
async fn test_web_server() {
let (tx, rx) = std::sync::mpsc::channel();
std::thread::spawn(move || {
let sys = ntex::rt::System::new("test-server", ntex::rt::DefaultRuntime);
let tcp = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
let local_addr = tcp.local_addr().unwrap();
let _ = sys.block_on(async move {
tx.send((ntex::rt::System::current(), local_addr)).unwrap();
web::server(async |_| {
App::new().service(
web::resource("/").route(web::to(async || HttpResponse::Ok().body(STR))),
)
})
.listen(
tcp,
SharedCfg::new("TEST")
.add(IoConfig::new().set_shutdown_timeout(Seconds(1)))
.add(
HttpServiceConfig::new()
.set_headers_read_rate(Seconds(1), Seconds(5), 128)
.set_payload_read_rate(Seconds(1), Seconds(5), 128),
),
)
.unwrap()
.run()
.await
});
});
let (system, addr) = rx.recv().unwrap();
let client =
client::Client::with_config(client::ClientConfig::new().set_response_timeout(Seconds(30)));
let response = client
.request(Method::GET, format!("http://{addr:?}/"))
.send()
.await
.unwrap();
assert!(response.status().is_success());
system.stop();
}
#[ntex::test]
async fn web_no_ws_with_response_payload() {
let srv = test::server_with(test::config().h1(), async |_| {
App::new()
.service(web::resource("/").route(web::get().to(async move || {
HttpResponse::Ok().streaming(TestBody::new(Bytes::from_static(STR.as_ref()), 24))
})))
.service(
web::resource("/f")
.route(web::get().to(async move || HttpResponse::Ok().body(STR))),
)
});
let client =
client::Client::with_config(client::ClientConfig::new().set_response_timeout(Seconds(30)));
let response = client
.request(Method::GET, format!("http://{:?}/f", srv.addr()))
.header("sec-websocket-version", "13")
.header("upgrade", "websocket")
.header("sec-websocket-key", "ld75/p3D5ju5UhWsNMcJHA==")
.set_connection_type(ConnectionType::Upgrade)
.send()
.await
.unwrap();
let body = response.body().await.unwrap();
assert_eq!(body, STR);
let response = client
.request(Method::GET, format!("http://{:?}/", srv.addr()))
.header("sec-websocket-version", "13")
.header("upgrade", "websocket")
.header("sec-websocket-key", "ld75/p3D5ju5UhWsNMcJHA==")
.set_connection_type(ConnectionType::Upgrade)
.send()
.await
.unwrap();
let body = response.body().await.unwrap();
assert_eq!(body, STR);
}
#[ntex::test]
async fn test_request_state() {
use ntex::{BindCtx, Ctx, Middleware, Service, web::WebRequest, web::WebResponse};
use std::convert::Infallible;
struct UsizeMw;
struct UsizeMwS<S>(S);
impl<S, St> Middleware<S, St> for UsizeMw {
type Service = UsizeMwS<S>;
fn create(&self, _: &St, s: S) -> Self::Service {
UsizeMwS(s)
}
}
impl<S, St> Service<St, WebRequest<()>> for UsizeMwS<S>
where
S: Service<St, WebRequest<usize>, Res = WebResponse>,
{
type Res = WebResponse;
type Error = S::Error;
#[inline]
fn bind(&self, ctx: BindCtx<'_>) {
ctx.bind(&self.0);
}
async fn call(
&self,
req: WebRequest<()>,
ctx: Ctx<'_, Self, St>,
) -> Result<Self::Res, Self::Error> {
let req = req.map_state(|()| 100);
ctx.call(&self.0, req).await
}
}
async fn test(_: &(), st: usize) -> Result<HttpResponse, Infallible> {
assert_eq!(st, 10);
Ok(HttpResponse::Ok().body(STR))
}
let srv = http::test::server(async |_| {
http::HttpService::new(
App::new()
.middleware(UsizeMw)
.filter(async |mut req: WebRequest<usize>| {
assert_eq!(*req.st(), 100);
*req.st_mut() = 10;
Ok::<_, Infallible>(req)
})
.service(
web::resource("/")
.filter(async |req: WebRequest<usize>| {
assert_eq!(*req.st(), 10);
Ok::<_, Infallible>(req)
})
.route(web::get().to_with_state(test)),
),
)
});
let response = srv.request(Method::GET, "/").send().await.unwrap();
assert!(response.status().is_success());
}