From 7793eb796c3bf44e7cf2e98eabbe9b943ff3983b Mon Sep 17 00:00:00 2001 From: Manuel Cillero Date: Mon, 12 Oct 2026 09:54:47 +0200 Subject: [PATCH] =?UTF-8?q?=E2=9A=A1=EF=B8=8F=20Cach=C3=A9=20HTTP=20y=20es?= =?UTF-8?q?t=C3=A1ticos=20fuera=20del=20middleware?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - ServeEmbedded envía ETag (del contenido) y `Cache-Control: no-cache`, y responde 304 sin cuerpo si el recurso no ha cambiado. - Los archivos servidos desde disco añaden también `no-cache`. - Nuevo `Extension::configure_static_files()`: sus rutas se montan tras el middleware y no resuelven la sesión. Movidos los estáticos del núcleo, Bootsier, Aliner y HTMX. --- Cargo.toml | 2 +- extensions/pagetop-aliner/src/lib.rs | 2 +- extensions/pagetop-bootsier/src/lib.rs | 2 +- extensions/pagetop-htmx/src/lib.rs | 2 +- extensions/pagetop-user/src/middleware.rs | 9 ++- helpers/pagetop-build/README.md | 2 +- helpers/pagetop-build/src/lib.rs | 2 +- src/app.rs | 14 +++- src/core/extension/all.rs | 31 +++++-- src/core/extension/definition.rs | 97 +++++++++++++--------- src/web.rs | 98 +++++++++++++++++++++-- tests/static_files.rs | 86 ++++++++++++++++++++ 12 files changed, 281 insertions(+), 66 deletions(-) create mode 100644 tests/static_files.rs diff --git a/Cargo.toml b/Cargo.toml index 25dacfb3..c59b1452 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -58,7 +58,7 @@ terminal_size = "0.4" thiserror = "2.0" tokio = { version = "1", features = ["full"] } tower = { version = "0.5", features = ["util"] } -tower-http = { version = "0.7", features = ["catch-panic", "fs"] } +tower-http = { version = "0.7", features = ["catch-panic", "fs", "set-header"] } tracing = "0.1" tracing-appender = "0.2" tracing-subscriber = { version = "0.3", features = ["json", "env-filter"] } diff --git a/extensions/pagetop-aliner/src/lib.rs b/extensions/pagetop-aliner/src/lib.rs index aa41219a..9775a990 100644 --- a/extensions/pagetop-aliner/src/lib.rs +++ b/extensions/pagetop-aliner/src/lib.rs @@ -104,7 +104,7 @@ impl Extension for Aliner { Some(&Self) } - fn configure_router(&self, router: Router) -> Router { + fn configure_static_files(&self, router: Router) -> Router { serve_static_files!(router, [aliner] => "/aliner"); router } diff --git a/extensions/pagetop-bootsier/src/lib.rs b/extensions/pagetop-bootsier/src/lib.rs index c3437f1d..69d739f8 100644 --- a/extensions/pagetop-bootsier/src/lib.rs +++ b/extensions/pagetop-bootsier/src/lib.rs @@ -106,7 +106,7 @@ impl Extension for Bootsier { Some(&Self) } - fn configure_router(&self, router: Router) -> Router { + fn configure_static_files(&self, router: Router) -> Router { let base = &config::SETTINGS.dev.bootsier_static_dir; let subdir = |s: &str| { if base.is_empty() { diff --git a/extensions/pagetop-htmx/src/lib.rs b/extensions/pagetop-htmx/src/lib.rs index e7d6acf9..f4b46df6 100644 --- a/extensions/pagetop-htmx/src/lib.rs +++ b/extensions/pagetop-htmx/src/lib.rs @@ -147,7 +147,7 @@ impl Extension for Htmx { actions![action::page::BeforeRenderBody::new(add_htmx_script)] } - fn configure_router(&self, router: Router) -> Router { + fn configure_static_files(&self, router: Router) -> Router { serve_static_files!(router, [htmx] => "/htmx"); router } diff --git a/extensions/pagetop-user/src/middleware.rs b/extensions/pagetop-user/src/middleware.rs index ff81b280..da5bc36b 100644 --- a/extensions/pagetop-user/src/middleware.rs +++ b/extensions/pagetop-user/src/middleware.rs @@ -1,9 +1,10 @@ -//! Middleware Tower para la resolución de sesión de usuario. +//! Middleware para la resolución de sesión de usuario. //! //! Se registra globalmente en [`crate::User::configure_middleware`] y se ejecuta en todas las -//! peticiones entrantes antes de que lleguen al handler. Inserta [`pagetop::auth::CurrentUser`] y, -//! si el usuario está autenticado, el [`crate::account::Account`] con sus datos ricos en las -//! extensiones de la petición HTTP. +//! peticiones a rutas de la aplicación antes de que lleguen al handler, excepto en las de archivos +//! estáticos (ver [`pagetop::core::extension::Extension::configure_static_files`]). Inserta +//! [`pagetop::auth::CurrentUser`] y, si el usuario está autenticado, el [`crate::account::Account`] +//! con sus datos ricos en las extensiones de la petición HTTP. use pagetop::prelude::*; diff --git a/helpers/pagetop-build/README.md b/helpers/pagetop-build/README.md index 776a1330..ddae072a 100644 --- a/helpers/pagetop-build/README.md +++ b/helpers/pagetop-build/README.md @@ -98,7 +98,7 @@ pub struct MyExtension; #[async_trait] impl Extension for MyExtension { - fn configure_router(&self, mut router: Router) -> Router { + fn configure_static_files(&self, router: Router) -> Router { serve_static_files!(router, ["./static/css", app_css] => "/public/css"); router } diff --git a/helpers/pagetop-build/src/lib.rs b/helpers/pagetop-build/src/lib.rs index 7582edec..dd4a3b21 100644 --- a/helpers/pagetop-build/src/lib.rs +++ b/helpers/pagetop-build/src/lib.rs @@ -99,7 +99,7 @@ pub struct MyExtension; #[async_trait] impl Extension for MyExtension { - fn configure_router(&self, mut router: Router) -> Router { + fn configure_static_files(&self, router: Router) -> Router { serve_static_files!(router, ["./static/css", app_css] => "/public/css"); router } diff --git a/src/app.rs b/src/app.rs index 813d0a0a..624e6bf9 100644 --- a/src/app.rs +++ b/src/app.rs @@ -126,13 +126,21 @@ impl Application { } } - // Construye el router con las rutas y el middleware de todas las extensiones habilitadas. + // Construye el router con las rutas, el middleware y los archivos estáticos de todas las + // extensiones habilitadas. // - // 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 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. + // + // 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. fn build_router() -> Router { let router = extension::all::configure_routes(Router::new()); 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)) diff --git a/src/core/extension/all.rs b/src/core/extension/all.rs index dccf0ab8..d98baa04 100644 --- a/src/core/extension/all.rs +++ b/src/core/extension/all.rs @@ -113,23 +113,20 @@ pub fn configure_routes(router: Router) -> Router { web::get(|| async { web::http::StatusCode::NOT_FOUND }), ); - let router = EXTENSIONS + EXTENSIONS .get() .into_iter() .flatten() - .fold(router, |r, e| e.configure_router(r)); - - serve_static_files!(router, [&global::SETTINGS.dev.pagetop_static_dir, assets] => "/pagetop"); - - router + .fold(router, |r, e| e.configure_router(r)) } // **< CONFIGURA EL MIDDLEWARE GLOBAL >************************************************************* /// Aplica las capas de middleware globales de todas las extensiones sobre el router ya enrutado. /// -/// Se llama después de [`configure_routes`] para garantizar que las capas envuelven todas las -/// rutas de la aplicación, independientemente del orden de las extensiones. +/// Se llama después de [`configure_routes`] para que las capas envuelvan todas sus rutas, +/// independientemente del orden de las extensiones, y antes de [`configure_static_files`], cuyas +/// rutas quedan fuera. pub fn configure_middleware(router: Router) -> Router { EXTENSIONS .get() @@ -137,3 +134,21 @@ pub fn configure_middleware(router: Router) -> Router { .flatten() .fold(router, |r, e| e.configure_middleware(r)) } + +// **< CONFIGURA LOS ARCHIVOS ESTÁTICOS >*********************************************************** + +/// Añade los archivos estáticos de PageTop y de todas las extensiones. +/// +/// Se llama después de [`configure_middleware`], para que estas rutas no pasen por las capas de +/// middleware de las extensiones. +pub fn configure_static_files(router: Router) -> Router { + let router = EXTENSIONS + .get() + .into_iter() + .flatten() + .fold(router, |r, e| e.configure_static_files(r)); + + serve_static_files!(router, [&global::SETTINGS.dev.pagetop_static_dir, assets] => "/pagetop"); + + router +} diff --git a/src/core/extension/definition.rs b/src/core/extension/definition.rs index 03231e33..a5b43db7 100644 --- a/src/core/extension/definition.rs +++ b/src/core/extension/definition.rs @@ -155,9 +155,11 @@ pub trait Extension: AnyInfo + Send + Sync { /// |----------------------------------|----------------------------------------------------| /// | Ruta HTTP | `.route("/path", web::get(handler))` | /// | Rutas bajo prefijo común | `.nest("/prefix", sub_router)` | - /// | Archivos estáticos | `serve_static_files!(router, [assets] => "/path")` | /// | Estado compartido entre handlers | `.with_state(my_state)` | /// + /// Los archivos estáticos se registran normalmente en [`configure_static_files`], donde no + /// pasan por el middleware de las extensiones. + /// /// # Ejemplos /// /// ## Rutas HTTP básicas @@ -226,58 +228,79 @@ pub trait Extension: AnyInfo + Send + Sync { /// } /// ``` /// - /// Para middleware que deba cubrir **todas** las rutas, usar - /// [`configure_middleware`](Self::configure_middleware). + /// Para el middleware que deba cubrir las rutas de **todas** las extensiones, usar + /// [`configure_middleware`]. /// - /// ## Archivos estáticos + /// [`configure_static_files`]: Self::configure_static_files + /// [`configure_middleware`]: Self::configure_middleware + fn configure_router(&self, router: Router) -> Router { + router + } + + /// Añade capas de middleware globales a las rutas de la aplicación. + /// + /// Se invoca **después** de que todas las extensiones hayan registrado sus rutas con + /// [`configure_router`](Self::configure_router), de modo que las capas añadidas aquí se aplican + /// a **todas** esas rutas, independientemente del orden de las extensiones. **No** se aplican a + /// los archivos estáticos de [`configure_static_files`](Self::configure_static_files), que se + /// registran después. + /// + /// Usar este método cuando el middleware deba interceptar todas las peticiones a rutas de la + /// aplicación (p. ej. resolución de sesión, autenticación, etc.). Una capa que deba cubrir + /// también los archivos estáticos (p. ej. ciertas cabeceras de seguridad) no puede añadirse + /// aquí; una alternativa es aplicarla en el proxy inverso. + /// + /// # Ejemplo + /// + /// ```rust,no_run + /// # use pagetop::prelude::*; + /// # async fn session_middleware(req: web::Request, next: web::middleware::Next) -> Response { + /// # next.run(req).await + /// # } + /// pub struct MyAuth; + /// + /// #[async_trait] + /// impl Extension for MyAuth { + /// fn configure_middleware(&self, router: Router) -> Router { + /// router.layer(web::middleware::from_fn(session_middleware)) + /// } + /// } + /// ``` + fn configure_middleware(&self, router: Router) -> Router { + router + } + + /// Registra los archivos estáticos de la extensión (hojas de estilo, *scripts*, fuentes, + /// imágenes, etc.) en el servidor web de la aplicación. + /// + /// Es un paso aparte de [`configure_router`](Self::configure_router) porque las capas de + /// middleware sólo envuelven las rutas registradas antes de añadirlas. Este método se invoca + /// **después** de [`configure_middleware`](Self::configure_middleware), así que estas rutas + /// **no** pasan por las capas de middleware de las extensiones (p. ej. la resolución de + /// sesión). Una página carga muchos recursos; sin esta separación, cada uno repetiría ese + /// trabajo, que no necesita. La implementación por defecto devuelve las rutas sin cambios. + /// + /// Si algún archivo sí debe pasar por el middleware (p. ej. descargas que requieran una sesión + /// iniciada), se registra en [`configure_router`](Self::configure_router). /// /// La macro [`serve_static_files!`](crate::serve_static_files) sombrea `router` internamente, /// por lo que el parámetro no necesita `mut`. Sí es necesario devolverlo al final. /// + /// # Ejemplo + /// /// ```rust,ignore /// # use pagetop::prelude::*; /// pub struct MyExtension; /// /// #[async_trait] /// impl Extension for MyExtension { - /// fn configure_router(&self, router: Router) -> Router { + /// fn configure_static_files(&self, router: Router) -> Router { /// serve_static_files!(router, [assets] => "/static"); /// router /// } /// } /// ``` - fn configure_router(&self, router: Router) -> Router { - router - } - - /// Añade capas de middleware globales al router ya completamente preparado. - /// - /// Se invoca **después** de que todas las extensiones hayan registrado sus rutas con - /// [`configure_router`](Self::configure_router), de modo que las capas añadidas aquí se aplican - /// a **todas** las rutas de la aplicación, independientemente del orden de las extensiones. - /// - /// Usar este método cuando el middleware deba interceptar cualquier petición entrante (p. ej. - /// resolución de sesión, autenticación, cabeceras de seguridad, ...). - /// - /// # Ejemplo - /// - /// ```rust,no_run - /// # use pagetop::prelude::*; - /// # use axum::middleware; - /// # async fn session_middleware( - /// # req: axum::extract::Request, - /// # next: middleware::Next, - /// # ) -> axum::response::Response { next.run(req).await } - /// pub struct MyAuth; - /// - /// #[async_trait] - /// impl Extension for MyAuth { - /// fn configure_middleware(&self, router: Router) -> Router { - /// router.layer(middleware::from_fn(session_middleware)) - /// } - /// } - /// ``` - fn configure_middleware(&self, router: Router) -> Router { + fn configure_static_files(&self, router: Router) -> Router { router } } diff --git a/src/web.rs b/src/web.rs index 707b1ffc..beb1a2b1 100644 --- a/src/web.rs +++ b/src/web.rs @@ -147,6 +147,28 @@ impl FromRequestParts for HttpRequest { // Servicio para archivos estáticos en disco. pub use tower_http::services::ServeDir; +// Valor de `Cache-Control` para los archivos estáticos: el navegador puede guardarlos, pero debe +// revalidarlos antes de reutilizarlos. Las versiones de las URL (`?v=...`) no siguen el contenido +// de cada archivo, así que una caché con caducidad podría servir recursos obsoletos tras desplegar. +const STATIC_CACHE_CONTROL: http::HeaderValue = http::HeaderValue::from_static("no-cache"); + +/// Servicio para archivos estáticos en disco con la política de caché de PageTop. +/// +/// Lo usa la macro [`serve_static_files!`](crate::serve_static_files). [`ServeDir`] ya envía +/// `Last-Modified` y `ETag`, y responde `304 Not Modified` cuando corresponde; este servicio añade +/// `Cache-Control: no-cache` para que el navegador revalide los archivos en lugar de reutilizarlos +/// sin preguntar. +#[doc(hidden)] +pub fn serve_dir( + dir: impl AsRef, +) -> tower_http::set_header::SetResponseHeader { + tower_http::set_header::SetResponseHeader::if_not_present( + ServeDir::new(dir), + http::header::CACHE_CONTROL, + STATIC_CACHE_CONTROL, + ) +} + // **< ServeEmbedded >****************************************************************************** /// Servicio para archivos estáticos embebidos en el binario. @@ -156,22 +178,69 @@ pub use tower_http::services::ServeDir; /// (p. ej. `"css/style.css"`). Si se solicita la raíz o una ruta que termina en `/`, el servicio /// devuelve el `index.html` raíz si existe; no busca por subdirectorio. /// +/// Cada respuesta incluye un `ETag` calculado sobre el contenido del recurso y +/// `Cache-Control: no-cache`, de modo que el navegador guarda el recurso pero lo revalida antes de +/// reutilizarlo; si no ha cambiado, el servicio responde `304 Not Modified` sin cuerpo. +/// /// Implementa [`Clone`] para clonar el servicio por petición, pero internamente comparte el mapa de /// recursos con un [`Arc`] para evitar copias innecesarias. #[derive(Clone)] pub struct ServeEmbedded { - files: std::sync::Arc>, + files: Arc>, +} + +// Recurso embebido con su `ETag`, calculado una sola vez al crear el servicio. +struct EmbeddedFile { + data: &'static [u8], + mime_type: &'static str, + etag: http::HeaderValue, } impl ServeEmbedded { /// Crea un nuevo servicio a partir del mapa de recursos embebidos generado por `build.rs`. pub fn new(files: HashMap<&'static str, StaticFile>) -> Self { + let files = files + .into_iter() + .map(|(path, file)| { + let embedded = EmbeddedFile { + data: file.data, + mime_type: file.mime_type, + etag: etag_for(file.data), + }; + (path, embedded) + }) + .collect(); Self { - files: std::sync::Arc::new(files), + files: Arc::new(files), } } } +// `ETag` de un recurso a partir de su contenido. `DefaultHasher::new()` usa siempre las mismas +// claves, así que el valor sólo cambia si cambia el contenido (o el algoritmo, al actualizar Rust, +// lo que únicamente obliga a descargar de nuevo los recursos). +fn etag_for(data: &[u8]) -> http::HeaderValue { + use std::hash::{DefaultHasher, Hasher}; + let mut hasher = DefaultHasher::new(); + hasher.write(data); + http::HeaderValue::try_from(format!("\"{:016x}\"", hasher.finish())) + .expect("a quoted hexadecimal string is always a valid header value") +} + +// Si alguna etiqueta de `If-None-Match` coincide con `etag`. La comparación es débil, como exige +// RFC 9110 para `If-None-Match`: se ignora el prefijo `W/`. +fn matches_etag(req: &http::Request, etag: &http::HeaderValue) -> bool { + req.headers() + .get_all(http::header::IF_NONE_MATCH) + .iter() + .filter_map(|value| value.to_str().ok()) + .flat_map(|tags| tags.split(',')) + .map(str::trim) + .any(|tag| { + tag == "*" || tag.strip_prefix("W/").unwrap_or(tag).as_bytes() == etag.as_bytes() + }) +} + impl tower::Service> for ServeEmbedded { type Response = http::Response; type Error = Infallible; @@ -197,9 +266,17 @@ impl tower::Service> for ServeEmbedded { }); let response = match resource { - Some(r) => http::Response::builder() - .header(header::CONTENT_TYPE, r.mime_type) - .body(Body::from(r.data)) + Some(file) if matches_etag(&req, &file.etag) => http::Response::builder() + .status(http::StatusCode::NOT_MODIFIED) + .header(header::ETAG, file.etag.clone()) + .header(header::CACHE_CONTROL, STATIC_CACHE_CONTROL) + .body(Body::empty()) + .unwrap(), + Some(file) => http::Response::builder() + .header(header::CONTENT_TYPE, file.mime_type) + .header(header::ETAG, file.etag.clone()) + .header(header::CACHE_CONTROL, STATIC_CACHE_CONTROL) + .body(Body::from(file.data)) .unwrap(), None => http::Response::builder() .status(http::StatusCode::NOT_FOUND) @@ -215,6 +292,9 @@ impl tower::Service> for ServeEmbedded { /// Configura el servidor web para publicar archivos estáticos. /// +/// Se usa normalmente en el método [`configure_static_files()`] de las extensiones, para que estas +/// rutas no pasen por su middleware. +/// /// La macro añade rutas al [`Router`] del primer argumento usando uno de los tres modos posibles: /// /// - **Sistema de ficheros o embebido** (`[$dir, $bundle]`): intenta servir los archivos desde el @@ -240,7 +320,7 @@ impl tower::Service> for ServeEmbedded { /// /// #[async_trait] /// impl Extension for MyExtension { -/// fn configure_router(&self, router: Router) -> Router { +/// fn configure_static_files(&self, router: Router) -> Router { /// // Forma 1) Sistema de ficheros o embebido. /// serve_static_files!(router, ["/var/www/static", assets] => "/public"); /// @@ -254,6 +334,8 @@ impl tower::Service> for ServeEmbedded { /// } /// } /// ``` +/// +/// [`configure_static_files()`]: crate::core::extension::Extension::configure_static_files #[macro_export] macro_rules! serve_static_files { // Forma 1: primero intenta servir desde el sistema de ficheros; si falla, sirve embebido. @@ -269,7 +351,7 @@ macro_rules! serve_static_files { let mut served_from_fs = false; if !::std::path::Path::new(&$dir).as_os_str().is_empty() { if let Ok(absolute) = $crate::util::resolve_absolute_dir($dir) { - __r = __r.nest_service($path, $crate::web::ServeDir::new(absolute)); + __r = __r.nest_service($path, $crate::web::serve_dir(absolute)); served_from_fs = true; } } @@ -321,7 +403,7 @@ macro_rules! serve_static_files { ) .entered(); match $crate::util::resolve_absolute_dir($dir) { - Ok(absolute) => $router.nest_service($path, $crate::web::ServeDir::new(absolute)), + Ok(absolute) => $router.nest_service($path, $crate::web::serve_dir(absolute)), Err(e) => { $crate::trace::warn!( "Static dir not found or invalid for route `{}`: {} ({e})", diff --git a/tests/static_files.rs b/tests/static_files.rs new file mode 100644 index 00000000..7fe35136 --- /dev/null +++ b/tests/static_files.rs @@ -0,0 +1,86 @@ +use pagetop::prelude::*; + +// Static assets of PageTop itself (`/pagetop/...`), always registered. +const ASSET: &str = "/pagetop/css/basic.min.css"; + +// Header added by the global middleware of the test extension. +const MARK: &str = "x-global-middleware"; + +// `EXTENSIONS` is a global `OnceLock`: all tests in this file share the same root extension. +struct MarkingExtension; + +#[async_trait] +impl Extension for MarkingExtension { + fn configure_router(&self, router: Router) -> Router { + router.route("/page", web::get(|| async { "page" })) + } + + fn configure_middleware(&self, router: Router) -> Router { + router.layer(web::middleware::from_fn(mark_response)) + } +} + +async fn mark_response(request: web::Request, next: web::middleware::Next) -> Response { + let mut response = next.run(request).await; + response + .headers_mut() + .insert(MARK, web::http::HeaderValue::from_static("1")); + response +} + +async fn get(uri: &str, if_none_match: Option<&str>) -> Response { + let app = web::test::init_router(Application::prepare(&MarkingExtension).await.test()); + let mut req = web::test::TestRequest::get().uri(uri); + if let Some(etag) = if_none_match { + req = req.header("if-none-match", etag); + } + web::test::send_request(&app, req.to_request()).await +} + +#[pagetop::test] +async fn routes_go_through_global_middleware() { + let resp = get("/page", None).await; + assert_eq!(resp.status(), web::http::StatusCode::OK); + assert!(resp.headers().contains_key(MARK)); +} + +#[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)); +} + +#[pagetop::test] +async fn embedded_static_files_are_revalidated_with_etag() { + let resp = get(ASSET, None).await; + let headers = resp.headers(); + assert_eq!( + headers.get(web::http::header::CACHE_CONTROL).unwrap(), + "no-cache" + ); + let etag = headers + .get(web::http::header::ETAG) + .expect("embedded asset without ETag") + .to_str() + .unwrap() + .to_owned(); + + // Same content: 304 without body, with the same validators. + let resp = get(ASSET, Some(&etag)).await; + assert_eq!(resp.status(), web::http::StatusCode::NOT_MODIFIED); + assert_eq!( + resp.headers().get(web::http::header::ETAG).unwrap(), + etag.as_str() + ); + assert!(web::test::read_body_text(resp).await.is_empty()); + + // Weak comparison inside a list of tags. + let resp = get(ASSET, Some(&format!("\"other\", W/{etag}"))).await; + assert_eq!(resp.status(), web::http::StatusCode::NOT_MODIFIED); + + // A different tag gets the full content. + let resp = get(ASSET, Some("\"other\"")).await; + assert_eq!(resp.status(), web::http::StatusCode::OK); + assert!(!web::test::read_body_text(resp).await.is_empty()); +}