rjango 0.1.1

use crate::http::{HttpResponse, request::HttpRequest};

pub trait MiddlewareHook: Send + Sync {
    fn process_request(&self, _request: &HttpRequest) -> Option<HttpResponse> {
        None
    }

    fn process_response(&self, _request: &HttpRequest, response: HttpResponse) -> HttpResponse {
        response
    }

    fn process_view(&self, _request: &HttpRequest, _view_name: &str) -> Option<HttpResponse> {
        None
    }

    fn process_exception(&self, _request: &HttpRequest, _error: &str) -> Option<HttpResponse> {
        None
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use bytes::Bytes;
    use http::{HeaderMap, Method, StatusCode, Uri};

    struct TestHook;

    impl MiddlewareHook for TestHook {}

    fn request() -> HttpRequest {
        HttpRequest::from_axum(
            Method::GET,
            "/middleware/".parse::<Uri>().expect("valid uri"),
            HeaderMap::new(),
            Bytes::new(),
        )
    }

    #[test]
    fn default_process_request_returns_none() {
        let hook = TestHook;

        assert!(hook.process_request(&request()).is_none());
    }

    #[test]
    fn default_process_response_returns_original_response() {
        let hook = TestHook;
        let original = HttpResponse::with_status(StatusCode::CREATED, "created");
        let processed = hook.process_response(&request(), original.clone());

        assert_eq!(processed.status_code, original.status_code);
        assert_eq!(processed.content, original.content);
    }

    #[test]
    fn default_view_and_exception_hooks_return_none() {
        let hook = TestHook;
        let request = request();

        assert!(hook.process_view(&request, "index").is_none());
        assert!(hook.process_exception(&request, "boom").is_none());
    }
}