use crate::context::Context;
use crate::error::Result;
use crate::middleware::OutboundMiddleware;
use crate::security::headers::SecurityHeaders;
use async_trait::async_trait;
#[derive(Clone)]
pub struct SecurityHeadersMiddleware {
headers: SecurityHeaders,
enabled: bool,
}
impl SecurityHeadersMiddleware {
pub fn new() -> Self {
Self {
headers: SecurityHeaders::new(),
enabled: true,
}
}
pub fn with_headers(headers: SecurityHeaders) -> Self {
Self {
headers,
enabled: true,
}
}
pub fn development() -> Self {
Self {
headers: SecurityHeaders::development(),
enabled: true,
}
}
pub fn strict() -> Self {
Self {
headers: SecurityHeaders::strict(),
enabled: true,
}
}
pub fn disabled() -> Self {
Self {
headers: SecurityHeaders::new(),
enabled: false,
}
}
}
impl Default for SecurityHeadersMiddleware {
fn default() -> Self {
Self::new()
}
}
#[async_trait]
impl OutboundMiddleware for SecurityHeadersMiddleware {
async fn process_response(&self, ctx: &mut Context) -> Result<()> {
if self.enabled {
if let Some(response) = ctx.res.as_mut() {
self.headers.apply_to_headers(&mut response.headers);
}
}
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_security_headers_middleware_creation() {
let middleware = SecurityHeadersMiddleware::new();
assert!(middleware.enabled);
let dev_middleware = SecurityHeadersMiddleware::development();
assert!(dev_middleware.enabled);
let strict_middleware = SecurityHeadersMiddleware::strict();
assert!(strict_middleware.enabled);
let disabled_middleware = SecurityHeadersMiddleware::disabled();
assert!(!disabled_middleware.enabled);
}
#[tokio::test]
async fn test_security_headers_application() {
use crate::http::Request;
use crate::views::ViewEngine;
use std::sync::Arc;
let middleware = SecurityHeadersMiddleware::new();
let request = Request::default();
let views = Arc::new(ViewEngine::from_directory("views"));
let mut ctx = Context::new(request, views);
middleware.process_response(&mut ctx).await.unwrap();
}
}