1
0
mirror of https://github.com/fafhrd91/actix-web synced 2024-12-02 19:32:24 +01:00
actix-web/awc/tests/test_client.rs

858 lines
24 KiB
Rust
Raw Normal View History

use std::{
collections::HashMap,
2022-01-03 19:46:04 +01:00
convert::Infallible,
io::{Read, Write},
net::{IpAddr, Ipv4Addr},
sync::{
atomic::{AtomicUsize, Ordering},
Arc,
},
time::Duration,
};
2019-03-27 04:45:00 +01:00
2021-04-01 16:26:13 +02:00
use actix_utils::future::ok;
2019-03-27 04:45:00 +01:00
use bytes::Bytes;
use cookie::Cookie;
2021-04-01 16:26:13 +02:00
use futures_util::stream;
2019-03-27 04:45:00 +01:00
use rand::Rng;
2022-01-03 19:46:04 +01:00
use actix_http::{HttpService, StatusCode};
2019-12-12 18:08:38 +01:00
use actix_http_test::test_server;
2021-04-16 21:28:21 +02:00
use actix_service::{fn_service, map_config, ServiceFactoryExt as _};
2022-01-03 19:46:04 +01:00
use actix_web::{dev::AppConfig, http::header, web, App, Error, HttpRequest, HttpResponse};
2021-02-17 12:55:11 +01:00
use awc::error::{JsonPayloadError, PayloadError, SendRequestError};
2019-03-27 04:45:00 +01:00
2022-01-03 19:46:04 +01:00
mod utils;
const S: &str = "Hello World ";
const STR: &str = const_str::repeat!(S, 100);
2019-03-27 04:45:00 +01:00
2019-11-26 06:25:50 +01:00
#[actix_rt::test]
async fn test_simple() {
let srv = actix_test::start(|| {
2021-02-12 00:03:17 +01:00
App::new().service(web::resource("/").route(web::to(|| HttpResponse::Ok().body(STR))))
2019-12-12 18:08:38 +01:00
});
2019-03-27 04:45:00 +01:00
2021-01-15 03:11:10 +01:00
let request = srv.get("/").insert_header(("x-test", "111")).send();
2019-11-26 06:25:50 +01:00
let mut response = request.await.unwrap();
assert!(response.status().is_success());
2019-03-27 04:45:00 +01:00
2019-11-26 06:25:50 +01:00
// read response
let bytes = response.body().await.unwrap();
assert_eq!(bytes, Bytes::from_static(STR.as_ref()));
2019-03-27 04:45:00 +01:00
2019-11-26 06:25:50 +01:00
let mut response = srv.post("/").send().await.unwrap();
assert!(response.status().is_success());
2019-03-27 04:45:00 +01:00
2019-11-26 06:25:50 +01:00
// read response
let bytes = response.body().await.unwrap();
assert_eq!(bytes, Bytes::from_static(STR.as_ref()));
2019-11-26 06:25:50 +01:00
// camel case
let response = srv.post("/").camel_case().send().await.unwrap();
assert!(response.status().is_success());
2019-03-27 04:45:00 +01:00
}
2019-11-26 06:25:50 +01:00
#[actix_rt::test]
async fn test_json() {
let srv = actix_test::start(|| {
2019-12-12 18:08:38 +01:00
App::new().service(
2019-11-26 06:25:50 +01:00
web::resource("/").route(web::to(|_: web::Json<String>| HttpResponse::Ok())),
2019-12-12 18:08:38 +01:00
)
2019-11-26 06:25:50 +01:00
});
let request = srv
.get("/")
2021-01-15 03:11:10 +01:00
.insert_header(("x-test", "111"))
2019-11-26 06:25:50 +01:00
.send_json(&"TEST".to_string());
let response = request.await.unwrap();
assert!(response.status().is_success());
2019-04-19 06:28:23 +02:00
}
2019-11-26 06:25:50 +01:00
#[actix_rt::test]
async fn test_form() {
let srv = actix_test::start(|| {
2019-12-12 18:08:38 +01:00
App::new().service(web::resource("/").route(web::to(
2019-11-26 06:25:50 +01:00
|_: web::Form<HashMap<String, String>>| HttpResponse::Ok(),
2019-12-12 18:08:38 +01:00
)))
2019-11-26 06:25:50 +01:00
});
2019-11-20 18:33:22 +01:00
2019-11-26 06:25:50 +01:00
let mut data = HashMap::new();
let _ = data.insert("key".to_string(), "TEST".to_string());
2019-11-20 18:33:22 +01:00
2021-01-15 03:11:10 +01:00
let request = srv
.get("/")
.append_header(("x-test", "111"))
.send_form(&data);
2019-11-26 06:25:50 +01:00
let response = request.await.unwrap();
assert!(response.status().is_success());
2019-04-19 06:28:23 +02:00
}
2019-11-26 06:25:50 +01:00
#[actix_rt::test]
async fn test_timeout() {
let srv = actix_test::start(|| {
2020-03-08 08:42:45 +01:00
App::new().service(web::resource("/").route(web::to(|| async {
actix_rt::time::sleep(Duration::from_millis(200)).await;
2020-03-08 08:42:45 +01:00
Ok::<_, Error>(HttpResponse::Ok().body(STR))
2019-12-12 18:08:38 +01:00
})))
2019-11-26 06:25:50 +01:00
});
let connector = awc::Connector::new()
2021-11-30 15:12:04 +01:00
.connector(actix_tls::connect::ConnectorService::default())
2021-02-18 13:30:09 +01:00
.timeout(Duration::from_secs(15));
2019-11-26 06:25:50 +01:00
let client = awc::Client::builder()
2019-11-26 06:25:50 +01:00
.connector(connector)
.timeout(Duration::from_millis(50))
.finish();
let request = client.get(srv.url("/")).send();
match request.await {
2021-01-04 02:01:35 +01:00
Err(SendRequestError::Timeout) => {}
2019-11-26 06:25:50 +01:00
_ => panic!(),
}
2019-03-29 06:33:41 +01:00
}
2019-11-26 06:25:50 +01:00
#[actix_rt::test]
async fn test_timeout_override() {
let srv = actix_test::start(|| {
2020-03-08 08:42:45 +01:00
App::new().service(web::resource("/").route(web::to(|| async {
actix_rt::time::sleep(Duration::from_millis(200)).await;
2020-03-08 08:42:45 +01:00
Ok::<_, Error>(HttpResponse::Ok().body(STR))
2019-12-12 18:08:38 +01:00
})))
2019-11-26 06:25:50 +01:00
});
let client = awc::Client::builder()
2019-11-26 06:25:50 +01:00
.timeout(Duration::from_millis(50000))
.finish();
let request = client
.get(srv.url("/"))
.timeout(Duration::from_millis(50))
.send();
match request.await {
2021-01-04 02:01:35 +01:00
Err(SendRequestError::Timeout) => {}
2019-11-26 06:25:50 +01:00
_ => panic!(),
}
2019-03-29 22:07:37 +01:00
}
2021-02-17 12:55:11 +01:00
#[actix_rt::test]
async fn test_response_timeout() {
2021-04-01 16:26:13 +02:00
use futures_util::stream::{once, StreamExt as _};
2021-02-17 12:55:11 +01:00
let srv = actix_test::start(|| {
2021-02-17 12:55:11 +01:00
App::new().service(web::resource("/").route(web::to(|| async {
Ok::<_, Error>(
HttpResponse::Ok()
.content_type("application/json")
.streaming(Box::pin(once(async {
actix_rt::time::sleep(Duration::from_millis(200)).await;
Ok::<_, Error>(Bytes::from(STR))
}))),
)
})))
});
let client = awc::Client::new();
let res = client
.get(srv.url("/"))
.send()
.await
.unwrap()
.timeout(Duration::from_millis(500))
.body()
.await
.unwrap();
assert_eq!(std::str::from_utf8(res.as_ref()).unwrap(), STR);
let res = client
.get(srv.url("/"))
.send()
.await
.unwrap()
.timeout(Duration::from_millis(100))
.next()
.await
.unwrap();
match res {
Err(PayloadError::Io(e)) => assert_eq!(e.kind(), std::io::ErrorKind::TimedOut),
_ => panic!("Response error type is not matched"),
}
let res = client
.get(srv.url("/"))
.send()
.await
.unwrap()
.timeout(Duration::from_millis(100))
.body()
.await;
match res {
Err(PayloadError::Io(e)) => assert_eq!(e.kind(), std::io::ErrorKind::TimedOut),
_ => panic!("Response error type is not matched"),
}
let res = client
.get(srv.url("/"))
.send()
.await
.unwrap()
.timeout(Duration::from_millis(100))
.json::<HashMap<String, String>>()
.await;
match res {
Err(JsonPayloadError::Payload(PayloadError::Io(e))) => {
assert_eq!(e.kind(), std::io::ErrorKind::TimedOut)
}
_ => panic!("Response error type is not matched"),
}
}
2019-11-26 06:25:50 +01:00
#[actix_rt::test]
async fn test_connection_reuse() {
let num = Arc::new(AtomicUsize::new(0));
let num2 = num.clone();
2019-12-12 18:08:38 +01:00
let srv = test_server(move || {
2019-11-26 06:25:50 +01:00
let num2 = num2.clone();
2021-04-16 21:28:21 +02:00
fn_service(move |io| {
2019-11-26 06:25:50 +01:00
num2.fetch_add(1, Ordering::Relaxed);
ok(io)
})
2019-12-02 12:33:11 +01:00
.and_then(
2019-12-20 12:27:32 +01:00
HttpService::new(map_config(
App::new().service(web::resource("/").route(web::to(HttpResponse::Ok))),
2019-12-20 12:27:32 +01:00
|_| AppConfig::default(),
))
2019-12-02 12:33:11 +01:00
.tcp(),
)
2020-03-08 08:42:45 +01:00
})
.await;
2019-11-26 06:25:50 +01:00
let client = awc::Client::default();
// req 1
let request = client.get(srv.url("/")).send();
let response = request.await.unwrap();
assert!(response.status().is_success());
// req 2
let req = client.post(srv.url("/"));
let response = req.send().await.unwrap();
assert!(response.status().is_success());
// one connection
assert_eq!(num.load(Ordering::Relaxed), 1);
}
2019-11-26 06:25:50 +01:00
#[actix_rt::test]
async fn test_connection_force_close() {
let num = Arc::new(AtomicUsize::new(0));
let num2 = num.clone();
2019-12-12 18:08:38 +01:00
let srv = test_server(move || {
2019-11-26 06:25:50 +01:00
let num2 = num2.clone();
2021-04-16 21:28:21 +02:00
fn_service(move |io| {
2019-11-26 06:25:50 +01:00
num2.fetch_add(1, Ordering::Relaxed);
ok(io)
})
2019-12-02 12:33:11 +01:00
.and_then(
2019-12-20 12:27:32 +01:00
HttpService::new(map_config(
App::new().service(web::resource("/").route(web::to(HttpResponse::Ok))),
2019-12-20 12:27:32 +01:00
|_| AppConfig::default(),
))
2019-12-02 12:33:11 +01:00
.tcp(),
)
2020-03-08 08:42:45 +01:00
})
.await;
2019-11-26 06:25:50 +01:00
let client = awc::Client::default();
// req 1
let request = client.get(srv.url("/")).force_close().send();
let response = request.await.unwrap();
assert!(response.status().is_success());
// req 2
let req = client.post(srv.url("/")).force_close();
let response = req.send().await.unwrap();
assert!(response.status().is_success());
// two connection
assert_eq!(num.load(Ordering::Relaxed), 2);
}
2019-11-26 06:25:50 +01:00
#[actix_rt::test]
async fn test_connection_server_close() {
let num = Arc::new(AtomicUsize::new(0));
let num2 = num.clone();
2019-12-22 13:39:25 +01:00
let srv = test_server(move || {
let num2 = num2.clone();
2021-04-16 21:28:21 +02:00
fn_service(move |io| {
2019-12-22 13:39:25 +01:00
num2.fetch_add(1, Ordering::Relaxed);
ok(io)
})
.and_then(
HttpService::new(map_config(
App::new().service(
web::resource("/")
.route(web::to(|| HttpResponse::Ok().force_close().finish())),
),
|_| AppConfig::default(),
))
.tcp(),
)
2020-03-08 08:42:45 +01:00
})
.await;
2019-11-26 06:25:50 +01:00
let client = awc::Client::default();
// req 1
let request = client.get(srv.url("/")).send();
let response = request.await.unwrap();
assert!(response.status().is_success());
// req 2
let req = client.post(srv.url("/"));
let response = req.send().await.unwrap();
assert!(response.status().is_success());
// two connection
assert_eq!(num.load(Ordering::Relaxed), 2);
}
2019-11-26 06:25:50 +01:00
#[actix_rt::test]
async fn test_connection_wait_queue() {
let num = Arc::new(AtomicUsize::new(0));
let num2 = num.clone();
2019-12-12 18:08:38 +01:00
let srv = test_server(move || {
2019-11-26 06:25:50 +01:00
let num2 = num2.clone();
2021-04-16 21:28:21 +02:00
fn_service(move |io| {
2019-11-26 06:25:50 +01:00
num2.fetch_add(1, Ordering::Relaxed);
ok(io)
})
2019-12-02 12:33:11 +01:00
.and_then(
2019-12-20 12:27:32 +01:00
HttpService::new(map_config(
2019-12-22 13:39:25 +01:00
App::new().service(
web::resource("/").route(web::to(|| HttpResponse::Ok().body(STR))),
),
2019-12-20 12:27:32 +01:00
|_| AppConfig::default(),
2019-12-02 12:33:11 +01:00
))
.tcp(),
)
2020-03-08 08:42:45 +01:00
})
.await;
2019-11-26 06:25:50 +01:00
let client = awc::Client::builder()
2021-02-18 13:30:09 +01:00
.connector(awc::Connector::new().limit(1))
2019-11-26 06:25:50 +01:00
.finish();
// req 1
let request = client.get(srv.url("/")).send();
let mut response = request.await.unwrap();
assert!(response.status().is_success());
// req 2
let req2 = client.post(srv.url("/"));
let req2_fut = req2.send();
// read response 1
let bytes = response.body().await.unwrap();
assert_eq!(bytes, Bytes::from_static(STR.as_ref()));
// req 2
let response = req2_fut.await.unwrap();
assert!(response.status().is_success());
// two connection
assert_eq!(num.load(Ordering::Relaxed), 1);
}
2019-11-26 06:25:50 +01:00
#[actix_rt::test]
async fn test_connection_wait_queue_force_close() {
let num = Arc::new(AtomicUsize::new(0));
let num2 = num.clone();
2019-12-22 13:39:25 +01:00
let srv = test_server(move || {
let num2 = num2.clone();
2021-04-16 21:28:21 +02:00
fn_service(move |io| {
2019-12-22 13:39:25 +01:00
num2.fetch_add(1, Ordering::Relaxed);
ok(io)
})
.and_then(
HttpService::new(map_config(
App::new().service(
web::resource("/")
.route(web::to(|| HttpResponse::Ok().force_close().body(STR))),
),
|_| AppConfig::default(),
))
.tcp(),
)
2020-03-08 08:42:45 +01:00
})
.await;
2019-11-26 06:25:50 +01:00
let client = awc::Client::builder()
2021-02-18 13:30:09 +01:00
.connector(awc::Connector::new().limit(1))
2019-11-26 06:25:50 +01:00
.finish();
// req 1
let request = client.get(srv.url("/")).send();
let mut response = request.await.unwrap();
assert!(response.status().is_success());
// req 2
let req2 = client.post(srv.url("/"));
let req2_fut = req2.send();
// read response 1
let bytes = response.body().await.unwrap();
assert_eq!(bytes, Bytes::from_static(STR.as_ref()));
// req 2
let response = req2_fut.await.unwrap();
assert!(response.status().is_success());
// two connection
assert_eq!(num.load(Ordering::Relaxed), 2);
2019-04-15 05:45:44 +02:00
}
2019-11-26 06:25:50 +01:00
#[actix_rt::test]
async fn test_with_query_parameter() {
let srv = actix_test::start(|| {
2019-12-12 18:08:38 +01:00
App::new().service(web::resource("/").to(|req: HttpRequest| {
if req.query_string().contains("qp") {
HttpResponse::Ok()
} else {
HttpResponse::BadRequest()
}
}))
2019-11-26 06:25:50 +01:00
});
let res = awc::Client::new()
.get(srv.url("/?qp=5"))
.send()
.await
.unwrap();
assert!(res.status().is_success());
2019-04-15 05:45:44 +02:00
}
#[cfg(feature = "compress-gzip")]
2019-11-26 06:25:50 +01:00
#[actix_rt::test]
async fn test_no_decompress() {
let srv = actix_test::start(|| {
2019-12-12 18:08:38 +01:00
App::new()
.wrap(actix_web::middleware::Compress::default())
2022-01-03 19:46:04 +01:00
.service(web::resource("/").route(web::to(|| HttpResponse::Ok().body(STR))))
2019-11-26 06:25:50 +01:00
});
let mut res = awc::Client::new()
.get(srv.url("/"))
2022-01-03 19:46:04 +01:00
.insert_header((header::ACCEPT_ENCODING, "gzip"))
2019-11-26 06:25:50 +01:00
.no_decompress()
.send()
.await
.unwrap();
assert!(res.status().is_success());
// read response
let bytes = res.body().await.unwrap();
2022-01-03 19:46:04 +01:00
assert_eq!(utils::gzip::decode(bytes), STR.as_bytes());
2019-11-26 06:25:50 +01:00
// POST
let mut res = awc::Client::new()
.post(srv.url("/"))
2022-01-03 19:46:04 +01:00
.insert_header((header::ACCEPT_ENCODING, "gzip"))
2019-11-26 06:25:50 +01:00
.no_decompress()
.send()
.await
.unwrap();
assert!(res.status().is_success());
let bytes = res.body().await.unwrap();
2022-01-03 19:46:04 +01:00
assert_eq!(utils::gzip::decode(bytes), STR.as_bytes());
2019-04-15 05:45:44 +02:00
}
2019-03-27 04:45:00 +01:00
#[cfg(feature = "compress-gzip")]
2019-11-26 06:25:50 +01:00
#[actix_rt::test]
async fn test_client_gzip_encoding() {
let srv = actix_test::start(|| {
2019-12-12 18:08:38 +01:00
App::new().service(web::resource("/").route(web::to(|| {
2019-11-26 06:25:50 +01:00
HttpResponse::Ok()
2022-01-03 19:46:04 +01:00
.insert_header(header::ContentEncoding::Gzip)
.body(utils::gzip::encode(STR))
2019-12-12 18:08:38 +01:00
})))
2019-11-26 06:25:50 +01:00
});
// client request
let mut response = srv.post("/").send().await.unwrap();
assert!(response.status().is_success());
// read response
let bytes = response.body().await.unwrap();
2022-01-03 19:46:04 +01:00
assert_eq!(bytes, STR);
2019-03-27 04:45:00 +01:00
}
#[cfg(feature = "compress-gzip")]
2019-11-26 06:25:50 +01:00
#[actix_rt::test]
async fn test_client_gzip_encoding_large() {
let srv = actix_test::start(|| {
2019-12-12 18:08:38 +01:00
App::new().service(web::resource("/").route(web::to(|| {
2019-11-26 06:25:50 +01:00
HttpResponse::Ok()
2022-01-03 19:46:04 +01:00
.insert_header(header::ContentEncoding::Gzip)
.body(utils::gzip::encode(STR.repeat(10)))
2019-12-12 18:08:38 +01:00
})))
2019-11-26 06:25:50 +01:00
});
// client request
let mut response = srv.post("/").send().await.unwrap();
assert!(response.status().is_success());
// read response
let bytes = response.body().await.unwrap();
2022-01-03 19:46:04 +01:00
assert_eq!(bytes, STR.repeat(10));
2019-03-27 04:45:00 +01:00
}
#[cfg(feature = "compress-gzip")]
2019-11-26 06:25:50 +01:00
#[actix_rt::test]
async fn test_client_gzip_encoding_large_random() {
let data = rand::thread_rng()
.sample_iter(&rand::distributions::Alphanumeric)
.take(100_000)
2020-12-23 00:45:31 +01:00
.map(char::from)
2019-11-26 06:25:50 +01:00
.collect::<String>();
let srv = actix_test::start(|| {
2019-12-12 18:08:38 +01:00
App::new().service(web::resource("/").route(web::to(|data: Bytes| {
HttpResponse::Ok()
2022-01-03 19:46:04 +01:00
.insert_header(header::ContentEncoding::Gzip)
.body(utils::gzip::encode(data))
2019-12-12 18:08:38 +01:00
})))
2019-11-26 06:25:50 +01:00
});
// client request
let mut response = srv.post("/").send_body(data.clone()).await.unwrap();
assert!(response.status().is_success());
// read response
let bytes = response.body().await.unwrap();
2022-01-03 19:46:04 +01:00
assert_eq!(bytes, data);
2019-03-27 04:45:00 +01:00
}
#[cfg(feature = "compress-brotli")]
2019-11-26 06:25:50 +01:00
#[actix_rt::test]
async fn test_client_brotli_encoding() {
let srv = actix_test::start(|| {
2019-12-12 18:08:38 +01:00
App::new().service(web::resource("/").route(web::to(|data: Bytes| {
HttpResponse::Ok()
2021-01-15 03:11:10 +01:00
.insert_header(("content-encoding", "br"))
2022-01-03 19:46:04 +01:00
.body(utils::brotli::encode(data))
2019-12-12 18:08:38 +01:00
})))
2019-11-26 06:25:50 +01:00
});
// client request
let mut response = srv.post("/").send_body(STR).await.unwrap();
assert!(response.status().is_success());
// read response
let bytes = response.body().await.unwrap();
assert_eq!(bytes, Bytes::from_static(STR.as_ref()));
2019-03-27 04:45:00 +01:00
}
#[cfg(feature = "compress-brotli")]
2019-12-08 07:31:16 +01:00
#[actix_rt::test]
async fn test_client_brotli_encoding_large_random() {
let data = rand::thread_rng()
.sample_iter(&rand::distributions::Alphanumeric)
.take(70_000)
2020-12-23 00:45:31 +01:00
.map(char::from)
2019-12-08 07:31:16 +01:00
.collect::<String>();
2019-03-27 04:45:00 +01:00
let srv = actix_test::start(|| {
2019-12-12 18:08:38 +01:00
App::new().service(web::resource("/").route(web::to(|data: Bytes| {
HttpResponse::Ok()
2022-01-03 19:46:04 +01:00
.insert_header(header::ContentEncoding::Brotli)
.body(utils::brotli::encode(&data))
2019-12-12 18:08:38 +01:00
})))
2019-12-08 07:31:16 +01:00
});
2019-03-27 04:45:00 +01:00
2019-12-08 07:31:16 +01:00
// client request
let mut response = srv.post("/").send_body(data.clone()).await.unwrap();
assert!(response.status().is_success());
// read response
let bytes = response.body().await.unwrap();
2022-01-03 19:46:04 +01:00
assert_eq!(bytes, data);
2019-12-08 07:31:16 +01:00
}
2019-03-27 04:45:00 +01:00
2021-01-17 06:19:32 +01:00
#[actix_rt::test]
async fn test_client_deflate_encoding() {
let srv = actix_test::start(|| {
2022-01-03 19:46:04 +01:00
App::new().default_service(web::to(|body: Bytes| HttpResponse::Ok().body(body)))
2021-01-17 06:19:32 +01:00
});
2022-01-03 19:46:04 +01:00
let req = srv
.post("/")
.insert_header((header::ACCEPT_ENCODING, "gzip"))
.send_body(STR);
2021-01-17 06:19:32 +01:00
let mut res = req.await.unwrap();
assert_eq!(res.status(), StatusCode::OK);
let bytes = res.body().await.unwrap();
2022-01-03 19:46:04 +01:00
assert_eq!(bytes, STR);
2021-01-17 06:19:32 +01:00
}
#[actix_rt::test]
async fn test_client_deflate_encoding_large_random() {
let data = rand::thread_rng()
.sample_iter(rand::distributions::Alphanumeric)
.map(char::from)
.take(70_000)
.collect::<String>();
let srv = actix_test::start(|| {
2022-01-03 19:46:04 +01:00
App::new().default_service(web::to(|body: Bytes| HttpResponse::Ok().body(body)))
2021-01-17 06:19:32 +01:00
});
2022-01-03 19:46:04 +01:00
let req = srv
.post("/")
.insert_header((header::ACCEPT_ENCODING, "br"))
.send_body(data.clone());
2021-01-17 06:19:32 +01:00
let mut res = req.await.unwrap();
let bytes = res.body().await.unwrap();
assert_eq!(res.status(), StatusCode::OK);
assert_eq!(bytes, Bytes::from(data));
}
#[actix_rt::test]
async fn test_client_streaming_explicit() {
let srv = actix_test::start(|| {
2021-01-17 06:19:32 +01:00
App::new().default_service(web::to(|body: web::Payload| {
2022-01-03 19:46:04 +01:00
HttpResponse::Ok().streaming(body)
2021-01-17 06:19:32 +01:00
}))
});
2021-02-12 00:03:17 +01:00
let body =
stream::once(async { Ok::<_, actix_http::Error>(Bytes::from_static(STR.as_bytes())) });
2022-01-03 19:46:04 +01:00
let req = srv
.post("/")
.insert_header((header::ACCEPT_ENCODING, "identity"))
.send_stream(Box::pin(body));
2021-01-17 06:19:32 +01:00
let mut res = req.await.unwrap();
assert!(res.status().is_success());
let bytes = res.body().await.unwrap();
assert_eq!(bytes, Bytes::from_static(STR.as_ref()));
}
#[actix_rt::test]
async fn test_body_streaming_implicit() {
let srv = actix_test::start(|| {
2021-01-17 06:19:32 +01:00
App::new().default_service(web::to(|| {
2022-01-03 19:46:04 +01:00
let body =
stream::once(async { Ok::<_, Infallible>(Bytes::from_static(STR.as_bytes())) });
HttpResponse::Ok().streaming(body)
2021-01-17 06:19:32 +01:00
}))
});
2022-01-03 19:46:04 +01:00
let req = srv
.get("/")
.insert_header((header::ACCEPT_ENCODING, "gzip"))
.send();
2021-01-17 06:19:32 +01:00
let mut res = req.await.unwrap();
assert!(res.status().is_success());
let bytes = res.body().await.unwrap();
assert_eq!(bytes, Bytes::from_static(STR.as_ref()));
}
2019-03-27 04:45:00 +01:00
2019-11-26 06:25:50 +01:00
#[actix_rt::test]
async fn test_client_cookie_handling() {
2019-11-22 06:49:35 +01:00
use std::io::{Error as IoError, ErrorKind};
2019-11-26 06:25:50 +01:00
let cookie1 = Cookie::build("cookie1", "value1").finish();
let cookie2 = Cookie::build("cookie2", "value2")
.domain("www.example.org")
.path("/")
.secure(true)
.http_only(true)
.finish();
// Q: are all these clones really necessary? A: Yes, possibly
let cookie1b = cookie1.clone();
let cookie2b = cookie2.clone();
let srv = actix_test::start(move || {
2019-11-26 06:25:50 +01:00
let cookie1 = cookie1b.clone();
let cookie2 = cookie2b.clone();
2019-12-12 18:08:38 +01:00
App::new().route(
2019-11-26 06:25:50 +01:00
"/",
web::to(move |req: HttpRequest| {
let cookie1 = cookie1.clone();
let cookie2 = cookie2.clone();
async move {
// Check cookies were sent correctly
let res: Result<(), Error> = req
.cookie("cookie1")
.ok_or(())
.and_then(|c1| {
if c1.value() == "value1" {
Ok(())
} else {
Err(())
}
})
.and_then(|()| req.cookie("cookie2").ok_or(()))
.and_then(|c2| {
if c2.value() == "value2" {
Ok(())
} else {
Err(())
}
})
.map_err(|_| Error::from(IoError::from(ErrorKind::NotFound)));
if let Err(e) = res {
Err(e)
} else {
// Send some cookies back
Ok::<_, Error>(
HttpResponse::Ok().cookie(cookie1).cookie(cookie2).finish(),
)
2019-11-22 06:49:35 +01:00
}
2019-11-26 06:25:50 +01:00
}
}),
2019-12-12 18:08:38 +01:00
)
2019-11-26 06:25:50 +01:00
});
let request = srv.get("/").cookie(cookie1.clone()).cookie(cookie2.clone());
let response = request.send().await.unwrap();
assert!(response.status().is_success());
let c1 = response.cookie("cookie1").expect("Missing cookie1");
assert_eq!(c1, cookie1);
let c2 = response.cookie("cookie2").expect("Missing cookie2");
assert_eq!(c2, cookie2);
2019-03-27 05:31:18 +01:00
}
2019-03-27 04:45:00 +01:00
2021-01-17 06:19:32 +01:00
#[actix_rt::test]
async fn client_unread_response() {
let addr = actix_test::unused_addr();
2021-02-06 17:05:33 +01:00
let lst = std::net::TcpListener::bind(addr).unwrap();
2021-01-17 06:19:32 +01:00
2021-02-06 17:05:33 +01:00
std::thread::spawn(move || {
2021-11-04 16:57:55 +01:00
let (mut stream, _) = lst.accept().unwrap();
let mut b = [0; 1000];
let _ = stream.read(&mut b).unwrap();
let _ = stream.write_all(
b"HTTP/1.1 200 OK\r\n\
2021-01-17 06:19:32 +01:00
connection: close\r\n\
\r\n\
welcome!",
2021-11-04 16:57:55 +01:00
);
2021-01-17 06:19:32 +01:00
});
// client request
let req = awc::Client::new().get(format!("http://{}/", addr).as_str());
let mut res = req.send().await.unwrap();
assert!(res.status().is_success());
// awc does not read all bytes unless content-length is specified
let bytes = res.body().await.unwrap();
assert_eq!(bytes, Bytes::from_static(b""));
}
2019-03-27 04:45:00 +01:00
2019-11-26 06:25:50 +01:00
#[actix_rt::test]
async fn client_basic_auth() {
let srv = actix_test::start(|| {
2019-12-12 18:08:38 +01:00
App::new().route(
2019-11-26 06:25:50 +01:00
"/",
web::to(|req: HttpRequest| {
if req
.headers()
.get(header::AUTHORIZATION)
.unwrap()
.to_str()
.unwrap()
== format!("Basic {}", base64::encode("username:password"))
2019-11-26 06:25:50 +01:00
{
HttpResponse::Ok()
} else {
HttpResponse::BadRequest()
}
}),
2019-12-12 18:08:38 +01:00
)
2019-11-26 06:25:50 +01:00
});
// set authorization header to Basic <base64 encoded username:password>
let request = srv.get("/").basic_auth("username", "password");
2019-11-26 06:25:50 +01:00
let response = request.send().await.unwrap();
assert!(response.status().is_success());
}
2019-11-26 06:25:50 +01:00
#[actix_rt::test]
async fn client_bearer_auth() {
let srv = actix_test::start(|| {
2019-12-12 18:08:38 +01:00
App::new().route(
2019-11-26 06:25:50 +01:00
"/",
web::to(|req: HttpRequest| {
if req
.headers()
.get(header::AUTHORIZATION)
.unwrap()
.to_str()
.unwrap()
== "Bearer someS3cr3tAutht0k3n"
{
HttpResponse::Ok()
} else {
HttpResponse::BadRequest()
}
}),
2019-12-12 18:08:38 +01:00
)
2019-11-26 06:25:50 +01:00
});
// set authorization header to Bearer <token>
let request = srv.get("/").bearer_auth("someS3cr3tAutht0k3n");
let response = request.send().await.unwrap();
assert!(response.status().is_success());
}
#[actix_rt::test]
async fn test_local_address() {
let ip = IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1));
let srv = actix_test::start(move || {
App::new().service(web::resource("/").route(web::to(
move |req: HttpRequest| async move {
assert_eq!(req.peer_addr().unwrap().ip(), ip);
Ok::<_, Error>(HttpResponse::Ok())
},
)))
});
let client = awc::Client::builder().local_address(ip).finish();
let res = client.get(srv.url("/")).send().await.unwrap();
assert_eq!(res.status(), 200);
let client = awc::Client::builder()
.connector(
// connector local address setting should always be override by client builder.
awc::Connector::new().local_address(IpAddr::V4(Ipv4Addr::new(128, 0, 0, 1))),
)
.local_address(ip)
.finish();
let res = client.get(srv.url("/")).send().await.unwrap();
assert_eq!(res.status(), 200);
}