diff --git a/src/app.rs b/src/app.rs index 624e6bf9..f133e316 100644 --- a/src/app.rs +++ b/src/app.rs @@ -129,20 +129,21 @@ impl Application { // Construye el router con las rutas, el middleware y los archivos estáticos de todas las // extensiones habilitadas. // - // Las capas del servidor web sólo envuelven las rutas registradas antes de añadirlas, así que - // los archivos estáticos se registran después del middleware de las extensiones para no pasar - // por él. Una página con muchos recursos repetiría, si no, el mismo trabajo (resolver la - // sesión, etc.) por cada uno. + // Las capas del servidor web sólo envuelven las rutas (y el `fallback`) registradas antes de + // añadirlas, así que los archivos estáticos se registran después del middleware de las + // extensiones para no pasar por él. Una página con muchos recursos repetiría, si no, el mismo + // trabajo (resolver la sesión, etc.) por cada uno. El `fallback` de rutas inexistentes, en + // cambio, se registra antes: la página 404 debe ver lo que el middleware añade a la petición + // (p. ej. el usuario actual). // - // En cambio, las capas de páginas de error y `CatchPanicLayer` sí los cubren, porque se añaden - // al final. Con `CatchPanicLayer` en la última capa se capturan incluso los `panic!` que se - // produzcan dentro del propio renderizado de una página de error. + // Las capas de páginas de error y `CatchPanicLayer` cubren todo, porque se añaden al final. Con + // `CatchPanicLayer` en la última capa se capturan incluso los `panic!` que se produzcan dentro + // del propio renderizado de una página de error. fn build_router() -> Router { - let router = extension::all::configure_routes(Router::new()); + let router = extension::all::configure_routes(Router::new()).fallback(route_not_found); let router = extension::all::configure_middleware(router); let router = extension::all::configure_static_files(router); router - .fallback(route_not_found) .layer(axum::middleware::from_fn(render_error_pages)) .layer(CatchPanicLayer::custom(response_for_panic)) } diff --git a/src/response/page/error.rs b/src/response/page/error.rs index af5f5d35..7d2f5adf 100644 --- a/src/response/page/error.rs +++ b/src/response/page/error.rs @@ -131,13 +131,24 @@ pub(crate) async fn route_not_found(request: HttpRequest) -> Result Response { let mut response = next.run(request).await; - if let Some(error_page) = response.extensions_mut().remove::() { - return error_page.render_html().await; + let Some(error_page) = response.extensions_mut().remove::() else { + return response; + }; + let mut rendered = error_page.render_html().await; + let own: Vec = rendered.headers().keys().cloned().collect(); + for (name, value) in response.headers() { + if !name.as_str().starts_with("content-") && !own.contains(name) { + rendered.headers_mut().append(name, value.clone()); + } } - response + rendered } // **< Fallo catastrófico >************************************************************************* diff --git a/tests/static_files.rs b/tests/static_files.rs index 7fe35136..9706d7a3 100644 --- a/tests/static_files.rs +++ b/tests/static_files.rs @@ -6,6 +6,20 @@ const ASSET: &str = "/pagetop/css/basic.min.css"; // Header added by the global middleware of the test extension. const MARK: &str = "x-global-middleware"; +// Paths seen by the global middleware, to check whether it ran independently of what ends up in +// the response headers. +static SEEN_PATHS: std::sync::Mutex> = std::sync::Mutex::new(Vec::new()); + +// Whether the global middleware has seen `path`. The lock is released before the caller asserts, +// so that a failing test does not poison it for the rest of the tests running in parallel. +fn middleware_saw(path: &str) -> bool { + SEEN_PATHS + .lock() + .unwrap_or_else(std::sync::PoisonError::into_inner) + .iter() + .any(|seen| seen == path) +} + // `EXTENSIONS` is a global `OnceLock`: all tests in this file share the same root extension. struct MarkingExtension; @@ -21,10 +35,21 @@ impl Extension for MarkingExtension { } async fn mark_response(request: web::Request, next: web::middleware::Next) -> Response { + SEEN_PATHS + .lock() + .unwrap_or_else(std::sync::PoisonError::into_inner) + .push(request.uri().path().to_owned()); let mut response = next.run(request).await; - response - .headers_mut() - .insert(MARK, web::http::HeaderValue::from_static("1")); + let headers = response.headers_mut(); + headers.insert(MARK, web::http::HeaderValue::from_static("1")); + headers.append( + web::http::header::SET_COOKIE, + web::http::HeaderValue::from_static("a=1"), + ); + headers.append( + web::http::header::SET_COOKIE, + web::http::HeaderValue::from_static("b=2"), + ); response } @@ -44,11 +69,38 @@ async fn routes_go_through_global_middleware() { assert!(resp.headers().contains_key(MARK)); } +#[pagetop::test] +async fn unknown_routes_go_through_global_middleware() { + // The 404 page must see what the middleware adds to the request (e.g. the current user). + let resp = get("/does-not-exist", None).await; + assert_eq!(resp.status(), web::http::StatusCode::NOT_FOUND); + assert!(middleware_saw("/does-not-exist")); +} + +#[pagetop::test] +async fn error_pages_keep_headers_added_by_middleware() { + // The rendered 404 page replaces the response, but keeps the middleware headers. + let resp = get("/does-not-exist", None).await; + let headers = resp.headers(); + assert_eq!(resp.status(), web::http::StatusCode::NOT_FOUND); + assert!(headers.contains_key(MARK)); + assert_eq!( + headers + .get_all(web::http::header::SET_COOKIE) + .iter() + .count(), + 2 + ); + let content_type = headers.get(web::http::header::CONTENT_TYPE).unwrap(); + assert!(content_type.to_str().unwrap().starts_with("text/html")); +} + #[pagetop::test] async fn static_files_skip_global_middleware() { let resp = get(ASSET, None).await; assert_eq!(resp.status(), web::http::StatusCode::OK); assert!(!resp.headers().contains_key(MARK)); + assert!(!middleware_saw(ASSET)); } #[pagetop::test]