Testing Web Services

use axum::{body::Body, http::{Request, StatusCode}, Router};
use tower::ServiceExt; // oneshot
 
#[tokio::test]
async fn health_returns_ok() {
    let app = Router::new().route("/health", axum::routing::get(|| async { "ok" }));
    let response = app
        .oneshot(Request::builder().uri("/health").body(Body::empty()).unwrap())
        .await
        .unwrap();
    assert_eq!(response.status(), StatusCode::OK);
}

use axum::{
    body::Body,
    extract::State,
    http::{Request, StatusCode},
    routing::{get, post},
    Json, Router,
};
use serde::{Deserialize, Serialize};
use tower::ServiceExt;
 
#[derive(Clone, Default)]
struct AppState { counter: std::sync::Arc<tokio::sync::Mutex<u32>> }
 
#[derive(Serialize)]
struct Count { value: u32 }
 
#[derive(Deserialize)]
struct Add { n: u32 }
 
async fn get_count(State(s): State<AppState>) -> Json<Count> {
    Json(Count { value: *s.counter.lock().await })
}
 
async fn add(State(s): State<AppState>, Json(body): Json<Add>) -> StatusCode {
    *s.counter.lock().await += body.n;
    StatusCode::NO_CONTENT
}
 
fn app(state: AppState) -> Router {
    Router::new()
        .route("/count", get(get_count).post(add))
        .with_state(state)
}
 
#[tokio::test]
async fn increments_counter() {
    let state = AppState::default();
    let mut app = app(state);
 
    let post = Request::builder()
        .method("POST")
        .uri("/count")
        .header("content-type", "application/json")
        .body(Body::from(r#"{"n":2}"#))
        .unwrap();
    let res = app.oneshot(post).await.unwrap();
    assert_eq!(res.status(), StatusCode::NO_CONTENT);
 
    let get = Request::builder().uri("/count").body(Body::empty()).unwrap();
    let res = app.oneshot(get).await.unwrap();
    assert_eq!(res.status(), StatusCode::OK);
    let bytes = axum::body::to_bytes(res.into_body(), usize::MAX).await.unwrap();
    assert!(String::from_utf8_lossy(&bytes).contains(r#""value":2"#));
}

// Helper to build JSON requests
fn json_request(method: &str, uri: &str, body: &str) -> Request<Body> {
    Request::builder()
        .method(method)
        .uri(uri)
        .header("content-type", "application/json")
        .body(Body::from(body.to_string()))
        .unwrap()
}