use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum TenantRole {
Member,
Admin,
Owner,
}
impl TenantRole {
pub const ALL: &'static [TenantRole] = &[Self::Member, Self::Admin, Self::Owner];
pub const fn as_str(self) -> &'static str {
match self {
Self::Member => "member",
Self::Admin => "admin",
Self::Owner => "owner",
}
}
pub fn parse(s: &str) -> Result<Self, UnknownRole> {
match s {
"member" => Ok(Self::Member),
"admin" => Ok(Self::Admin),
"owner" => Ok(Self::Owner),
other => Err(UnknownRole(other.to_string())),
}
}
pub const fn can_invite(self) -> bool {
matches!(self, Self::Admin | Self::Owner)
}
pub const fn can_revoke(self) -> bool {
matches!(self, Self::Admin | Self::Owner)
}
pub fn outranks(self, other: Self) -> bool {
self > other
}
}
impl std::fmt::Display for TenantRole {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(self.as_str())
}
}
impl std::str::FromStr for TenantRole {
type Err = UnknownRole;
fn from_str(s: &str) -> Result<Self, Self::Err> {
Self::parse(s)
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct UnknownRole(pub String);
impl std::fmt::Display for UnknownRole {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "unknown tenant role: `{}`", self.0)
}
}
impl std::error::Error for UnknownRole {}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn every_variant_is_listed_in_all() {
for role in TenantRole::ALL {
match role {
TenantRole::Member | TenantRole::Admin | TenantRole::Owner => {}
}
}
assert_eq!(TenantRole::ALL.len(), 3);
}
#[test]
fn storage_spelling_round_trips_for_every_role() {
for &role in TenantRole::ALL {
assert_eq!(TenantRole::parse(role.as_str()), Ok(role));
}
}
#[test]
fn unknown_spellings_are_rejected_not_defaulted() {
assert_eq!(
TenantRole::parse("superuser"),
Err(UnknownRole("superuser".into()))
);
assert_eq!(TenantRole::parse(""), Err(UnknownRole(String::new())));
assert_eq!(TenantRole::parse("Owner"), Err(UnknownRole("Owner".into())));
assert_eq!(TenantRole::parse("OWNER"), Err(UnknownRole("OWNER".into())));
assert_eq!(
TenantRole::parse(" admin"),
Err(UnknownRole(" admin".into()))
);
}
#[test]
fn from_str_agrees_with_parse() {
assert_eq!("admin".parse::<TenantRole>(), Ok(TenantRole::Admin));
assert!("nope".parse::<TenantRole>().is_err());
}
#[test]
fn display_is_the_storage_spelling() {
assert_eq!(format!("{}", TenantRole::Owner), "owner");
assert_eq!(format!("{}", TenantRole::Admin), "admin");
assert_eq!(format!("{}", TenantRole::Member), "member");
}
#[test]
fn only_admins_and_owners_can_invite_or_revoke() {
assert!(!TenantRole::Member.can_invite());
assert!(TenantRole::Admin.can_invite());
assert!(TenantRole::Owner.can_invite());
assert!(!TenantRole::Member.can_revoke());
assert!(TenantRole::Admin.can_revoke());
assert!(TenantRole::Owner.can_revoke());
}
#[test]
fn privilege_ordering_is_member_admin_owner() {
assert!(TenantRole::Owner.outranks(TenantRole::Admin));
assert!(TenantRole::Owner.outranks(TenantRole::Member));
assert!(TenantRole::Admin.outranks(TenantRole::Member));
assert!(!TenantRole::Admin.outranks(TenantRole::Owner));
assert!(!TenantRole::Member.outranks(TenantRole::Admin));
for &role in TenantRole::ALL {
assert!(!role.outranks(role));
}
}
#[test]
fn serde_uses_the_same_lowercase_spelling_as_storage() {
for &role in TenantRole::ALL {
let json = serde_json::to_string(&role).unwrap();
assert_eq!(json, format!("\"{}\"", role.as_str()));
let back: TenantRole = serde_json::from_str(&json).unwrap();
assert_eq!(back, role);
}
}
#[test]
fn serde_rejects_an_unknown_role() {
assert!(serde_json::from_str::<TenantRole>(r#""superuser""#).is_err());
}
#[test]
fn unknown_role_error_names_the_offending_value() {
let e = TenantRole::parse("wat").unwrap_err();
assert!(e.to_string().contains("wat"));
}
}