footing 0.1.18

Feature-gated foundations for Rust backend services
Documentation
use super::{PermissionError, Principal, PrincipalRequirement};
use crate::result::{ClassifyError, ErrorKind};

#[tokio::test]
async fn permission_checker_receives_validated_requests_and_maps_denials() {
    use super::{PermissionChecker, PermissionDecision, PermissionRequest};
    struct Checker;
    #[async_trait::async_trait]
    impl PermissionChecker for Checker {
        async fn check(
            &self,
            _: &Principal,
            request: &PermissionRequest,
        ) -> Result<PermissionDecision, PermissionError> {
            Ok(
                if request.action() == "read" && request.resource() == "users" {
                    PermissionDecision::Allow
                } else {
                    PermissionDecision::Deny
                },
            )
        }
    }
    let principal = test_user();
    assert!(
        Checker
            .ensure_allowed(
                &principal,
                &PermissionRequest::new(" read ", " users ").unwrap()
            )
            .await
            .is_ok()
    );
    assert!(matches!(
        Checker
            .ensure_allowed(
                &principal,
                &PermissionRequest::new("delete", "users").unwrap()
            )
            .await,
        Err(PermissionError::Denied)
    ));
}

fn test_user() -> Principal {
    Principal::user("usr_1").expect("static test principal id is valid")
}

#[test]
fn supports_wildcard_scopes() {
    let principal = test_user()
        .with_scopes(["user:*"])
        .expect("static test scope is valid");

    assert!(principal.has_scope("user:read"));
    assert!(principal.has_scope("user:write"));
    assert!(!principal.has_scope("client:read"));
}

#[test]
fn role_guard_requires_matching_role() {
    let principal = test_user()
        .with_roles(["admin"])
        .expect("static test role is valid");

    assert!(
        PrincipalRequirement::role("admin")
            .expect("static guard role is valid")
            .check(&principal)
            .is_ok()
    );
    assert!(
        PrincipalRequirement::role("operator")
            .expect("static guard role is valid")
            .check(&principal)
            .is_err()
    );
}

#[test]
fn scope_guard_supports_wildcard_scopes() {
    let principal = test_user()
        .with_scopes(["user:*"])
        .expect("static test scope is valid");

    assert!(
        PrincipalRequirement::scope("user:read")
            .expect("static guard scope is valid")
            .check(&principal)
            .is_ok()
    );
    assert!(
        PrincipalRequirement::scope("client:read")
            .expect("static guard scope is valid")
            .check(&principal)
            .is_err()
    );
}

#[test]
fn role_set_guard_allows_any_matching_role() {
    let principal = test_user()
        .with_roles(["operator"])
        .expect("static test role is valid");

    assert!(
        PrincipalRequirement::any_roles(["admin", "operator"])
            .expect("static guard roles are valid")
            .check(&principal)
            .is_ok()
    );
    assert!(
        PrincipalRequirement::any_roles(["admin"])
            .expect("static guard role is valid")
            .check(&principal)
            .is_err()
    );
}

#[test]
fn role_set_guard_can_require_all_roles() {
    let principal = test_user()
        .with_roles(["admin", "operator"])
        .expect("static test roles are valid");

    assert!(
        PrincipalRequirement::all_roles(["admin", "operator"])
            .expect("static guard roles are valid")
            .check(&principal)
            .is_ok()
    );
    assert!(
        PrincipalRequirement::all_roles(["admin", "auditor"])
            .expect("static guard roles are valid")
            .check(&principal)
            .is_err()
    );
}

#[test]
fn scope_set_guard_requires_all_scopes() {
    let principal = test_user()
        .with_scopes(["user:*", "audit:read"])
        .expect("static test scopes are valid");

    assert!(
        PrincipalRequirement::all_scopes(["user:read", "audit:read"])
            .expect("static guard scopes are valid")
            .check(&principal)
            .is_ok()
    );
    assert!(
        PrincipalRequirement::all_scopes(["user:read", "client:read"])
            .expect("static guard scopes are valid")
            .check(&principal)
            .is_err()
    );
}

#[test]
fn scope_set_guard_can_allow_any_scope() {
    let principal = test_user()
        .with_scopes(["user:*"])
        .expect("static test scope is valid");

    assert!(
        PrincipalRequirement::any_scopes(["client:read", "user:read"])
            .expect("static guard scopes are valid")
            .check(&principal)
            .is_ok()
    );
    assert!(
        PrincipalRequirement::any_scopes(["client:read", "audit:read"])
            .expect("static guard scopes are valid")
            .check(&principal)
            .is_err()
    );
}

#[test]
fn empty_permission_guards_are_invalid_policies() {
    assert!(matches!(
        PrincipalRequirement::role(""),
        Err(PermissionError::InvalidPolicy(_))
    ));
    assert!(matches!(
        PrincipalRequirement::scope(""),
        Err(PermissionError::InvalidPolicy(_))
    ));
    assert!(matches!(
        PrincipalRequirement::any_roles(std::iter::empty::<&str>()),
        Err(PermissionError::InvalidPolicy(_))
    ));
    assert!(matches!(
        PrincipalRequirement::all_roles(std::iter::empty::<&str>()),
        Err(PermissionError::InvalidPolicy(_))
    ));
    assert!(matches!(
        PrincipalRequirement::any_scopes(std::iter::empty::<&str>()),
        Err(PermissionError::InvalidPolicy(_))
    ));
    assert!(matches!(
        PrincipalRequirement::all_scopes(std::iter::empty::<&str>()),
        Err(PermissionError::InvalidPolicy(_))
    ));
}

