Struct SimpleHandler 

pub struct SimpleHandler<F>
where
    F: Fn(Request) -> Result<Response, Error> + Send + Sync + 'static,
{ /* private fields */ }

Simple handler wrapper for testing

Provides a convenient way to create handlers from closures for testing purposes. The handler function can be any closure that takes a Request and returns a Result<Response>.

Examples

Basic usage

use reinhardt_testkit::mock::SimpleHandler;
use reinhardt_http::{Request, Response};
use reinhardt_http::Handler;

let handler = SimpleHandler::new(|req: Request| {
    Ok(Response::ok().with_body("Hello, World!"))
});

// Use handler in tests

With path-based routing

use reinhardt_testkit::mock::SimpleHandler;
use reinhardt_http::{Request, Response};

let handler = SimpleHandler::new(|req: Request| {
    match req.path() {
        "/" => Ok(Response::ok().with_body("Home")),
        "/api" => Ok(Response::ok().with_body(r#"{"status": "ok"}"#)),
        _ => Ok(Response::not_found().with_body("Not Found")),
    }
});

With custom logic

use reinhardt_testkit::mock::SimpleHandler;
use reinhardt_http::{Request, Response};
use std::sync::{Arc, Mutex};

let call_count = Arc::new(Mutex::new(0));
let call_count_clone = call_count.clone();

let handler = SimpleHandler::new(move |req: Request| {
    let mut count = call_count_clone.lock().unwrap();
    *count += 1;
    Ok(Response::ok().with_body(format!("Call count: {}", *count)))
});

Implementations

impl<F> SimpleHandler<F>

where F: Fn(Request) -> Result<Response, Error> + Send + Sync + 'static,

pub fn new(handler_fn: F) -> SimpleHandler<F>

Create a new SimpleHandler with the given handler function

Arguments

• handler_fn - A closure that processes requests and returns responses

Examples

use reinhardt_testkit::mock::SimpleHandler;
use reinhardt_http::{Request, Response};

let handler = SimpleHandler::new(|req| {
    Ok(Response::ok().with_body("Success"))
});

Trait Implementations

impl<F> Handler for SimpleHandler<F>

where F: Fn(Request) -> Result<Response, Error> + Send + Sync + 'static,

fn handle<'life0, 'async_trait>( &'life0 self, request: Request, ) -> Pin<Box<dyn Future<Output = Result<Response, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, SimpleHandler<F>: 'async_trait,

Handles an HTTP request and produces a response.