⚡️ 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:
parent
98a5768406
commit
7793eb796c
12 changed files with 281 additions and 66 deletions
|
|
@ -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"] }
|
||||
|
|
|
|||
|
|
@ -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
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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() {
|
||||
|
|
|
|||
|
|
@ -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
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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::*;
|
||||
|
||||
|
|
|
|||
|
|
@ -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
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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
|
||||
}
|
||||
|
|
|
|||
14
src/app.rs
14
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))
|
||||
|
|
|
|||
|
|
@ -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
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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
|
||||
}
|
||||
}
|
||||
|
|
|
|||
98
src/web.rs
98
src/web.rs
|
|
@ -147,6 +147,28 @@ impl<S: Send + Sync> FromRequestParts<S> 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<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 >******************************************************************************
|
||||
|
||||
/// 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<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 {
|
||||
/// 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<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 {
|
||||
type Response = http::Response<Body>;
|
||||
type Error = Infallible;
|
||||
|
|
@ -197,9 +266,17 @@ impl tower::Service<http::Request<Body>> 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<http::Request<Body>> 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<http::Request<Body>> 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<http::Request<Body>> 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})",
|
||||
|
|
|
|||
86
tests/static_files.rs
Normal file
86
tests/static_files.rs
Normal 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());
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue