2019-01-27 19:59:07 +01:00
|
|
|
//! Various helpers for Actix applications to use during testing.
|
2020-11-25 01:53:48 +01:00
|
|
|
|
2021-12-08 07:09:56 +01:00
|
|
|
#![deny(rust_2018_idioms, nonstandard_style)]
|
|
|
|
#![warn(future_incompatible)]
|
2020-11-25 01:53:48 +01:00
|
|
|
#![doc(html_logo_url = "https://actix.rs/img/logo.png")]
|
|
|
|
#![doc(html_favicon_url = "https://actix.rs/favicon.ico")]
|
2023-02-26 22:55:25 +01:00
|
|
|
#![cfg_attr(docsrs, feature(doc_auto_cfg))]
|
2020-11-25 01:53:48 +01:00
|
|
|
|
2021-02-07 04:54:58 +01:00
|
|
|
#[cfg(feature = "openssl")]
|
|
|
|
extern crate tls_openssl as openssl;
|
|
|
|
|
2021-11-15 05:03:33 +01:00
|
|
|
use std::{net, thread, time::Duration};
|
2019-01-27 19:59:07 +01:00
|
|
|
|
|
|
|
use actix_codec::{AsyncRead, AsyncWrite, Framed};
|
2019-12-02 18:33:39 +01:00
|
|
|
use actix_rt::{net::TcpStream, System};
|
2021-12-27 19:45:31 +01:00
|
|
|
use actix_server::{Server, ServerServiceFactory};
|
2021-04-01 07:40:10 +02:00
|
|
|
use awc::{
|
2021-12-05 15:37:20 +01:00
|
|
|
error::PayloadError, http::header::HeaderMap, ws, Client, ClientRequest, ClientResponse,
|
|
|
|
Connector,
|
2021-04-01 07:40:10 +02:00
|
|
|
};
|
2019-03-30 02:51:07 +01:00
|
|
|
use bytes::Bytes;
|
2020-05-18 04:47:33 +02:00
|
|
|
use futures_core::stream::Stream;
|
2019-01-27 19:59:07 +01:00
|
|
|
use http::Method;
|
2020-05-19 02:25:51 +02:00
|
|
|
use socket2::{Domain, Protocol, Socket, Type};
|
2021-11-15 05:03:33 +01:00
|
|
|
use tokio::sync::mpsc;
|
2019-01-27 19:59:07 +01:00
|
|
|
|
2021-11-22 19:16:56 +01:00
|
|
|
/// Start test server.
|
2019-01-27 19:59:07 +01:00
|
|
|
///
|
2021-11-22 19:16:56 +01:00
|
|
|
/// `TestServer` is very simple test server that simplify process of writing integration tests cases
|
|
|
|
/// for HTTP applications.
|
2019-01-27 19:59:07 +01:00
|
|
|
///
|
|
|
|
/// # Examples
|
2019-03-30 05:13:39 +01:00
|
|
|
///
|
2023-07-22 02:57:44 +02:00
|
|
|
/// ```
|
|
|
|
/// use actix_http::{HttpService, Response, Error, StatusCode};
|
|
|
|
/// use actix_http_test::test_server;
|
|
|
|
/// use actix_service::{fn_service, map_config, ServiceFactoryExt as _};
|
2019-01-27 19:59:07 +01:00
|
|
|
///
|
2023-07-22 02:57:44 +02:00
|
|
|
/// #[actix_rt::test]
|
|
|
|
/// # async fn hidden_test() {}
|
2019-11-26 06:25:50 +01:00
|
|
|
/// async fn test_example() {
|
2023-03-31 20:09:13 +02:00
|
|
|
/// let srv = test_server(|| {
|
|
|
|
/// HttpService::build()
|
2023-07-22 02:57:44 +02:00
|
|
|
/// .h1(fn_service(|req| async move {
|
|
|
|
/// Ok::<_, Error>(Response::ok())
|
|
|
|
/// }))
|
2023-03-31 20:09:13 +02:00
|
|
|
/// .tcp()
|
|
|
|
/// .map_err(|_| ())
|
|
|
|
/// })
|
|
|
|
/// .await;
|
2019-01-27 19:59:07 +01:00
|
|
|
///
|
2019-11-26 06:25:50 +01:00
|
|
|
/// let req = srv.get("/");
|
|
|
|
/// let response = req.send().await.unwrap();
|
2023-03-31 20:09:13 +02:00
|
|
|
///
|
2023-07-22 02:57:44 +02:00
|
|
|
/// assert_eq!(response.status(), StatusCode::OK);
|
2019-03-26 20:50:51 +01:00
|
|
|
/// }
|
2023-07-22 02:57:44 +02:00
|
|
|
/// # actix_rt::System::new().block_on(test_example());
|
2019-01-27 19:59:07 +01:00
|
|
|
/// ```
|
2021-12-27 19:45:31 +01:00
|
|
|
pub async fn test_server<F: ServerServiceFactory<TcpStream>>(factory: F) -> TestServer {
|
2020-09-15 13:09:16 +02:00
|
|
|
let tcp = net::TcpListener::bind("127.0.0.1:0").unwrap();
|
|
|
|
test_server_with_addr(tcp, factory).await
|
|
|
|
}
|
|
|
|
|
2021-11-15 05:03:33 +01:00
|
|
|
/// Start [`test server`](test_server()) on an existing address binding.
|
2021-12-27 19:45:31 +01:00
|
|
|
pub async fn test_server_with_addr<F: ServerServiceFactory<TcpStream>>(
|
2020-09-15 13:09:16 +02:00
|
|
|
tcp: net::TcpListener,
|
|
|
|
factory: F,
|
|
|
|
) -> TestServer {
|
2021-11-15 05:03:33 +01:00
|
|
|
let (started_tx, started_rx) = std::sync::mpsc::channel();
|
|
|
|
let (thread_stop_tx, thread_stop_rx) = mpsc::channel(1);
|
2019-12-12 18:08:38 +01:00
|
|
|
|
|
|
|
// run server in separate thread
|
|
|
|
thread::spawn(move || {
|
2021-11-22 02:19:09 +01:00
|
|
|
System::new().block_on(async move {
|
|
|
|
let local_addr = tcp.local_addr().unwrap();
|
|
|
|
|
|
|
|
let srv = Server::build()
|
|
|
|
.workers(1)
|
|
|
|
.disable_signals()
|
|
|
|
.system_exit()
|
|
|
|
.listen("test", tcp, factory)
|
|
|
|
.expect("test server could not be created");
|
|
|
|
|
|
|
|
let srv = srv.run();
|
|
|
|
started_tx
|
|
|
|
.send((System::current(), srv.handle(), local_addr))
|
|
|
|
.unwrap();
|
|
|
|
|
|
|
|
// drive server loop
|
|
|
|
srv.await.unwrap();
|
|
|
|
});
|
2021-11-15 05:03:33 +01:00
|
|
|
|
|
|
|
// notify TestServer that server and system have shut down
|
|
|
|
// all thread managed resources should be dropped at this point
|
2023-01-01 21:56:27 +01:00
|
|
|
#[allow(clippy::let_underscore_future)]
|
2021-11-15 05:03:33 +01:00
|
|
|
let _ = thread_stop_tx.send(());
|
2019-12-12 18:08:38 +01:00
|
|
|
});
|
|
|
|
|
2021-11-15 05:03:33 +01:00
|
|
|
let (system, server, addr) = started_rx.recv().unwrap();
|
2019-12-12 18:08:38 +01:00
|
|
|
|
|
|
|
let client = {
|
2021-11-15 05:03:33 +01:00
|
|
|
#[cfg(feature = "openssl")]
|
|
|
|
let connector = {
|
|
|
|
use openssl::ssl::{SslConnector, SslMethod, SslVerifyMode};
|
|
|
|
|
|
|
|
let mut builder = SslConnector::builder(SslMethod::tls()).unwrap();
|
|
|
|
|
|
|
|
builder.set_verify(SslVerifyMode::NONE);
|
|
|
|
let _ = builder
|
|
|
|
.set_alpn_protos(b"\x02h2\x08http/1.1")
|
|
|
|
.map_err(|e| log::error!("Can not set alpn protocol: {:?}", e));
|
|
|
|
|
|
|
|
Connector::new()
|
|
|
|
.conn_lifetime(Duration::from_secs(0))
|
|
|
|
.timeout(Duration::from_millis(30000))
|
2021-12-18 17:44:30 +01:00
|
|
|
.openssl(builder.build())
|
2021-11-15 05:03:33 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
#[cfg(not(feature = "openssl"))]
|
2019-12-12 18:08:38 +01:00
|
|
|
let connector = {
|
2021-11-15 05:03:33 +01:00
|
|
|
Connector::new()
|
|
|
|
.conn_lifetime(Duration::from_secs(0))
|
|
|
|
.timeout(Duration::from_millis(30000))
|
2019-12-12 18:08:38 +01:00
|
|
|
};
|
|
|
|
|
2020-09-11 10:24:39 +02:00
|
|
|
Client::builder().connector(connector).finish()
|
2019-12-12 18:08:38 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
TestServer {
|
2021-11-15 05:03:33 +01:00
|
|
|
server,
|
2019-12-12 18:08:38 +01:00
|
|
|
client,
|
|
|
|
system,
|
2021-11-15 05:03:33 +01:00
|
|
|
addr,
|
|
|
|
thread_stop_rx,
|
2019-12-12 18:08:38 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-03-13 22:41:40 +01:00
|
|
|
/// Test server controller
|
2019-12-12 18:08:38 +01:00
|
|
|
pub struct TestServer {
|
2021-11-15 05:03:33 +01:00
|
|
|
server: actix_server::ServerHandle,
|
|
|
|
client: awc::Client,
|
|
|
|
system: actix_rt::System,
|
2019-01-27 19:59:07 +01:00
|
|
|
addr: net::SocketAddr,
|
2021-11-15 05:03:33 +01:00
|
|
|
thread_stop_rx: mpsc::Receiver<()>,
|
2019-01-27 19:59:07 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
impl TestServer {
|
|
|
|
/// Construct test server url
|
|
|
|
pub fn addr(&self) -> net::SocketAddr {
|
|
|
|
self.addr
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Construct test server url
|
|
|
|
pub fn url(&self, uri: &str) -> String {
|
|
|
|
if uri.starts_with('/') {
|
2019-07-31 22:02:56 +02:00
|
|
|
format!("http://localhost:{}{}", self.addr.port(), uri)
|
2019-01-27 19:59:07 +01:00
|
|
|
} else {
|
2019-07-31 22:02:56 +02:00
|
|
|
format!("http://localhost:{}/{}", self.addr.port(), uri)
|
2019-01-27 19:59:07 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-02-11 23:39:54 +01:00
|
|
|
/// Construct test HTTPS server URL.
|
2019-02-06 20:44:15 +01:00
|
|
|
pub fn surl(&self, uri: &str) -> String {
|
|
|
|
if uri.starts_with('/') {
|
2019-07-31 22:02:56 +02:00
|
|
|
format!("https://localhost:{}{}", self.addr.port(), uri)
|
2019-02-06 20:44:15 +01:00
|
|
|
} else {
|
2019-07-31 22:02:56 +02:00
|
|
|
format!("https://localhost:{}/{}", self.addr.port(), uri)
|
2019-02-06 20:44:15 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-01-27 19:59:07 +01:00
|
|
|
/// Create `GET` request
|
2019-03-30 15:53:45 +01:00
|
|
|
pub fn get<S: AsRef<str>>(&self, path: S) -> ClientRequest {
|
|
|
|
self.client.get(self.url(path.as_ref()).as_str())
|
2019-01-27 19:59:07 +01:00
|
|
|
}
|
|
|
|
|
2021-02-11 23:39:54 +01:00
|
|
|
/// Create HTTPS `GET` request
|
2019-03-30 15:53:45 +01:00
|
|
|
pub fn sget<S: AsRef<str>>(&self, path: S) -> ClientRequest {
|
|
|
|
self.client.get(self.surl(path.as_ref()).as_str())
|
2019-03-12 00:42:33 +01:00
|
|
|
}
|
|
|
|
|
2019-01-27 19:59:07 +01:00
|
|
|
/// Create `POST` request
|
2019-03-30 15:53:45 +01:00
|
|
|
pub fn post<S: AsRef<str>>(&self, path: S) -> ClientRequest {
|
|
|
|
self.client.post(self.url(path.as_ref()).as_str())
|
2019-01-27 19:59:07 +01:00
|
|
|
}
|
|
|
|
|
2021-02-11 23:39:54 +01:00
|
|
|
/// Create HTTPS `POST` request
|
2019-03-30 15:53:45 +01:00
|
|
|
pub fn spost<S: AsRef<str>>(&self, path: S) -> ClientRequest {
|
|
|
|
self.client.post(self.surl(path.as_ref()).as_str())
|
2019-01-27 19:59:07 +01:00
|
|
|
}
|
|
|
|
|
2019-03-26 19:43:22 +01:00
|
|
|
/// Create `HEAD` request
|
2019-03-30 15:53:45 +01:00
|
|
|
pub fn head<S: AsRef<str>>(&self, path: S) -> ClientRequest {
|
|
|
|
self.client.head(self.url(path.as_ref()).as_str())
|
2019-01-27 19:59:07 +01:00
|
|
|
}
|
|
|
|
|
2021-02-11 23:39:54 +01:00
|
|
|
/// Create HTTPS `HEAD` request
|
2019-03-30 15:53:45 +01:00
|
|
|
pub fn shead<S: AsRef<str>>(&self, path: S) -> ClientRequest {
|
|
|
|
self.client.head(self.surl(path.as_ref()).as_str())
|
2019-01-27 19:59:07 +01:00
|
|
|
}
|
|
|
|
|
2019-06-12 12:47:00 +02:00
|
|
|
/// Create `PUT` request
|
|
|
|
pub fn put<S: AsRef<str>>(&self, path: S) -> ClientRequest {
|
|
|
|
self.client.put(self.url(path.as_ref()).as_str())
|
|
|
|
}
|
|
|
|
|
2021-02-11 23:39:54 +01:00
|
|
|
/// Create HTTPS `PUT` request
|
2019-06-12 12:47:00 +02:00
|
|
|
pub fn sput<S: AsRef<str>>(&self, path: S) -> ClientRequest {
|
|
|
|
self.client.put(self.surl(path.as_ref()).as_str())
|
|
|
|
}
|
|
|
|
|
2019-07-16 06:19:28 +02:00
|
|
|
/// Create `PATCH` request
|
|
|
|
pub fn patch<S: AsRef<str>>(&self, path: S) -> ClientRequest {
|
|
|
|
self.client.patch(self.url(path.as_ref()).as_str())
|
|
|
|
}
|
|
|
|
|
2021-02-11 23:39:54 +01:00
|
|
|
/// Create HTTPS `PATCH` request
|
2019-07-16 06:19:28 +02:00
|
|
|
pub fn spatch<S: AsRef<str>>(&self, path: S) -> ClientRequest {
|
|
|
|
self.client.patch(self.surl(path.as_ref()).as_str())
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Create `DELETE` request
|
|
|
|
pub fn delete<S: AsRef<str>>(&self, path: S) -> ClientRequest {
|
|
|
|
self.client.delete(self.url(path.as_ref()).as_str())
|
|
|
|
}
|
|
|
|
|
2021-02-11 23:39:54 +01:00
|
|
|
/// Create HTTPS `DELETE` request
|
2019-07-16 06:19:28 +02:00
|
|
|
pub fn sdelete<S: AsRef<str>>(&self, path: S) -> ClientRequest {
|
|
|
|
self.client.delete(self.surl(path.as_ref()).as_str())
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Create `OPTIONS` request
|
|
|
|
pub fn options<S: AsRef<str>>(&self, path: S) -> ClientRequest {
|
|
|
|
self.client.options(self.url(path.as_ref()).as_str())
|
|
|
|
}
|
|
|
|
|
2021-02-11 23:39:54 +01:00
|
|
|
/// Create HTTPS `OPTIONS` request
|
2019-07-16 06:19:28 +02:00
|
|
|
pub fn soptions<S: AsRef<str>>(&self, path: S) -> ClientRequest {
|
|
|
|
self.client.options(self.surl(path.as_ref()).as_str())
|
|
|
|
}
|
|
|
|
|
2021-02-11 23:39:54 +01:00
|
|
|
/// Connect to test HTTP server
|
2019-03-26 19:43:22 +01:00
|
|
|
pub fn request<S: AsRef<str>>(&self, method: Method, path: S) -> ClientRequest {
|
|
|
|
self.client.request(method, path.as_ref())
|
2019-01-27 19:59:07 +01:00
|
|
|
}
|
|
|
|
|
2019-11-19 13:54:19 +01:00
|
|
|
pub async fn load_body<S>(
|
2019-03-30 02:51:07 +01:00
|
|
|
&mut self,
|
2019-04-02 23:27:54 +02:00
|
|
|
mut response: ClientResponse<S>,
|
2019-03-30 02:51:07 +01:00
|
|
|
) -> Result<Bytes, PayloadError>
|
|
|
|
where
|
2019-11-19 04:55:17 +01:00
|
|
|
S: Stream<Item = Result<Bytes, PayloadError>> + Unpin + 'static,
|
2019-03-30 02:51:07 +01:00
|
|
|
{
|
2019-11-19 13:54:19 +01:00
|
|
|
response.body().limit(10_485_760).await
|
2019-01-27 19:59:07 +01:00
|
|
|
}
|
|
|
|
|
2021-02-12 01:27:20 +01:00
|
|
|
/// Connect to WebSocket server at a given path.
|
2019-11-19 13:54:19 +01:00
|
|
|
pub async fn ws_at(
|
2019-01-27 19:59:07 +01:00
|
|
|
&mut self,
|
|
|
|
path: &str,
|
2021-02-12 00:03:17 +01:00
|
|
|
) -> Result<Framed<impl AsyncRead + AsyncWrite, ws::Codec>, awc::error::WsClientError> {
|
2019-01-27 19:59:07 +01:00
|
|
|
let url = self.url(path);
|
2019-03-28 02:53:19 +01:00
|
|
|
let connect = self.client.ws(url).connect();
|
2019-11-19 13:54:19 +01:00
|
|
|
connect.await.map(|(_, framed)| framed)
|
2019-01-27 19:59:07 +01:00
|
|
|
}
|
|
|
|
|
2021-02-12 01:27:20 +01:00
|
|
|
/// Connect to a WebSocket server.
|
2019-11-19 13:54:19 +01:00
|
|
|
pub async fn ws(
|
2019-01-27 19:59:07 +01:00
|
|
|
&mut self,
|
2021-02-12 00:03:17 +01:00
|
|
|
) -> Result<Framed<impl AsyncRead + AsyncWrite, ws::Codec>, awc::error::WsClientError> {
|
2019-11-19 13:54:19 +01:00
|
|
|
self.ws_at("/").await
|
2019-01-27 19:59:07 +01:00
|
|
|
}
|
2019-03-30 02:51:07 +01:00
|
|
|
|
2021-04-01 07:40:10 +02:00
|
|
|
/// Get default HeaderMap of Client.
|
|
|
|
///
|
|
|
|
/// Returns Some(&mut HeaderMap) when Client object is unique
|
|
|
|
/// (No other clone of client exists at the same time).
|
|
|
|
pub fn client_headers(&mut self) -> Option<&mut HeaderMap> {
|
|
|
|
self.client.headers()
|
|
|
|
}
|
|
|
|
|
2021-11-19 15:04:12 +01:00
|
|
|
/// Stop HTTP server.
|
2021-11-15 05:03:33 +01:00
|
|
|
///
|
2021-11-19 15:04:12 +01:00
|
|
|
/// Waits for spawned `Server` and `System` to (force) shutdown.
|
2021-11-15 05:03:33 +01:00
|
|
|
pub async fn stop(&mut self) {
|
|
|
|
// signal server to stop
|
2021-11-19 15:04:12 +01:00
|
|
|
self.server.stop(false).await;
|
2021-11-15 05:03:33 +01:00
|
|
|
|
|
|
|
// also signal system to stop
|
|
|
|
// though this is handled by `ServerBuilder::exit_system` too
|
2019-09-17 17:45:06 +02:00
|
|
|
self.system.stop();
|
2021-11-15 05:03:33 +01:00
|
|
|
|
|
|
|
// wait for thread to be stopped but don't care about result
|
|
|
|
let _ = self.thread_stop_rx.recv().await;
|
2019-03-30 02:51:07 +01:00
|
|
|
}
|
2019-01-27 19:59:07 +01:00
|
|
|
}
|
|
|
|
|
2019-12-12 18:08:38 +01:00
|
|
|
impl Drop for TestServer {
|
2019-01-27 19:59:07 +01:00
|
|
|
fn drop(&mut self) {
|
2021-11-15 05:03:33 +01:00
|
|
|
// calls in this Drop impl should be enough to shut down the server, system, and thread
|
|
|
|
// without needing to await anything
|
|
|
|
|
|
|
|
// signal server to stop
|
2023-01-01 21:56:27 +01:00
|
|
|
#[allow(clippy::let_underscore_future)]
|
2021-11-15 05:03:33 +01:00
|
|
|
let _ = self.server.stop(true);
|
|
|
|
|
|
|
|
// signal system to stop
|
|
|
|
self.system.stop();
|
2019-01-27 19:59:07 +01:00
|
|
|
}
|
|
|
|
}
|
2021-04-02 09:26:59 +02:00
|
|
|
|
|
|
|
/// Get a localhost socket address with random, unused port.
|
|
|
|
pub fn unused_addr() -> net::SocketAddr {
|
|
|
|
let addr: net::SocketAddr = "127.0.0.1:0".parse().unwrap();
|
|
|
|
let socket = Socket::new(Domain::IPV4, Type::STREAM, Some(Protocol::TCP)).unwrap();
|
|
|
|
socket.bind(&addr.into()).unwrap();
|
|
|
|
socket.set_reuse_address(true).unwrap();
|
|
|
|
let tcp = net::TcpListener::from(socket);
|
|
|
|
tcp.local_addr().unwrap()
|
|
|
|
}
|