pagetop/tests/web_endpoint.rs
Manuel Cillero e2e2ccb31e ✨ (pagetop): Oculta enlaces sin acceso con Endpoint
Las rutas se declaran con su acceso en un enum que implementa Endpoint y
se montan con `routes.endpoint()`. Convertidas en Route, `nav::Item`,
`dropdown::Item` y `Button::anchor()` no se muestran a quien no cumple
el acceso, sin repetir el permiso. `to()` rellena el parámetro de la
ruta.
2026-11-08 08:56:57 +01:00

301 lines
9.7 KiB
Rust

// Verifies that a route declared with `Endpoint` is protected by its access when it is requested
// and that the links to it are only shown to whoever has that access.
use pagetop::prelude::*;
struct Granted;
impl Permission for Granted {
fn key(&self) -> CowStr {
"test:granted".into()
}
}
struct Denied;
impl Permission for Denied {
fn key(&self) -> CowStr {
"test:denied".into()
}
}
// Grants `test:granted` to everybody, as an authentication extension would.
fn grant(_: &HttpRequest, perm: PermissionRef, granted: &mut bool) {
if perm.key() == "test:granted" {
*granted = true;
}
}
#[derive(Clone, Copy)]
enum TestRoute {
Open,
Signed,
Allowed,
Forbidden,
Report(&'static str),
NoteView,
NoteSave,
AllowedItem,
ForbiddenItem,
}
impl Endpoint for TestRoute {
fn path(&self) -> CowStr {
match self {
Self::Open => "/open".into(),
Self::Signed => "/signed".into(),
Self::Allowed => "/allowed".into(),
Self::Forbidden => "/forbidden".into(),
Self::Report(slug) => format!("/reports/{slug}").into(),
Self::NoteView | Self::NoteSave => "/notes".into(),
Self::AllowedItem => "/items/{id}/edit".into(),
Self::ForbiddenItem => "/secrets/{id}/edit".into(),
}
}
fn access(&self) -> Access {
match self {
Self::Open => Access::Public,
Self::Signed => Access::Authenticated,
Self::Allowed | Self::Report(_) | Self::NoteView | Self::AllowedItem => {
Access::Permission(&Granted)
}
Self::Forbidden | Self::NoteSave | Self::ForbiddenItem => Access::Permission(&Denied),
}
}
}
// Signs in the requests that carry an `x-user` header.
async fn sign_in(mut request: web::Request, next: web::middleware::Next) -> Response {
if request.headers().contains_key("x-user") {
request
.extensions_mut()
.insert(CurrentUser::authenticated(1, "Test user"));
}
next.run(request).await
}
async fn ok() -> &'static str {
"ok"
}
async fn home(request: HttpRequest) -> Result<Markup, ErrorPage> {
Page::new(request)
.with_child(
Nav::new()
.with_item(nav::Item::link(Lc::n("nav-open"), TestRoute::Open))
.with_item(nav::Item::link(Lc::n("nav-signed"), TestRoute::Signed))
.with_item(nav::Item::link(Lc::n("nav-allowed"), TestRoute::Allowed))
.with_item(nav::Item::link(
Lc::n("nav-forbidden"),
TestRoute::Forbidden,
))
.with_item(nav::Item::link(
Lc::n("nav-report"),
TestRoute::Report("sales"),
))
.with_item(nav::Item::link(Lc::n("nav-literal"), "/literal"))
.with_item(nav::Item::label(Lc::n("nav-label")))
.with_item(nav::Item::dropdown(
Dropdown::new()
.with_title(Lc::n("dropdown-empty"))
.with_item(dropdown::Item::link(Lc::n("x"), TestRoute::Forbidden)),
))
.with_item(nav::Item::dropdown(
Dropdown::new()
.with_title(Lc::n("dropdown-partial"))
.with_item(dropdown::Item::link(
Lc::n("in-allowed"),
TestRoute::Allowed,
))
.with_item(dropdown::Item::link(
Lc::n("in-forbidden"),
TestRoute::Forbidden,
))
.with_item(dropdown::Item::button(Lc::n("in-button"))),
)),
)
.with_child(
Nav::new()
.with_id("nav-all-hidden")
.with_item(nav::Item::link(Lc::n("x"), TestRoute::Forbidden)),
)
.with_child(
Dropdown::new()
.with_title(Lc::n("standalone-empty"))
.with_item(dropdown::Item::link(Lc::n("x"), TestRoute::Forbidden)),
)
.with_child(Button::anchor(Lc::n("button-allowed"), TestRoute::Allowed))
.with_child(Button::anchor(
Lc::n("button-forbidden"),
TestRoute::Forbidden,
))
.with_child(Button::anchor(
Lc::n("item-allowed"),
TestRoute::AllowedItem.to(7),
))
.with_child(Button::anchor(
Lc::n("item-forbidden"),
TestRoute::ForbiddenItem.to(7),
))
.with_child(Button::anchor(
Lc::n("item-encoded"),
TestRoute::AllowedItem.to("a b/c?d#e"),
))
.with_child(Button::submit(Lc::n("button-submit")))
.render()
.await
}
struct Ext;
#[async_trait]
impl Extension for Ext {
fn actions(&self) -> Vec<ActionBox> {
actions![action::auth::CheckPermission::new(grant)]
}
fn configure_router(&self, routes: Routes) -> Routes {
routes
.public_route("/", web::get(home))
.endpoint(TestRoute::Open, web::get(ok))
.endpoint(TestRoute::Signed, web::get(ok))
.endpoint(TestRoute::Allowed, web::get(ok))
.endpoint(TestRoute::Forbidden, web::get(ok))
.endpoint(TestRoute::Report("sales"), web::get(ok))
// Reading is allowed, writing needs a permission that nobody has.
.endpoint(TestRoute::NoteView, web::get(ok))
.endpoint(TestRoute::NoteSave, web::post(ok))
.endpoint(TestRoute::AllowedItem, web::get(ok))
.endpoint(TestRoute::ForbiddenItem, web::get(ok))
}
fn configure_middleware(&self, layers: Layers) -> Layers {
layers.layer(web::middleware::from_fn(sign_in))
}
}
async fn send(request: web::test::TestRequest) -> Response {
let app = Application::prepare(&Ext).await.test();
web::test::send_request(&app, request.to_request()).await
}
async fn status_of(uri: &str) -> u16 {
let response = send(web::test::TestRequest::get().uri(uri)).await;
response.status().as_u16()
}
async fn home_page() -> String {
let response = send(web::test::TestRequest::get().uri("/")).await;
assert_eq!(response.status().as_u16(), 200);
web::test::read_body_text(response).await
}
#[pagetop::test]
async fn the_routes_require_the_access_they_declare() {
assert_eq!(status_of("/open").await, 200);
assert_eq!(status_of("/allowed").await, 200);
assert_eq!(status_of("/reports/sales").await, 200);
assert_eq!(status_of("/items/7/edit").await, 200);
assert_eq!(status_of("/signed").await, 403);
assert_eq!(status_of("/forbidden").await, 403);
assert_eq!(status_of("/secrets/7/edit").await, 403);
}
#[pagetop::test]
async fn each_method_of_a_route_can_require_its_own_access() {
assert_eq!(status_of("/notes").await, 200);
let save = send(web::test::TestRequest::post().uri("/notes")).await;
assert_eq!(save.status().as_u16(), 403);
}
#[pagetop::test]
async fn links_are_only_shown_with_access_to_their_route() {
let html = home_page().await;
for shown in [
"nav-open",
"nav-allowed",
"nav-report",
r#"href="/reports/sales""#,
"dropdown-partial",
"in-allowed",
"button-allowed",
] {
assert!(html.contains(shown), "`{shown}` is missing in {html}");
}
for hidden in [
"nav-signed",
"nav-forbidden",
"in-forbidden",
"button-forbidden",
"item-forbidden",
] {
assert!(!html.contains(hidden), "`{hidden}` is shown in {html}");
}
}
#[pagetop::test]
async fn links_for_signed_in_users_are_shown_after_signing_in() {
assert_eq!(status_of("/signed").await, 403);
let signed = send(
web::test::TestRequest::get()
.uri("/signed")
.header("x-user", "1"),
)
.await;
assert_eq!(signed.status().as_u16(), 200);
let home = send(web::test::TestRequest::get().uri("/").header("x-user", "1")).await;
let html = web::test::read_body_text(home).await;
assert!(
html.contains("nav-signed"),
"`nav-signed` is missing in {html}"
);
}
#[pagetop::test]
async fn elements_without_an_endpoint_are_not_affected() {
let html = home_page().await;
for shown in ["nav-literal", "nav-label", "in-button", "button-submit"] {
assert!(html.contains(shown), "`{shown}` is missing in {html}");
}
}
#[pagetop::test]
async fn menus_with_nothing_to_show_are_not_rendered() {
let html = home_page().await;
for hidden in ["dropdown-empty", "nav-all-hidden", "standalone-empty"] {
assert!(!html.contains(hidden), "`{hidden}` is shown in {html}");
}
}
#[pagetop::test]
async fn links_fill_the_parameter_of_their_route() {
let html = home_page().await;
assert!(html.contains(r#"href="/items/7/edit""#), "{html}");
assert!(
html.contains(r#"href="/items/a%20b%2Fc%3Fd%23e/edit""#),
"{html}"
);
}
#[pagetop::test]
async fn without_a_request_only_public_routes_are_accessible() {
let cx = Context::default();
assert!(Route::from(TestRoute::Open).is_accessible(&cx));
assert!(!Route::from(TestRoute::Signed).is_accessible(&cx));
assert!(!Route::from(TestRoute::Allowed).is_accessible(&cx));
assert!(Route::from("/literal").is_accessible(&cx));
}
#[pagetop::test]
#[should_panic(expected = "needs its parameter")]
async fn linking_to_a_route_with_a_parameter_needs_its_value() {
let _ = nav::Item::link(Lc::n("x"), TestRoute::AllowedItem);
}
#[pagetop::test]
#[should_panic(expected = "has no parameter")]
async fn filling_a_route_without_a_parameter_is_an_error() {
let _ = TestRoute::Allowed.to(7);
}