#[test]
fn permission_request_rejects_empty_parts() {
    assert!(matches!(
        super::PermissionRequest::new("", "users"),
        Err(PermissionError::InvalidPolicy(_))
    ));
    assert!(matches!(
        super::PermissionRequest::new("read", ""),
        Err(PermissionError::InvalidPolicy(_))
    ));
    let request = super::PermissionRequest::new("read", "users").expect("request should be valid");

    assert_eq!(request.action(), "read");
    assert_eq!(request.resource(), "users");

    let invalid = serde_json::json!({
        "action": "",
        "resource": "users"
    });
    assert!(serde_json::from_value::<super::PermissionRequest>(invalid).is_err());
}

#[test]
fn principal_deduplicates_roles_and_scopes() {
    let mut principal = test_user()
        .with_roles(["admin", " admin "])
        .expect("static test roles are valid")
        .with_scopes(["user:read", " user:read "])
        .expect("static test scopes are valid");
    principal
        .add_role(" admin ")
        .expect("static test role is valid");
    principal
        .add_scope(" user:read ")
        .expect("static test scope is valid");

    assert_eq!(principal.id(), "usr_1");
    assert_eq!(principal.kind(), super::PrincipalKind::User);
    assert_eq!(principal.roles(), ["admin"]);
    assert_eq!(principal.scopes(), ["user:read"]);
}

#[test]
fn principal_debug_redacts_identifiers_and_authorities_without_changing_wire_data() {
    let id = "private-principal-id";
    let tenant_id = "private-tenant-id";
    let role = "private-role";
    let scope = "private:scope";
    let principal = Principal::user(id)
        .expect("principal should be valid")
        .with_tenant_id(tenant_id)
        .expect("tenant should be valid")
        .with_roles([role])
        .expect("role should be valid")
        .with_scopes([scope])
        .expect("scope should be valid");

    let debug = format!("{principal:?}");
    assert!(debug.contains("[REDACTED]"));
    for sensitive in [id, tenant_id, role, scope] {
        assert!(!debug.contains(sensitive));
    }

    let wire = serde_json::to_value(principal).expect("principal should serialize");
    assert_eq!(wire["id"], id);
    assert_eq!(wire["tenant_id"], tenant_id);
    assert_eq!(wire["roles"][0], role);
    assert_eq!(wire["scopes"][0], scope);
}

#[test]
fn principal_rejects_invalid_identifiers_and_authorities() {
    assert!(matches!(
        Principal::user(""),
        Err(PermissionError::InvalidPrincipal(_))
    ));
    assert!(matches!(
        Principal::client("client with space"),
        Err(PermissionError::InvalidPrincipal(_))
    ));
    assert!(matches!(
        test_user().with_roles([""]),
        Err(PermissionError::InvalidAuthority(_))
    ));
    assert!(matches!(
        test_user().with_scopes(["user read"]),
        Err(PermissionError::InvalidAuthority(_))
    ));
}

#[test]
fn principal_deserialization_uses_same_validation() {
    let valid = serde_json::json!({
        "id": "usr_1",
        "kind": "user",
        "roles": ["admin", " admin "],
        "scopes": ["user:*"]
    });
    let principal: Principal =
        serde_json::from_value(valid).expect("valid principal JSON should deserialize");

    assert_eq!(principal.roles(), ["admin"]);
    assert!(principal.has_scope("user:read"));

    let invalid = serde_json::json!({
        "id": "usr_1",
        "kind": "user",
        "roles": [""]
    });
    assert!(serde_json::from_value::<Principal>(invalid).is_err());
}

#[test]
fn blank_role_or_scope_checks_are_not_satisfied_by_wildcards() {
    let principal = test_user()
        .with_roles(["admin"])
        .expect("static test role is valid")
        .with_scopes(["*"])
        .expect("static test scope is valid");

    assert!(!principal.has_role(" "));
    assert!(!principal.has_scope(" "));
    assert!(!principal.has_all_roles(std::iter::empty::<&str>()));
    assert!(!principal.has_all_scopes(std::iter::empty::<&str>()));
}

#[test]
fn principal_can_remove_authorities() {
    let mut principal = test_user()
        .with_roles(["admin", "operator"])
        .expect("static test roles are valid")
        .with_scopes(["user:read", "audit:read"])
        .expect("static test scopes are valid");

    assert!(principal.remove_role(" operator "));
    assert!(principal.remove_scope(" audit:read "));
    assert!(!principal.remove_role("missing"));

    assert_eq!(principal.roles(), ["admin"]);
    assert_eq!(principal.scopes(), ["user:read"]);
}

#[test]
fn permission_errors_have_stable_classification() {
    let denied = PermissionError::Denied.error_descriptor();
    let unavailable = PermissionError::Unavailable.error_descriptor();
    let invalid_principal =
        PermissionError::InvalidPrincipal("empty id".to_owned()).error_descriptor();
    let invalid = PermissionError::InvalidPolicy("empty scope".to_owned()).error_descriptor();

    assert_eq!(denied.kind(), ErrorKind::Authorization);
    assert_eq!(denied.code().as_str(), "permission_denied");
    assert_eq!(unavailable.kind(), ErrorKind::Unavailable);
    assert!(unavailable.retryable());
    assert_eq!(invalid_principal.kind(), ErrorKind::Validation);
    assert_eq!(invalid_principal.code().as_str(), "principal_invalid");
    assert_eq!(invalid.kind(), ErrorKind::Internal);
    assert_eq!(invalid.code().as_str(), "permission_invalid_policy");
}