⚡️ Caché HTTP y estáticos fuera del middleware

- 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.
This commit is contained in:
Manuel Cillero 2026-10-12 09:54:47 +02:00
parent 98a5768406
commit 7793eb796c
12 changed files with 281 additions and 66 deletions

View file

@ -58,7 +58,7 @@ terminal_size = "0.4"
thiserror = "2.0" thiserror = "2.0"
tokio = { version = "1", features = ["full"] } tokio = { version = "1", features = ["full"] }
tower = { version = "0.5", features = ["util"] } 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 = "0.1"
tracing-appender = "0.2" tracing-appender = "0.2"
tracing-subscriber = { version = "0.3", features = ["json", "env-filter"] } tracing-subscriber = { version = "0.3", features = ["json", "env-filter"] }

View file

@ -104,7 +104,7 @@ impl Extension for Aliner {
Some(&Self) Some(&Self)
} }
fn configure_router(&self, router: Router) -> Router { fn configure_static_files(&self, router: Router) -> Router {
serve_static_files!(router, [aliner] => "/aliner"); serve_static_files!(router, [aliner] => "/aliner");
router router
} }

View file

@ -106,7 +106,7 @@ impl Extension for Bootsier {
Some(&Self) 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 base = &config::SETTINGS.dev.bootsier_static_dir;
let subdir = |s: &str| { let subdir = |s: &str| {
if base.is_empty() { if base.is_empty() {

View file

@ -147,7 +147,7 @@ impl Extension for Htmx {
actions![action::page::BeforeRenderBody::new(add_htmx_script)] 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"); serve_static_files!(router, [htmx] => "/htmx");
router router
} }

View file

@ -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 //! 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, //! peticiones a rutas de la aplicación antes de que lleguen al handler, excepto en las de archivos
//! si el usuario está autenticado, el [`crate::account::Account`] con sus datos ricos en las //! estáticos (ver [`pagetop::core::extension::Extension::configure_static_files`]). Inserta
//! extensiones de la petición HTTP. //! [`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::*; use pagetop::prelude::*;

View file

@ -98,7 +98,7 @@ pub struct MyExtension;
#[async_trait] #[async_trait]
impl Extension for MyExtension { 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"); serve_static_files!(router, ["./static/css", app_css] => "/public/css");
router router
} }

View file

@ -99,7 +99,7 @@ pub struct MyExtension;
#[async_trait] #[async_trait]
impl Extension for MyExtension { 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"); serve_static_files!(router, ["./static/css", app_css] => "/public/css");
router router
} }

View file

@ -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 // Las capas del servidor web sólo envuelven las rutas registradas antes de añadirlas, así que
// dentro del propio renderizado de una página de error. // 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 { fn build_router() -> Router {
let router = extension::all::configure_routes(Router::new()); let router = extension::all::configure_routes(Router::new());
let router = extension::all::configure_middleware(router); let router = extension::all::configure_middleware(router);
let router = extension::all::configure_static_files(router);
router router
.fallback(route_not_found) .fallback(route_not_found)
.layer(axum::middleware::from_fn(render_error_pages)) .layer(axum::middleware::from_fn(render_error_pages))

View file

@ -113,23 +113,20 @@ pub fn configure_routes(router: Router) -> Router {
web::get(|| async { web::http::StatusCode::NOT_FOUND }), web::get(|| async { web::http::StatusCode::NOT_FOUND }),
); );
let router = EXTENSIONS EXTENSIONS
.get() .get()
.into_iter() .into_iter()
.flatten() .flatten()
.fold(router, |r, e| e.configure_router(r)); .fold(router, |r, e| e.configure_router(r))
serve_static_files!(router, [&global::SETTINGS.dev.pagetop_static_dir, assets] => "/pagetop");
router
} }
// **< CONFIGURA EL MIDDLEWARE GLOBAL >************************************************************* // **< CONFIGURA EL MIDDLEWARE GLOBAL >*************************************************************
/// Aplica las capas de middleware globales de todas las extensiones sobre el router ya enrutado. /// 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 /// Se llama después de [`configure_routes`] para que las capas envuelvan todas sus rutas,
/// rutas de la aplicación, independientemente del orden de las extensiones. /// independientemente del orden de las extensiones, y antes de [`configure_static_files`], cuyas
/// rutas quedan fuera.
pub fn configure_middleware(router: Router) -> Router { pub fn configure_middleware(router: Router) -> Router {
EXTENSIONS EXTENSIONS
.get() .get()
@ -137,3 +134,21 @@ pub fn configure_middleware(router: Router) -> Router {
.flatten() .flatten()
.fold(router, |r, e| e.configure_middleware(r)) .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
}

View file

@ -155,9 +155,11 @@ pub trait Extension: AnyInfo + Send + Sync {
/// |----------------------------------|----------------------------------------------------| /// |----------------------------------|----------------------------------------------------|
/// | Ruta HTTP | `.route("/path", web::get(handler))` | /// | Ruta HTTP | `.route("/path", web::get(handler))` |
/// | Rutas bajo prefijo común | `.nest("/prefix", sub_router)` | /// | 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)` | /// | 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 /// # Ejemplos
/// ///
/// ## Rutas HTTP básicas /// ## Rutas HTTP básicas
@ -226,58 +228,79 @@ pub trait Extension: AnyInfo + Send + Sync {
/// } /// }
/// ``` /// ```
/// ///
/// Para middleware que deba cubrir **todas** las rutas, usar /// Para el middleware que deba cubrir las rutas de **todas** las extensiones, usar
/// [`configure_middleware`](Self::configure_middleware). /// [`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, /// 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. /// por lo que el parámetro no necesita `mut`. Sí es necesario devolverlo al final.
/// ///
/// # Ejemplo
///
/// ```rust,ignore /// ```rust,ignore
/// # use pagetop::prelude::*; /// # use pagetop::prelude::*;
/// pub struct MyExtension; /// pub struct MyExtension;
/// ///
/// #[async_trait] /// #[async_trait]
/// impl Extension for MyExtension { /// 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"); /// serve_static_files!(router, [assets] => "/static");
/// router /// router
/// } /// }
/// } /// }
/// ``` /// ```
fn configure_router(&self, router: Router) -> Router { fn configure_static_files(&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 {
router router
} }
} }

View file

@ -147,6 +147,28 @@ impl<S: Send + Sync> FromRequestParts<S> for HttpRequest {
// Servicio para archivos estáticos en disco. // Servicio para archivos estáticos en disco.
pub use tower_http::services::ServeDir; 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<std::path::Path>,
) -> tower_http::set_header::SetResponseHeader<ServeDir, http::HeaderValue> {
tower_http::set_header::SetResponseHeader::if_not_present(
ServeDir::new(dir),
http::header::CACHE_CONTROL,
STATIC_CACHE_CONTROL,
)
}
// **< ServeEmbedded >****************************************************************************** // **< ServeEmbedded >******************************************************************************
/// Servicio para archivos estáticos embebidos en el binario. /// 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 /// (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. /// 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 /// Implementa [`Clone`] para clonar el servicio por petición, pero internamente comparte el mapa de
/// recursos con un [`Arc`] para evitar copias innecesarias. /// recursos con un [`Arc`] para evitar copias innecesarias.
#[derive(Clone)] #[derive(Clone)]
pub struct ServeEmbedded { pub struct ServeEmbedded {
files: std::sync::Arc<HashMap<&'static str, StaticFile>>, files: Arc<HashMap<&'static str, EmbeddedFile>>,
}
// 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 { impl ServeEmbedded {
/// Crea un nuevo servicio a partir del mapa de recursos embebidos generado por `build.rs`. /// Crea un nuevo servicio a partir del mapa de recursos embebidos generado por `build.rs`.
pub fn new(files: HashMap<&'static str, StaticFile>) -> Self { 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 { 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<Body>, 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<http::Request<Body>> for ServeEmbedded { impl tower::Service<http::Request<Body>> for ServeEmbedded {
type Response = http::Response<Body>; type Response = http::Response<Body>;
type Error = Infallible; type Error = Infallible;
@ -197,9 +266,17 @@ impl tower::Service<http::Request<Body>> for ServeEmbedded {
}); });
let response = match resource { let response = match resource {
Some(r) => http::Response::builder() Some(file) if matches_etag(&req, &file.etag) => http::Response::builder()
.header(header::CONTENT_TYPE, r.mime_type) .status(http::StatusCode::NOT_MODIFIED)
.body(Body::from(r.data)) .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(), .unwrap(),
None => http::Response::builder() None => http::Response::builder()
.status(http::StatusCode::NOT_FOUND) .status(http::StatusCode::NOT_FOUND)
@ -215,6 +292,9 @@ impl tower::Service<http::Request<Body>> for ServeEmbedded {
/// Configura el servidor web para publicar archivos estáticos. /// 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: /// 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 /// - **Sistema de ficheros o embebido** (`[$dir, $bundle]`): intenta servir los archivos desde el
@ -240,7 +320,7 @@ impl tower::Service<http::Request<Body>> for ServeEmbedded {
/// ///
/// #[async_trait] /// #[async_trait]
/// impl Extension for MyExtension { /// 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. /// // Forma 1) Sistema de ficheros o embebido.
/// serve_static_files!(router, ["/var/www/static", assets] => "/public"); /// serve_static_files!(router, ["/var/www/static", assets] => "/public");
/// ///
@ -254,6 +334,8 @@ impl tower::Service<http::Request<Body>> for ServeEmbedded {
/// } /// }
/// } /// }
/// ``` /// ```
///
/// [`configure_static_files()`]: crate::core::extension::Extension::configure_static_files
#[macro_export] #[macro_export]
macro_rules! serve_static_files { macro_rules! serve_static_files {
// Forma 1: primero intenta servir desde el sistema de ficheros; si falla, sirve embebido. // 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; let mut served_from_fs = false;
if !::std::path::Path::new(&$dir).as_os_str().is_empty() { if !::std::path::Path::new(&$dir).as_os_str().is_empty() {
if let Ok(absolute) = $crate::util::resolve_absolute_dir($dir) { 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; served_from_fs = true;
} }
} }
@ -321,7 +403,7 @@ macro_rules! serve_static_files {
) )
.entered(); .entered();
match $crate::util::resolve_absolute_dir($dir) { 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) => { Err(e) => {
$crate::trace::warn!( $crate::trace::warn!(
"Static dir not found or invalid for route `{}`: {} ({e})", "Static dir not found or invalid for route `{}`: {} ({e})",

86
tests/static_files.rs Normal file
View file

@ -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());
}