#![allow(dead_code)]
use std::{
convert::Infallible,
net::SocketAddr,
sync::{Arc, Mutex, MutexGuard},
time::Duration,
};
use http_body_util::{BodyExt as _, Full};
use hyper::{Request, Response, body::Incoming, server::conn::http1, service::service_fn};
use hyper_util::rt::TokioIo;
use tez::{Bytes, HeaderMap, HeaderName, HeaderValue, Method, StatusCode, Uri, Version};
use tokio::{
net::TcpListener,
sync::oneshot,
task::{JoinHandle, JoinSet},
};
type Responder = dyn Fn(&RecordedRequest) -> MockResponse + Send + Sync;
#[derive(Clone, Debug)]
pub(crate) struct RecordedRequest {
pub(crate) method: Method,
pub(crate) uri: Uri,
pub(crate) version: Version,
pub(crate) headers: HeaderMap,
pub(crate) body: Bytes,
}
impl RecordedRequest {
pub(crate) fn path_and_query(&self) -> &str {
self.uri
.path_and_query()
.map_or(self.uri.path(), |target| target.as_str())
}
pub(crate) fn header(&self, name: &str) -> Option<&str> {
self.headers.get(name).and_then(|value| value.to_str().ok())
}
pub(crate) fn header_values(&self, name: &str) -> Vec<&str> {
self.headers
.get_all(name)
.iter()
.filter_map(|value| value.to_str().ok())
.collect()
}
}
#[derive(Clone, Debug)]
pub(crate) struct MockResponse {
status: StatusCode,
headers: HeaderMap,
body: Bytes,
delay: Option<Duration>,
}
impl MockResponse {
pub(crate) fn ok(body: impl Into<Bytes>) -> Self {
Self::with_status(StatusCode::OK, body)
}
pub(crate) fn with_status(status: StatusCode, body: impl Into<Bytes>) -> Self {
Self {
status,
headers: HeaderMap::new(),
body: body.into(),
delay: None,
}
}
pub(crate) fn with_header(mut self, name: impl AsRef<str>, value: impl AsRef<str>) -> Self {
let name = HeaderName::from_bytes(name.as_ref().as_bytes())
.expect("mock response header name must be valid");
let value = HeaderValue::from_bytes(value.as_ref().as_bytes())
.expect("mock response header value must be valid");
self.headers.append(name, value);
self
}
pub(crate) fn with_delay(mut self, delay: Duration) -> Self {
self.delay = Some(delay);
self
}
async fn into_response(self) -> Response<Full<Bytes>> {
if let Some(delay) = self.delay {
tokio::time::sleep(delay).await;
}
let mut response = Response::new(Full::new(self.body));
*response.status_mut() = self.status;
*response.headers_mut() = self.headers;
response
}
}
pub(crate) struct Server {
address: SocketAddr,
requests: Arc<Mutex<Vec<RecordedRequest>>>,
shutdown: Option<oneshot::Sender<()>>,
supervisor: Option<JoinHandle<()>>,
}
pub(crate) struct StreamingServer {
address: SocketAddr,
first_frame: Option<oneshot::Receiver<Bytes>>,
body: Arc<Mutex<Bytes>>,
supervisor: JoinHandle<()>,
}
impl Server {
pub(crate) async fn start(
responder: impl Fn(&RecordedRequest) -> MockResponse + Send + Sync + 'static,
) -> Self {
let listener = TcpListener::bind("127.0.0.1:0")
.await
.expect("mock server must bind to loopback");
let address = listener
.local_addr()
.expect("mock server must expose its address");
let requests = Arc::new(Mutex::new(Vec::new()));
let (shutdown, receiver) = oneshot::channel();
let supervisor = tokio::spawn(run(
listener,
Arc::clone(&requests),
Arc::new(responder),
receiver,
));
Self {
address,
requests,
shutdown: Some(shutdown),
supervisor: Some(supervisor),
}
}
pub(crate) fn url(&self, path: &str) -> String {
format!("http://{}{path}", self.address)
}
pub(crate) const fn port(&self) -> u16 {
self.address.port()
}
pub(crate) fn requests(&self) -> Vec<RecordedRequest> {
lock(&self.requests).clone()
}
pub(crate) async fn shutdown(mut self) {
self.request_shutdown();
if let Some(supervisor) = self.supervisor.take() {
supervisor
.await
.expect("mock server supervisor must finish cleanly");
}
}
fn request_shutdown(&mut self) {
if let Some(shutdown) = self.shutdown.take() {
let _ = shutdown.send(());
}
}
}
impl Drop for Server {
fn drop(&mut self) {
self.request_shutdown();
if let Some(supervisor) = self.supervisor.take() {
supervisor.abort();
}
}
}
impl StreamingServer {
pub(crate) async fn start() -> Self {
let listener = TcpListener::bind("127.0.0.1:0")
.await
.expect("streaming server must bind to loopback");
let address = listener
.local_addr()
.expect("streaming server must expose its address");
let body = Arc::new(Mutex::new(Bytes::new()));
let (first_frame_sender, first_frame) = oneshot::channel();
let first_frame_sender = Arc::new(Mutex::new(Some(first_frame_sender)));
let stored_body = Arc::clone(&body);
let supervisor = tokio::spawn(async move {
let (stream, _) = listener
.accept()
.await
.expect("streaming server must accept a request");
let service = service_fn(move |request| {
record_stream(
request,
Arc::clone(&first_frame_sender),
Arc::clone(&stored_body),
)
});
let _ = http1::Builder::new()
.serve_connection(TokioIo::new(stream), service)
.await;
});
Self {
address,
first_frame: Some(first_frame),
body,
supervisor,
}
}
pub(crate) fn url(&self) -> String {
format!("http://{}/stream", self.address)
}
pub(crate) async fn first_frame(&mut self) -> Bytes {
self.first_frame
.take()
.expect("the first frame can be observed once")
.await
.expect("the request must contain a data frame")
}
pub(crate) fn body(&self) -> Bytes {
lock(&self.body).clone()
}
pub(crate) async fn finish(mut self) {
if tokio::time::timeout(Duration::from_secs(2), &mut self.supervisor)
.await
.is_err()
{
self.supervisor.abort();
}
}
}
async fn run(
listener: TcpListener,
requests: Arc<Mutex<Vec<RecordedRequest>>>,
responder: Arc<Responder>,
mut shutdown: oneshot::Receiver<()>,
) {
let mut connections = JoinSet::new();
loop {
tokio::select! {
_ = &mut shutdown => break,
accepted = listener.accept() => {
let (stream, _) = accepted.expect("mock server must accept requests");
let requests = Arc::clone(&requests);
let responder = Arc::clone(&responder);
connections.spawn(async move {
let service = service_fn(move |request| {
handle(request, Arc::clone(&requests), Arc::clone(&responder))
});
http1::Builder::new()
.serve_connection(TokioIo::new(stream), service)
.await
});
}
completed = connections.join_next(), if !connections.is_empty() => {
inspect_connection(completed);
}
}
}
connections.abort_all();
while let Some(completed) = connections.join_next().await {
if !completed
.as_ref()
.is_err_and(tokio::task::JoinError::is_cancelled)
{
inspect_connection(Some(completed));
}
}
}
async fn handle(
request: Request<Incoming>,
requests: Arc<Mutex<Vec<RecordedRequest>>>,
responder: Arc<Responder>,
) -> Result<Response<Full<Bytes>>, Infallible> {
let (parts, body) = request.into_parts();
let body = body
.collect()
.await
.expect("mock server must read the request body")
.to_bytes();
let request = RecordedRequest {
method: parts.method,
uri: parts.uri,
version: parts.version,
headers: parts.headers,
body,
};
lock(&requests).push(request.clone());
Ok(responder(&request).into_response().await)
}
async fn record_stream(
request: Request<Incoming>,
first_frame: Arc<Mutex<Option<oneshot::Sender<Bytes>>>>,
stored_body: Arc<Mutex<Bytes>>,
) -> Result<Response<Full<Bytes>>, Infallible> {
let mut body = request.into_body();
let mut received = Vec::new();
while let Some(frame) = body.frame().await {
let Ok(frame) = frame else {
break;
};
let Ok(data) = frame.into_data() else {
continue;
};
if let Some(sender) = lock(&first_frame).take() {
let _ = sender.send(data.clone());
}
received.extend_from_slice(&data);
}
*lock(&stored_body) = Bytes::from(received);
Ok(Response::new(Full::new(Bytes::from_static(b"streamed"))))
}
fn inspect_connection(completed: Option<Result<Result<(), hyper::Error>, tokio::task::JoinError>>) {
match completed {
Some(Ok(Ok(()))) | None => {}
Some(Ok(Err(error))) if error.is_incomplete_message() => {}
Some(Ok(Err(error))) => panic!("mock HTTP connection failed: {error}"),
Some(Err(error)) if error.is_cancelled() => {}
Some(Err(error)) => panic!("mock HTTP task failed: {error}"),
}
}
fn lock<T>(mutex: &Mutex<T>) -> MutexGuard<'_, T> {
mutex
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
}