Enum HealthStatus

Source

pub enum HealthStatus {
    Healthy,
    Unhealthy,
    Uncheckable,
}

Expand description

A trait for implementing test server abstractions for different web frameworks.

This trait provides a generic interface for launching and managing test servers for various web frameworks (e.g., Axum, Warp, actix-web). It allows the TestClient to work with any server implementation in a framework-agnostic way.

§Associated Types

Error: Error type that can occur during server operations

§Required Methods

launch: Starts the server with the provided TcpListener

§Optional Methods

is_healthy: Checks if the server is ready to accept requests
config: Provides configuration for the test framework

§Example

use clawspec_core::test_client::{TestServer, TestServerConfig, HealthStatus};
use std::net::TcpListener;
use std::time::Duration;

#[derive(Debug)]
struct ServerError;

impl std::fmt::Display for ServerError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "Server error")
    }
}

impl std::error::Error for ServerError {}

#[derive(Debug)]
struct MyTestServer;

impl TestServer for MyTestServer {
    type Error = ServerError;

    async fn launch(&self, listener: TcpListener) -> Result<(), Self::Error> {
        // Convert to non-blocking for tokio compatibility
        listener.set_nonblocking(true).map_err(|_| ServerError)?;
        let tokio_listener = tokio::net::TcpListener::from_std(listener)
            .map_err(|_| ServerError)?;
         
        // Start your web server here
        // For example, with axum:
        // axum::serve(tokio_listener, app).await.map_err(|_| ServerError)?;
        Ok(())
    }

    async fn is_healthy(&self, client: &mut clawspec_core::ApiClient) -> Result<HealthStatus, Self::Error> {
        // Check if server is ready by making a health check request
        match client.get("/health").unwrap().await {
            Ok(_) => Ok(HealthStatus::Healthy),
            Err(_) => Ok(HealthStatus::Unhealthy),
        }
    }

    fn config(&self) -> TestServerConfig {
        TestServerConfig {
            api_client: Some(
                clawspec_core::ApiClient::builder()
                    .with_host("localhost")
                    .with_base_path("/api").unwrap()
            ),
            min_backoff_delay: Duration::from_millis(10),
            max_backoff_delay: Duration::from_secs(1),
            backoff_jitter: true,
            max_retry_attempts: 10,
        }
    }
}

§Framework Integration

§Framework Integration Example

use clawspec_core::test_client::{TestServer, TestServerConfig};
use std::net::TcpListener;

#[derive(Debug)]
struct WebFrameworkTestServer {
    // Your web framework's app/router would go here
    // For example: app: axum::Router, or app: warp::Filter, etc.
}

impl WebFrameworkTestServer {
    fn new(/* app: YourApp */) -> Self {
        Self { /* app */ }
    }
}

impl TestServer for WebFrameworkTestServer {
    type Error = std::io::Error; // or your custom error type

    async fn launch(&self, listener: TcpListener) -> Result<(), Self::Error> {
        listener.set_nonblocking(true)?;
        let tokio_listener = tokio::net::TcpListener::from_std(listener)?;
         
        // Start your web framework here:
        // For Axum: axum::serve(tokio_listener, self.app.clone()).await?;
        // For Warp: warp::serve(self.app.clone()).run_async(tokio_listener).await;
        // For actix-web: HttpServer::new(|| self.app.clone()).listen(tokio_listener)?.run().await?;
        Ok(())
    }
}