use crate::backend::SpacePatchOp;
pub const MANAGE_SPACE: &str = "manage_space";
pub const MANAGE_ROLES: &str = "manage_roles";
pub const MANAGE_MEMBERS: &str = "manage_members";
pub const MANAGE_CHANNELS: &str = "manage_channels";
#[non_exhaustive]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum RequiredPermissions {
Known(&'static [&'static str]),
UnknownOp,
}
pub fn required_permissions_for_op(op: &SpacePatchOp) -> RequiredPermissions {
match op {
SpacePatchOp::AddRole(_)
| SpacePatchOp::RemoveRole(_)
| SpacePatchOp::UpdateRole { .. } => RequiredPermissions::Known(&[MANAGE_ROLES]),
SpacePatchOp::AddMember(_) | SpacePatchOp::RemoveMember(_) => {
RequiredPermissions::Known(&[MANAGE_MEMBERS])
}
SpacePatchOp::UpdateMember { patch, .. } => {
if patch.role_ids.is_some() {
RequiredPermissions::Known(&[MANAGE_MEMBERS, MANAGE_ROLES])
} else {
RequiredPermissions::Known(&[MANAGE_MEMBERS])
}
}
SpacePatchOp::AddChannel(_)
| SpacePatchOp::RemoveChannel(_)
| SpacePatchOp::UpdateChannel { .. } => RequiredPermissions::Known(&[MANAGE_CHANNELS]),
SpacePatchOp::AddCategory(_)
| SpacePatchOp::RemoveCategory(_)
| SpacePatchOp::UpdateCategory { .. } => RequiredPermissions::Known(&[MANAGE_CHANNELS]),
_ => RequiredPermissions::UnknownOp,
}
}
#[cfg(test)]
mod tests {
use super::*;
use jmap_chat_types::space_set::{
CategoryPatch, ChannelCreate, ChannelPatch, MemberPatch, RolePatch,
};
use jmap_chat_types::{Category, Clearable, SpaceRole};
use jmap_types::Id;
fn role_fixture() -> SpaceRole {
serde_json::from_value(serde_json::json!({
"id": "r1",
"name": "Moderator",
"permissions": ["chat:read"],
"position": 0
}))
.expect("role fixture must deserialize")
}
fn category_fixture() -> Category {
serde_json::from_value(serde_json::json!({
"id": "cat1",
"name": "Voice",
"position": 0,
"channelIds": []
}))
.expect("category fixture must deserialize")
}
fn channel_create_fixture() -> ChannelCreate {
serde_json::from_value(serde_json::json!({
"name": "general"
}))
.expect("channelCreate fixture must deserialize")
}
#[test]
fn add_role_requires_manage_roles() {
let op = SpacePatchOp::AddRole(role_fixture());
assert_eq!(
required_permissions_for_op(&op),
RequiredPermissions::Known(&[MANAGE_ROLES])
);
}
#[test]
fn remove_role_requires_manage_roles() {
let op = SpacePatchOp::RemoveRole(Id::from("r1"));
assert_eq!(
required_permissions_for_op(&op),
RequiredPermissions::Known(&[MANAGE_ROLES])
);
}
#[test]
fn update_role_requires_manage_roles() {
let mut patch = RolePatch::default();
patch.name = Some("Renamed".to_owned());
let op = SpacePatchOp::UpdateRole {
id: Id::from("r1"),
patch,
};
assert_eq!(
required_permissions_for_op(&op),
RequiredPermissions::Known(&[MANAGE_ROLES])
);
}
#[test]
fn add_member_requires_manage_members_only() {
let op = SpacePatchOp::AddMember(jmap_chat_types::MemberCreate::new(
Id::from("u1"),
vec![Id::from("r1"), Id::from("r2")],
));
assert_eq!(
required_permissions_for_op(&op),
RequiredPermissions::Known(&[MANAGE_MEMBERS])
);
}
#[test]
fn remove_member_requires_manage_members() {
let op = SpacePatchOp::RemoveMember(Id::from("u1"));
assert_eq!(
required_permissions_for_op(&op),
RequiredPermissions::Known(&[MANAGE_MEMBERS])
);
}
#[test]
fn update_member_nick_only_requires_manage_members_only() {
let mut patch = MemberPatch::default();
patch.nick = Some(Clearable::Set("Captain".to_owned()));
let op = SpacePatchOp::UpdateMember {
user_id: Id::from("u1"),
patch,
};
assert_eq!(
required_permissions_for_op(&op),
RequiredPermissions::Known(&[MANAGE_MEMBERS])
);
}
#[test]
fn update_member_role_ids_change_requires_both() {
let mut patch = MemberPatch::default();
patch.role_ids = Some(vec![Id::from("r1")]);
let op = SpacePatchOp::UpdateMember {
user_id: Id::from("u1"),
patch,
};
assert_eq!(
required_permissions_for_op(&op),
RequiredPermissions::Known(&[MANAGE_MEMBERS, MANAGE_ROLES])
);
}
#[test]
fn update_member_role_ids_empty_still_counts_as_change() {
let mut patch = MemberPatch::default();
patch.role_ids = Some(vec![]);
let op = SpacePatchOp::UpdateMember {
user_id: Id::from("u1"),
patch,
};
assert_eq!(
required_permissions_for_op(&op),
RequiredPermissions::Known(&[MANAGE_MEMBERS, MANAGE_ROLES])
);
}
#[test]
fn add_channel_requires_manage_channels() {
let op = SpacePatchOp::AddChannel(channel_create_fixture());
assert_eq!(
required_permissions_for_op(&op),
RequiredPermissions::Known(&[MANAGE_CHANNELS])
);
}
#[test]
fn remove_channel_requires_manage_channels() {
let op = SpacePatchOp::RemoveChannel(Id::from("ch1"));
assert_eq!(
required_permissions_for_op(&op),
RequiredPermissions::Known(&[MANAGE_CHANNELS])
);
}
#[test]
fn update_channel_requires_manage_channels() {
let mut patch = ChannelPatch::default();
patch.name = Some("renamed".to_owned());
let op = SpacePatchOp::UpdateChannel {
id: Id::from("ch1"),
patch,
};
assert_eq!(
required_permissions_for_op(&op),
RequiredPermissions::Known(&[MANAGE_CHANNELS])
);
}
#[test]
fn add_category_requires_manage_channels() {
let op = SpacePatchOp::AddCategory(category_fixture());
assert_eq!(
required_permissions_for_op(&op),
RequiredPermissions::Known(&[MANAGE_CHANNELS])
);
}
#[test]
fn remove_category_requires_manage_channels() {
let op = SpacePatchOp::RemoveCategory(Id::from("cat1"));
assert_eq!(
required_permissions_for_op(&op),
RequiredPermissions::Known(&[MANAGE_CHANNELS])
);
}
#[test]
fn update_category_requires_manage_channels() {
let mut patch = CategoryPatch::default();
patch.name = Some("Voice".to_owned());
let op = SpacePatchOp::UpdateCategory {
id: Id::from("cat1"),
patch,
};
assert_eq!(
required_permissions_for_op(&op),
RequiredPermissions::Known(&[MANAGE_CHANNELS])
);
}
#[test]
fn permission_constants_have_spec_literal_values() {
assert_eq!(MANAGE_SPACE, "manage_space");
assert_eq!(MANAGE_ROLES, "manage_roles");
assert_eq!(MANAGE_MEMBERS, "manage_members");
assert_eq!(MANAGE_CHANNELS, "manage_channels");
}
#[test]
fn helper_returns_typed_known_or_unknown() {
fn assert_typed_return<F>(_f: F)
where
F: Fn(&SpacePatchOp) -> RequiredPermissions,
{
}
assert_typed_return(required_permissions_for_op);
}
#[test]
fn unknown_op_variant_is_distinct_from_any_known_arm() {
let a = RequiredPermissions::Known(&[MANAGE_ROLES]);
let b = RequiredPermissions::Known(&[MANAGE_MEMBERS]);
let u = RequiredPermissions::UnknownOp;
assert_ne!(a, b);
assert_ne!(a, u);
assert_ne!(b, u);
assert_eq!(u, RequiredPermissions::UnknownOp);
}
}