Skip to main content

auth_framework/api/
server.rs

1//! REST API Server Implementation
2//!
3//! Main server that hosts all API endpoints
4
5use crate::AuthFramework;
6#[cfg(feature = "saml")]
7use crate::api::saml;
8use crate::api::{
9    ApiState, admin, advanced_protocols, auth, email_verification, health, mfa, middleware,
10    oauth_advanced, oauth2, openapi, users, webauthn,
11};
12use axum::{
13    Router,
14    extract::DefaultBodyLimit,
15    http::Method,
16    middleware as axum_middleware,
17    routing::{delete, get, post, put},
18};
19use std::net::SocketAddr;
20use std::sync::Arc;
21use tower::ServiceBuilder;
22use tower_http::{cors::CorsLayer, trace::TraceLayer};
23use tracing::info;
24
25/// REST API server configuration.
26///
27/// Use [`ApiServerConfig::builder()`] for ergonomic construction:
28///
29/// ```rust,ignore
30/// let config = ApiServerConfig::builder()
31///     .host("0.0.0.0")
32///     .port(3000)
33///     .enable_cors(true)
34///     .allow_origin("https://example.com")
35///     .build();
36/// ```
37///
38/// Default values bind to `127.0.0.1:8080` with tracing enabled, CORS disabled,
39/// and a 1 MB maximum request body.
40#[derive(Debug, Clone)]
41pub struct ApiServerConfig {
42    /// Address to bind the server to (default: `"127.0.0.1"`).
43    pub host: String,
44    /// TCP port to listen on (default: `8080`).
45    pub port: u16,
46    /// Centralized CORS configuration. Enable and set `allowed_origins` to
47    /// permit cross-origin requests. Origins are validated strictly — wildcard
48    /// (`"*"`) is never accepted.
49    pub cors: crate::config::CorsConfig,
50    /// Maximum allowed request body size in bytes (default: 1 MB).
51    pub max_body_size: usize,
52    /// Whether to attach a `tower_http::TraceLayer` for structured request/response logging.
53    pub enable_tracing: bool,
54}
55
56impl ApiServerConfig {
57    /// Convenience: is CORS enabled?
58    pub fn enable_cors(&self) -> bool {
59        self.cors.enabled
60    }
61}
62
63impl Default for ApiServerConfig {
64    fn default() -> Self {
65        Self {
66            host: "127.0.0.1".to_string(),
67            port: 8080,
68            cors: crate::config::CorsConfig::default(), // disabled by default
69            max_body_size: 1024 * 1024,                 // 1MB
70            enable_tracing: true,
71        }
72    }
73}
74
75/// REST API Server
76impl ApiServerConfig {
77    /// Create a new builder for `ApiServerConfig`
78    pub fn builder() -> ApiServerConfigBuilder {
79        ApiServerConfigBuilder::default()
80    }
81}
82
83/// Fluent builder for [`ApiServerConfig`].
84///
85/// Obtain via [`ApiServerConfig::builder()`].  All fields start with the same
86/// defaults as `ApiServerConfig::default()`.
87#[derive(Default)]
88pub struct ApiServerConfigBuilder {
89    config: ApiServerConfig,
90}
91
92impl ApiServerConfigBuilder {
93    /// Set the address to bind to (e.g. `"0.0.0.0"`).
94    pub fn host(mut self, host: impl Into<String>) -> Self {
95        self.config.host = host.into();
96        self
97    }
98
99    /// Set the TCP port (e.g. `3000`).
100    pub fn port(mut self, port: u16) -> Self {
101        self.config.port = port;
102        self
103    }
104
105    /// Enable or disable CORS (default: disabled).
106    pub fn enable_cors(mut self, enable: bool) -> Self {
107        self.config.cors.enabled = enable;
108        self
109    }
110
111    /// Append a single allowed origin for CORS (e.g. `"https://example.com"`).
112    pub fn allow_origin(mut self, origin: impl Into<String>) -> Self {
113        self.config.cors.allowed_origins.push(origin.into());
114        self
115    }
116
117    /// Replace the allowed origins list for CORS.
118    pub fn allowed_origins(mut self, origins: Vec<String>) -> Self {
119        self.config.cors.allowed_origins = origins;
120        self
121    }
122
123    /// Set the maximum request body size in bytes (default: 1 MB).
124    pub fn max_body_size(mut self, size: usize) -> Self {
125        self.config.max_body_size = size;
126        self
127    }
128
129    /// Enable or disable structured request/response tracing (default: enabled).
130    pub fn enable_tracing(mut self, enable: bool) -> Self {
131        self.config.enable_tracing = enable;
132        self
133    }
134
135    /// Consume the builder and return the finished [`ApiServerConfig`].
136    pub fn build(self) -> ApiServerConfig {
137        self.config
138    }
139}
140
141/// The REST API server that hosts all authentication, user-management,
142/// and health-check endpoints.
143///
144/// # Example
145///
146/// ```rust,ignore
147/// let server = ApiServer::with_config(auth.clone(), config);
148/// server.start().await?;
149/// ```
150pub struct ApiServer {
151    config: ApiServerConfig,
152    auth_framework: Arc<AuthFramework>,
153    email_verification_sender: Option<Arc<dyn super::email_verification::EmailVerificationSender>>,
154    trusted_proxies: Vec<std::net::IpAddr>,
155}
156
157impl ApiServer {
158    /// Create a server with the default [`ApiServerConfig`].
159    pub fn new(auth_framework: Arc<AuthFramework>) -> Self {
160        Self {
161            config: ApiServerConfig::default(),
162            auth_framework,
163            email_verification_sender: None,
164            trusted_proxies: Vec::new(),
165        }
166    }
167
168    /// Create a server with a custom [`ApiServerConfig`].
169    pub fn with_config(auth_framework: Arc<AuthFramework>, config: ApiServerConfig) -> Self {
170        Self {
171            config,
172            auth_framework,
173            email_verification_sender: None,
174            trusted_proxies: Vec::new(),
175        }
176    }
177
178    /// Declare the reverse proxies in front of this server (by the peer address they
179    /// connect from). Only requests arriving from these addresses have their
180    /// `X-Forwarded-For` header believed when identifying the client for rate limiting;
181    /// from anyone else the header is ignored.
182    pub fn with_trusted_proxies(mut self, proxies: Vec<std::net::IpAddr>) -> Self {
183        self.trusted_proxies = proxies;
184        self
185    }
186
187    /// Install the channel that delivers email-verification tokens. Without one, the
188    /// verification endpoints cannot deliver anything and email verification cannot complete.
189    pub fn with_email_verification_sender(
190        mut self,
191        sender: Arc<dyn super::email_verification::EmailVerificationSender>,
192    ) -> Self {
193        self.email_verification_sender = Some(sender);
194        self
195    }
196
197    /// Assemble the Axum [`Router`] with all route groups and middleware.
198    pub async fn build_router(&self) -> crate::errors::Result<Router> {
199        let mut state = ApiState::new(self.auth_framework.clone()).await?;
200        state.email_verification_sender = self.email_verification_sender.clone();
201        state.trusted_proxies = self.trusted_proxies.clone();
202
203        // Create nested router for API v1
204        let api_v1 = Router::new()
205            // Health and monitoring endpoints (public)
206            .route("/health", get(health::health_check))
207            .route("/health/detailed", get(health::detailed_health_check))
208            .route("/metrics", get(health::metrics))
209            .route("/readiness", get(health::readiness_check))
210            .route("/liveness", get(health::liveness_check))
211            // Authentication endpoints (public)
212            .route("/auth/login", post(auth::login))
213            .route("/auth/register", post(auth::register))
214            .route("/auth/refresh", post(auth::refresh_token))
215            .route("/auth/logout", post(auth::logout))
216            .route("/auth/validate", get(auth::validate_token))
217            .route("/auth/providers", get(auth::list_providers))
218            .route("/api-keys", post(auth::create_api_key))
219            // Email verification endpoints
220            .route(
221                "/auth/verify-email/send",
222                post(email_verification::send_verification),
223            )
224            .route("/auth/verify-email", post(email_verification::verify_email))
225            .route(
226                "/auth/resend-verification",
227                post(email_verification::resend_verification),
228            )
229            // OAuth 2.0 endpoints
230            .route("/oauth/authorize", get(oauth2::authorize))
231            .route("/oauth/token", post(oauth2::token))
232            .route("/oauth/revoke", post(oauth2::revoke))
233            // RFC 7662: Token Introspection (form-encoded, client auth required)
234            .route("/oauth/introspect", post(oauth_advanced::introspect_token))
235            // RFC 9126: Pushed Authorization Requests
236            .route(
237                "/oauth/par",
238                post(oauth_advanced::pushed_authorization_request),
239            )
240            .route("/oauth/clients/{client_id}", get(oauth2::get_client_info))
241            // RFC 8628: Device Authorization Grant
242            .route("/oauth/device", post(oauth_advanced::device_authorization))
243            // OpenID Connect CIBA (Client Initiated Backchannel Auth)
244            .route("/oauth/ciba", post(oauth_advanced::ciba_backchannel_auth))
245            // OIDC UserInfo endpoint
246            .route("/oauth/userinfo", get(oauth2::userinfo))
247            // OIDC RP-Initiated Logout
248            .route("/oauth/end_session", get(oauth2::end_session))
249            // RFC 7591: Dynamic Client Registration
250            .route("/oauth/register", post(oauth2::register_client))
251            // OpenID Connect Discovery
252            .route(
253                "/.well-known/openid-configuration",
254                get(oauth2::openid_configuration),
255            )
256            // JWKS endpoint
257            .route("/.well-known/jwks.json", get(oauth2::jwks))
258            // User management endpoints (authenticated)
259            .route("/users/me", get(oauth2::users_me))
260            .route("/users/profile", get(users::get_profile))
261            .route("/users/profile", put(users::update_profile))
262            .route("/users/change-password", post(users::change_password))
263            .route("/users/sessions", get(users::get_sessions))
264            .route(
265                "/users/sessions/{session_id}",
266                delete(users::revoke_session),
267            )
268            .route("/users/{user_id}/profile", get(users::get_user_profile))
269            // Multi-factor authentication endpoints (authenticated)
270            .route("/mfa/setup", post(mfa::setup_mfa))
271            .route("/mfa/verify", post(mfa::verify_mfa))
272            .route("/mfa/disable", post(mfa::disable_mfa))
273            .route("/mfa/status", get(mfa::get_mfa_status))
274            .route(
275                "/mfa/regenerate-backup-codes",
276                post(mfa::regenerate_backup_codes),
277            )
278            .route("/mfa/verify-backup-code", post(mfa::verify_backup_code))
279            // Administrative endpoints (admin only)
280            .route("/admin/users", get(admin::list_users))
281            .route("/admin/users", post(admin::create_user))
282            .route(
283                "/admin/users/{user_id}/roles",
284                put(admin::update_user_roles),
285            )
286            .route("/admin/users/{user_id}", delete(admin::delete_user))
287            .route("/admin/users/{user_id}/activate", put(admin::activate_user))
288            .route("/admin/stats", get(admin::get_system_stats))
289            .route("/admin/audit-logs", get(admin::get_audit_logs))
290            .route("/admin/audit-logs/stats", get(admin::get_audit_log_stats))
291            .route(
292                "/admin/config",
293                get(admin::get_config).put(admin::update_config),
294            )
295            // WebAuthn endpoints
296            .route(
297                "/webauthn/registration/init",
298                post(webauthn::webauthn_registration_init),
299            )
300            .route(
301                "/webauthn/registration/complete",
302                post(webauthn::webauthn_registration_complete),
303            )
304            .route(
305                "/webauthn/authentication/init",
306                post(webauthn::webauthn_authentication_init),
307            )
308            .route(
309                "/webauthn/authentication/complete",
310                post(webauthn::webauthn_authentication_complete),
311            )
312            .route(
313                "/webauthn/credentials/{username}",
314                get(webauthn::list_webauthn_credentials),
315            )
316            .route(
317                "/webauthn/credentials/{username}/{credential_id}",
318                delete(webauthn::delete_webauthn_credential),
319            );
320
321        // Build the router with conditional SAML routes
322        let api_v1 = {
323            let router = api_v1;
324
325            #[cfg(feature = "saml")]
326            {
327                router
328                    .route("/saml/metadata", get(saml::get_saml_metadata))
329                    .route("/saml/sso", post(saml::initiate_saml_sso))
330                    .route("/saml/acs", post(saml::handle_saml_acs))
331                    .route("/saml/slo", post(saml::initiate_saml_slo))
332                    .route("/saml/slo/response", get(saml::handle_saml_slo_response))
333                    .route("/saml/assertion", post(saml::create_saml_assertion))
334                    .route("/saml/idps", get(saml::list_saml_idps))
335            }
336
337            #[cfg(not(feature = "saml"))]
338            {
339                router
340            }
341        };
342
343        // Create the main router with all routes
344        let router = Router::new()
345            .route("/api/openapi.json", get(openapi::serve_openapi_json))
346            .route("/docs", get(openapi::serve_swagger_ui))
347            .nest("/api/v1", api_v1)
348            .merge(advanced_protocols::router())
349            .with_state(state.clone());
350
351        // Add middleware layers
352        let middleware_stack = ServiceBuilder::new()
353            .layer(axum_middleware::from_fn(middleware::timeout_middleware))
354            .layer(axum_middleware::from_fn(
355                middleware::security_headers_middleware,
356            ))
357            .layer(axum_middleware::from_fn({
358                let state = state.clone();
359                move |request, next| {
360                    let state = state.clone();
361                    async move {
362                        middleware::rate_limit_middleware_with_state(state, request, next).await
363                    }
364                }
365            }))
366            .layer(axum_middleware::from_fn(middleware::logging_middleware));
367
368        let router = if self.config.cors.enabled {
369            if self.config.cors.allowed_origins.is_empty() {
370                tracing::warn!(
371                    "SECURITY/CORS: CORS is enabled but allowed_origins is empty. All cross-origin requests will be rejected! Disable CORS or add allowed origins."
372                );
373            }
374
375            let header_origins: Vec<axum::http::HeaderValue> = self
376                .config
377                .cors
378                .allowed_origins
379                .iter()
380                .filter_map(|o| o.parse::<axum::http::HeaderValue>().ok())
381                .collect();
382
383            if header_origins.is_empty() && !self.config.cors.allowed_origins.is_empty() {
384                tracing::warn!(
385                    "CORS: none of the configured allowed_origins could be parsed as valid HTTP \
386                     header values; cross-origin requests will be rejected"
387                );
388            }
389
390            let allow_origin = tower_http::cors::AllowOrigin::list(header_origins);
391
392            let allowed_methods: Vec<Method> = self
393                .config
394                .cors
395                .allowed_methods
396                .iter()
397                .filter_map(|m| m.parse::<Method>().ok())
398                .collect();
399
400            let allowed_headers: Vec<axum::http::HeaderName> = self
401                .config
402                .cors
403                .allowed_headers
404                .iter()
405                .filter_map(|h| h.parse::<axum::http::HeaderName>().ok())
406                .collect();
407
408            router.layer(
409                CorsLayer::new()
410                    .allow_origin(allow_origin)
411                    .allow_methods(allowed_methods)
412                    .allow_headers(allowed_headers)
413                    .max_age(std::time::Duration::from_secs(
414                        self.config.cors.max_age_secs as u64,
415                    )),
416            )
417        } else {
418            router
419        };
420
421        let router = if self.config.enable_tracing {
422            router.layer(TraceLayer::new_for_http())
423        } else {
424            router
425        };
426
427        Ok(router
428            .layer(middleware_stack)
429            .layer(DefaultBodyLimit::max(self.config.max_body_size)))
430    }
431
432    /// Start the API server
433    pub async fn start(&self) -> Result<(), Box<dyn std::error::Error>> {
434        let app = self.build_router().await?;
435
436        let addr = SocketAddr::new(self.config.host.parse()?, self.config.port);
437
438        info!("🚀 AuthFramework API server starting on http://{}", addr);
439        info!("📖 API documentation available at http://{}/docs", addr);
440        info!(
441            "📘 OpenAPI JSON available at http://{}/api/openapi.json",
442            addr
443        );
444        info!("🏥 Health check available at http://{}/health", addr);
445        info!("📊 Metrics available at http://{}/metrics", addr);
446
447        let listener = tokio::net::TcpListener::bind(addr).await?;
448        axum::serve(
449            listener,
450            app.into_make_service_with_connect_info::<SocketAddr>(),
451        )
452        .await?;
453
454        Ok(())
455    }
456
457    /// Get server configuration
458    pub fn config(&self) -> &ApiServerConfig {
459        &self.config
460    }
461
462    /// Get server address
463    pub fn address(&self) -> String {
464        format!("{}:{}", self.config.host, self.config.port)
465    }
466}
467
468/// Create a basic API server with default configuration
469pub async fn create_api_server(auth_framework: Arc<AuthFramework>) -> ApiServer {
470    ApiServer::new(auth_framework)
471}
472
473/// Create an API server with custom host and port
474pub async fn create_api_server_with_address(
475    auth_framework: Arc<AuthFramework>,
476    host: impl Into<String>,
477    port: u16,
478) -> ApiServer {
479    let config = ApiServerConfig {
480        host: host.into(),
481        port,
482        ..Default::default()
483    };
484    ApiServer::with_config(auth_framework, config)
485}
486
487#[cfg(test)]
488mod tests {
489    use super::*;
490    use crate::storage::memory::InMemoryStorage;
491    use crate::{AuthConfig, AuthFramework};
492    use axum::body::Body;
493    use axum::http::{Request, StatusCode};
494    use tower::ServiceExt;
495
496    async fn create_test_api_server() -> ApiServer {
497        let _storage = Arc::new(InMemoryStorage::new());
498        let config = AuthConfig::default();
499        let auth_framework = Arc::new(AuthFramework::new(config));
500        ApiServer::new(auth_framework)
501    }
502
503    #[tokio::test]
504    async fn test_health_endpoint() {
505        let api_server = create_test_api_server().await;
506        let router = api_server.build_router().await.unwrap();
507
508        let request = Request::builder()
509            .uri("/api/v1/health")
510            .method("GET")
511            .body(Body::empty())
512            .unwrap();
513
514        let response = router.oneshot(request).await.unwrap();
515        assert_eq!(response.status(), StatusCode::OK);
516    }
517
518    #[tokio::test]
519    async fn test_auth_required_endpoints() {
520        let api_server = create_test_api_server().await;
521        let router = api_server.build_router().await.unwrap();
522
523        let request = Request::builder()
524            .uri("/api/v1/users/profile")
525            .method("GET")
526            .body(Body::empty())
527            .unwrap();
528
529        let response = router.oneshot(request).await.unwrap();
530        // Protected endpoint should reject request without auth
531        assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
532    }
533
534    #[tokio::test]
535    async fn test_cors_headers() {
536        let config = AuthConfig::default();
537        let auth_framework = Arc::new(AuthFramework::new(config));
538        let api_config = ApiServerConfig {
539            cors: crate::config::CorsConfig {
540                enabled: true,
541                allowed_origins: vec!["http://localhost:3000".to_string()],
542                ..crate::config::CorsConfig::default()
543            },
544            ..ApiServerConfig::default()
545        };
546        let api_server = ApiServer::with_config(auth_framework, api_config);
547        let router = api_server.build_router().await.unwrap();
548
549        let request = Request::builder()
550            .uri("/api/v1/health")
551            .method("GET")
552            .header("Origin", "http://localhost:3000")
553            .body(Body::empty())
554            .unwrap();
555
556        let response = router.oneshot(request).await.unwrap();
557        assert_eq!(response.status(), StatusCode::OK);
558
559        // Check CORS headers are present when a matching Origin is sent
560        assert!(
561            response
562                .headers()
563                .contains_key("access-control-allow-origin")
564        );
565    }
566
567    #[tokio::test]
568    async fn test_readiness_endpoint() {
569        let api_server = create_test_api_server().await;
570        let router = api_server.build_router().await.unwrap();
571
572        let request = Request::builder()
573            .uri("/api/v1/readiness")
574            .method("GET")
575            .body(Body::empty())
576            .unwrap();
577
578        let response = router.oneshot(request).await.unwrap();
579        // Should be OK or SERVICE_UNAVAILABLE, not a 404
580        assert!(
581            response.status() == StatusCode::OK
582                || response.status() == StatusCode::SERVICE_UNAVAILABLE
583        );
584    }
585
586    #[tokio::test]
587    async fn test_liveness_endpoint() {
588        let api_server = create_test_api_server().await;
589        let router = api_server.build_router().await.unwrap();
590
591        let request = Request::builder()
592            .uri("/api/v1/liveness")
593            .method("GET")
594            .body(Body::empty())
595            .unwrap();
596
597        let response = router.oneshot(request).await.unwrap();
598        assert_eq!(response.status(), StatusCode::OK);
599    }
600
601    #[tokio::test]
602    async fn test_metrics_endpoint() {
603        let api_server = create_test_api_server().await;
604        let router = api_server.build_router().await.unwrap();
605
606        let request = Request::builder()
607            .uri("/api/v1/metrics")
608            .method("GET")
609            .body(Body::empty())
610            .unwrap();
611
612        let response = router.oneshot(request).await.unwrap();
613        assert_eq!(response.status(), StatusCode::OK);
614    }
615
616    #[tokio::test]
617    async fn test_nonexistent_route_returns_404() {
618        let api_server = create_test_api_server().await;
619        let router = api_server.build_router().await.unwrap();
620
621        let request = Request::builder()
622            .uri("/api/v1/this-does-not-exist")
623            .method("GET")
624            .body(Body::empty())
625            .unwrap();
626
627        let response = router.oneshot(request).await.unwrap();
628        assert_eq!(response.status(), StatusCode::NOT_FOUND);
629    }
630
631    #[tokio::test]
632    async fn test_login_with_empty_body() {
633        let api_server = create_test_api_server().await;
634        let router = api_server.build_router().await.unwrap();
635
636        let request = Request::builder()
637            .uri("/api/v1/auth/login")
638            .method("POST")
639            .header("Content-Type", "application/json")
640            .body(Body::from("{}"))
641            .unwrap();
642
643        let response = router.oneshot(request).await.unwrap();
644        // Should return an error (400 or 422), not 200
645        assert_ne!(response.status(), StatusCode::OK);
646    }
647
648    #[tokio::test]
649    async fn test_register_endpoint_accessible() {
650        let api_server = create_test_api_server().await;
651        let router = api_server.build_router().await.unwrap();
652
653        let body = serde_json::json!({
654            "username": "newuser",
655            "password": "StrongP@ssw0rd123!",
656            "email": "test@example.com"
657        });
658
659        let request = Request::builder()
660            .uri("/api/v1/auth/register")
661            .method("POST")
662            .header("Content-Type", "application/json")
663            .body(Body::from(serde_json::to_string(&body).unwrap()))
664            .unwrap();
665
666        let response = router.oneshot(request).await.unwrap();
667        // It should process the request (not 404 or 405)
668        assert_ne!(response.status(), StatusCode::NOT_FOUND);
669        assert_ne!(response.status(), StatusCode::METHOD_NOT_ALLOWED);
670    }
671
672    #[tokio::test]
673    async fn test_server_config_defaults() {
674        let config = ApiServerConfig::default();
675        assert_eq!(config.host, "127.0.0.1");
676        assert_eq!(config.port, 8080);
677        assert!(!config.enable_cors());
678    }
679
680    #[tokio::test]
681    async fn test_server_address() {
682        let api_server = create_test_api_server().await;
683        assert_eq!(api_server.address(), "127.0.0.1:8080");
684    }
685
686    #[tokio::test]
687    async fn test_create_api_server_with_address() {
688        let config = AuthConfig::default();
689        let auth_framework = Arc::new(AuthFramework::new(config));
690        let api_server = create_api_server_with_address(auth_framework, "0.0.0.0", 8080).await;
691        assert_eq!(api_server.address(), "0.0.0.0:8080");
692    }
693
694    #[tokio::test]
695    async fn test_admin_endpoints_require_auth() {
696        let api_server = create_test_api_server().await;
697        let router = api_server.build_router().await.unwrap();
698
699        let request = Request::builder()
700            .uri("/api/v1/admin/users")
701            .method("GET")
702            .body(Body::empty())
703            .unwrap();
704
705        let response = router.oneshot(request).await.unwrap();
706        assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
707    }
708
709    #[tokio::test]
710    async fn test_security_headers_present() {
711        let api_server = create_test_api_server().await;
712        let router = api_server.build_router().await.unwrap();
713
714        let request = Request::builder()
715            .uri("/api/v1/health")
716            .method("GET")
717            .body(Body::empty())
718            .unwrap();
719
720        let response = router.oneshot(request).await.unwrap();
721        assert_eq!(response.status(), StatusCode::OK);
722
723        let headers = response.headers();
724        assert_eq!(
725            headers
726                .get("x-content-type-options")
727                .map(|v| v.to_str().unwrap()),
728            Some("nosniff")
729        );
730        assert_eq!(
731            headers.get("x-frame-options").map(|v| v.to_str().unwrap()),
732            Some("DENY")
733        );
734    }
735}