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";
const UNKNOWN_OP_SENTINEL: &str = "__unknown_space_patch_op__";
pub fn required_permissions_for_op(op: &SpacePatchOp) -> &'static [&'static str] {
match op {
SpacePatchOp::AddRole(_)
| SpacePatchOp::RemoveRole(_)
| SpacePatchOp::UpdateRole { .. } => &[MANAGE_ROLES],
SpacePatchOp::AddMember { .. } | SpacePatchOp::RemoveMember(_) => &[MANAGE_MEMBERS],
SpacePatchOp::UpdateMember { patch, .. } => {
if patch.role_ids.is_some() {
&[MANAGE_MEMBERS, MANAGE_ROLES]
} else {
&[MANAGE_MEMBERS]
}
}
SpacePatchOp::AddChannel(_)
| SpacePatchOp::RemoveChannel(_)
| SpacePatchOp::UpdateChannel { .. } => &[MANAGE_CHANNELS],
SpacePatchOp::AddCategory(_)
| SpacePatchOp::RemoveCategory(_)
| SpacePatchOp::UpdateCategory { .. } => &[MANAGE_CHANNELS],
_ => &[UNKNOWN_OP_SENTINEL],
}
}
#[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), &[MANAGE_ROLES]);
}
#[test]
fn remove_role_requires_manage_roles() {
let op = SpacePatchOp::RemoveRole(Id::from("r1"));
assert_eq!(required_permissions_for_op(&op), &[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), &[MANAGE_ROLES]);
}
#[test]
fn add_member_requires_manage_members_only() {
let op = SpacePatchOp::AddMember {
user_id: Id::from("u1"),
role_ids: vec![Id::from("r1"), Id::from("r2")],
};
assert_eq!(required_permissions_for_op(&op), &[MANAGE_MEMBERS]);
}
#[test]
fn remove_member_requires_manage_members() {
let op = SpacePatchOp::RemoveMember(Id::from("u1"));
assert_eq!(required_permissions_for_op(&op), &[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), &[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),
&[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),
&[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), &[MANAGE_CHANNELS]);
}
#[test]
fn remove_channel_requires_manage_channels() {
let op = SpacePatchOp::RemoveChannel(Id::from("ch1"));
assert_eq!(required_permissions_for_op(&op), &[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), &[MANAGE_CHANNELS]);
}
#[test]
fn add_category_requires_manage_channels() {
let op = SpacePatchOp::AddCategory(category_fixture());
assert_eq!(required_permissions_for_op(&op), &[MANAGE_CHANNELS]);
}
#[test]
fn remove_category_requires_manage_channels() {
let op = SpacePatchOp::RemoveCategory(Id::from("cat1"));
assert_eq!(required_permissions_for_op(&op), &[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), &[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_static_slice() {
fn assert_static_slice<F>(_f: F)
where
F: Fn(&SpacePatchOp) -> &'static [&'static str],
{
}
assert_static_slice(required_permissions_for_op);
}
}