tez 0.0.3

A lightweight, ergonomic, and fast high-level HTTP client for Rust
Documentation
//! HTTP mock support for `tez` subprocess specifications.

#![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)
}