#![allow(async_fn_in_trait)]
mod common;
use common::{
ACCOUNT_ID, ACCOUNT_ID_B, FaultyBackend, MemoryBackend, TrackingBackend, make_chat_group,
make_space, make_space_with_props,
};
use jmap_chat_server::message::{
handle_message_changes, handle_message_get, handle_message_query, handle_message_set,
};
use jmap_chat_server::{ChatMessageLifecycle, ChatSettings, ChatSpaces, ChatStore};
use jmap_chat_server::{
handle_ban_get, handle_ban_set, handle_chat_changes, handle_chat_get, handle_chat_query,
handle_chat_query_changes, handle_chat_set, handle_contact_changes, handle_contact_get,
handle_contact_query, handle_contact_query_changes, handle_contact_set, handle_invite_get,
handle_invite_set, handle_position_get, handle_position_set, handle_presence_changes,
handle_presence_get, handle_presence_set, handle_space_get, handle_space_join,
handle_space_set,
};
use jmap_chat_types::Chat;
use jmap_server::HandlerOutput;
use jmap_server::JmapReads;
use jmap_types::Id;
use serde_json::json;
#[tokio::test]
async fn memory_backend_initial_state_is_zero() {
let backend = common::account_backend();
let account_id = Id::from("account1");
let state = backend
.get_state::<Chat>(&(), &account_id)
.await
.expect("get_state must not fail on fresh backend");
assert_eq!(state.as_ref(), "0", "initial state must be \"0\"");
}
#[tokio::test]
async fn chat_get_empty() {
let backend = common::account_backend();
let account_id = Id::from(ACCOUNT_ID);
backend.register_account(&account_id);
let HandlerOutput {
primary: resp,
extra_invocations: invocations,
..
} = handle_chat_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": null }),
&[],
)
.await
.expect("handle_chat_get");
assert!(invocations.is_empty());
assert_eq!(resp["accountId"], ACCOUNT_ID);
assert_eq!(resp["state"], "0");
assert_eq!(resp["list"], json!([]));
assert_eq!(resp["notFound"], json!([]));
}
#[tokio::test]
async fn chat_get_not_found() {
let backend = common::account_backend();
let account_id = Id::from(ACCOUNT_ID);
backend.register_account(&account_id);
let HandlerOutput { primary: resp, .. } = handle_chat_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": ["missing1"] }),
&[],
)
.await
.expect("handle_chat_get");
assert_eq!(resp["list"], json!([]));
assert_eq!(resp["notFound"], json!(["missing1"]));
}
#[tokio::test]
async fn chat_get_missing_account_id() {
let backend = common::account_backend();
let err = handle_chat_get(&backend, &(), json!({}), &[])
.await
.unwrap_err();
assert_eq!(err.error_type.to_string(), "invalidArguments");
}
#[tokio::test]
async fn chat_set_create_group() {
let backend = common::account_backend();
let HandlerOutput { primary: resp, .. } = handle_chat_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": {
"c0": { "kind": "group", "name": "My Group" }
}
}),
&[],
)
.await
.expect("handle_chat_set");
assert!(resp["created"]["c0"].is_object(), "c0 must be in created");
assert_eq!(resp["notCreated"], json!(null));
assert_ne!(resp["newState"], resp["oldState"], "state must advance");
}
#[tokio::test]
async fn chat_set_create_direct_with_contact_id() {
let backend = common::account_backend();
let HandlerOutput { primary: resp, .. } = handle_chat_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": {
"c0": { "kind": "direct", "contactId": "u1" }
}
}),
&[],
)
.await
.expect("handle_chat_set");
assert!(resp["created"]["c0"].is_object());
assert_eq!(resp["notCreated"], json!(null));
}
#[tokio::test]
async fn chat_set_create_direct_missing_contact_id() {
let backend = common::account_backend();
let HandlerOutput { primary: resp, .. } = handle_chat_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": {
"c0": { "kind": "direct" }
}
}),
&[],
)
.await
.expect("handle_chat_set");
assert_eq!(resp["created"], json!(null));
assert!(resp["notCreated"]["c0"].is_object());
assert_eq!(resp["notCreated"]["c0"]["type"], "invalidProperties");
}
#[tokio::test]
async fn chat_set_create_channel_missing_space_id() {
let backend = common::account_backend();
let HandlerOutput { primary: resp, .. } = handle_chat_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": {
"c0": { "kind": "channel" }
}
}),
&[],
)
.await
.expect("handle_chat_set");
assert!(resp["notCreated"]["c0"].is_object());
assert_eq!(resp["notCreated"]["c0"]["type"], "forbidden");
}
#[tokio::test]
async fn chat_set_create_missing_kind() {
let backend = common::account_backend();
let HandlerOutput { primary: resp, .. } = handle_chat_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": {
"c0": { "name": "No Kind" }
}
}),
&[],
)
.await
.expect("handle_chat_set");
assert!(resp["notCreated"]["c0"].is_object());
let props = resp["notCreated"]["c0"]["properties"]
.as_array()
.expect("properties");
assert!(props.iter().any(|p| p == "kind"));
}
#[tokio::test]
async fn chat_set_create_unknown_kind_rejected() {
let backend = common::account_backend();
let HandlerOutput { primary: resp, .. } = handle_chat_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": {
"c0": { "kind": "vampire", "name": "Junk" }
}
}),
&[],
)
.await
.expect("handle_chat_set");
assert!(resp["notCreated"]["c0"].is_object());
assert_eq!(resp["notCreated"]["c0"]["type"], "invalidProperties");
let props = resp["notCreated"]["c0"]["properties"]
.as_array()
.expect("properties");
assert!(
props.iter().any(|p| p == "kind"),
"expected 'kind' in properties, got {props:?}"
);
assert!(resp["created"].as_object().is_none_or(|m| m.is_empty()));
}
#[tokio::test]
async fn chat_set_update_too_deep_patch_rejected_not_silently_truncated() {
let backend = common::account_backend();
let chat_id = make_chat_group(&backend, "Original").await;
const DEPTH: usize = 200;
let mut patch = json!({ "leaf": "ignored" });
for _ in 0..DEPTH {
patch = json!({ "a": patch });
}
let patch = json!({ "description": patch });
let HandlerOutput { primary: resp, .. } = handle_chat_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": { &chat_id: patch }
}),
&[],
)
.await
.expect("handle_chat_set");
assert_eq!(
resp["notUpdated"][&chat_id]["type"], "invalidPatch",
"deeply-nested patch must surface as invalidPatch, \
not silently truncate (bd:JMAP-wlip.1): {:?}",
resp["notUpdated"][&chat_id]
);
assert!(
resp["updated"].get(&chat_id).is_none(),
"deeply-nested patch must NOT appear in updated: {:?}",
resp["updated"]
);
let HandlerOutput {
primary: get_resp, ..
} = handle_chat_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": [&chat_id] }),
&[],
)
.await
.expect("handle_chat_get");
assert_eq!(
get_resp["list"][0]["name"], "Original",
"stored Chat.name must be unchanged after a rejected too-deep patch: {:?}",
get_resp["list"][0]
);
}
#[tokio::test]
async fn chat_set_update_readonly_field_rejected() {
let backend = common::account_backend();
let chat_id = make_chat_group(&backend, "G").await;
let HandlerOutput { primary: resp, .. } = handle_chat_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": {
&chat_id: { "createdAt": "2020-01-01T00:00:00Z" }
}
}),
&[],
)
.await
.expect("update");
assert!(resp["notUpdated"][&chat_id].is_object());
assert_eq!(resp["notUpdated"][&chat_id]["type"], "invalidProperties");
}
#[tokio::test]
async fn chat_set_destroy() {
let backend = common::account_backend();
let chat_id = make_chat_group(&backend, "Temp").await;
let HandlerOutput {
primary: destroy_resp,
..
} = handle_chat_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({ "accountId": ACCOUNT_ID, "destroy": [chat_id] }),
&[],
)
.await
.expect("destroy");
assert!(destroy_resp["destroyed"].as_array().is_some());
assert_eq!(destroy_resp["notDestroyed"], json!(null));
}
#[tokio::test]
async fn chat_set_if_in_state_mismatch() {
let backend = common::account_backend();
let err = handle_chat_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"ifInState": "999",
"create": { "c0": { "kind": "group" } }
}),
&[],
)
.await
.unwrap_err();
assert_eq!(err.error_type.to_string(), "stateMismatch");
}
#[tokio::test]
async fn chat_changes_empty() {
let backend = common::account_backend();
let account_id = Id::from(ACCOUNT_ID);
backend.register_account(&account_id);
let HandlerOutput { primary: resp, .. } = handle_chat_changes(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "sinceState": "0" }),
&[],
)
.await
.expect("handle_chat_changes");
assert_eq!(resp["created"], json!([]));
assert_eq!(resp["updated"], json!([]));
assert_eq!(resp["destroyed"], json!([]));
assert!(!resp["hasMoreChanges"].as_bool().unwrap_or(true));
}
#[tokio::test]
async fn chat_changes_missing_since_state() {
let backend = common::account_backend();
let account_id = Id::from(ACCOUNT_ID);
backend.register_account(&account_id);
let err = handle_chat_changes(&backend, &(), json!({ "accountId": ACCOUNT_ID }), &[])
.await
.unwrap_err();
assert_eq!(err.error_type.to_string(), "invalidArguments");
}
#[tokio::test]
async fn chat_changes_after_create() {
let backend = common::account_backend();
handle_chat_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": { "c0": { "kind": "group", "name": "G" } }
}),
&[],
)
.await
.expect("create");
let HandlerOutput { primary: resp, .. } = handle_chat_changes(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "sinceState": "0" }),
&[],
)
.await
.expect("changes");
let created = resp["created"].as_array().expect("created array");
assert_eq!(created.len(), 1, "one created id expected");
}
#[tokio::test]
async fn chat_query_empty() {
let backend = common::account_backend();
backend.register_account(&jmap_types::Id::from(ACCOUNT_ID));
let HandlerOutput { primary: resp, .. } =
handle_chat_query(&backend, &(), json!({ "accountId": ACCOUNT_ID }), &[])
.await
.expect("handle_chat_query");
assert_eq!(resp["ids"], json!([]));
assert_eq!(resp["position"], 0);
}
#[tokio::test]
async fn chat_query_with_calculate_total() {
let backend = common::account_backend();
handle_chat_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({ "accountId": ACCOUNT_ID, "create": { "c0": { "kind": "group", "name": "G" } } }),
&[],
)
.await
.expect("create");
let HandlerOutput { primary: resp, .. } = handle_chat_query(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "calculateTotal": true }),
&[],
)
.await
.expect("query");
assert!(resp["total"].is_number(), "total must be present");
assert_eq!(resp["total"], json!(1u64));
}
#[tokio::test]
async fn chat_query_changes_missing_since() {
let backend = common::account_backend();
let account_id = Id::from(ACCOUNT_ID);
backend.register_account(&account_id);
let err = handle_chat_query_changes(&backend, &(), json!({ "accountId": ACCOUNT_ID }), &[])
.await
.unwrap_err();
assert_eq!(err.error_type.to_string(), "invalidArguments");
}
#[tokio::test]
async fn chat_query_changes_after_create() {
let backend = common::account_backend();
handle_chat_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({ "accountId": ACCOUNT_ID, "create": { "c0": { "kind": "group", "name": "G" } } }),
&[],
)
.await
.expect("create");
let HandlerOutput { primary: resp, .. } = handle_chat_query_changes(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "sinceQueryState": "0" }),
&[],
)
.await
.expect("queryChanges");
let added = resp["added"].as_array().expect("added array");
assert_eq!(added.len(), 1);
assert!(added[0]["id"].is_string());
assert!(added[0]["index"].is_number());
}
#[tokio::test]
async fn chat_query_changes_reports_updated_id_in_removed_and_added() {
let backend = common::account_backend();
let chat_id = make_chat_group(&backend, "Original").await;
let HandlerOutput { primary: query, .. } =
handle_chat_query(&backend, &(), json!({ "accountId": ACCOUNT_ID }), &[])
.await
.expect("handle_chat_query");
assert_eq!(query["ids"], json!([chat_id]), "{query}");
let HandlerOutput { primary: upd, .. } = handle_chat_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": { &chat_id: { "name": "Renamed" } }
}),
&[],
)
.await
.expect("update");
assert!(upd["notUpdated"].is_null(), "{upd}");
let HandlerOutput { primary: qc, .. } = handle_chat_query_changes(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "sinceQueryState": query["queryState"] }),
&[],
)
.await
.expect("queryChanges");
assert_eq!(qc["removed"], json!([chat_id]), "{qc}");
assert_eq!(qc["added"], json!([{ "id": chat_id, "index": 0 }]), "{qc}");
}
#[tokio::test]
async fn chat_typing_returns_success_when_contact_not_blocked() {
use jmap_chat_server::handle_chat_typing;
let backend = common::account_backend();
backend.insert_object_for_test(
"Chat",
ACCOUNT_ID,
"c1",
json!({
"id": "c1",
"kind": "direct",
"contactId": "u1",
"createdAt": "2024-01-01T00:00:00Z",
"unreadCount": 0,
"pinnedMessageIds": [],
"muted": false,
"receiveTypingIndicators": true
}),
);
let HandlerOutput { primary: resp, .. } = handle_chat_typing(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "chatId": "c1", "typing": true }),
)
.await
.expect("handle_chat_typing");
assert_eq!(resp["accountId"], ACCOUNT_ID);
}
#[tokio::test]
async fn chat_typing_returns_success_when_contact_blocked() {
use jmap_chat_server::handle_chat_typing;
let backend = common::account_backend();
backend.insert_object_for_test(
"Chat",
ACCOUNT_ID,
"c1",
json!({
"id": "c1",
"kind": "direct",
"contactId": "u1",
"createdAt": "2024-01-01T00:00:00Z",
"unreadCount": 0,
"pinnedMessageIds": [],
"muted": false,
"receiveTypingIndicators": true
}),
);
backend.insert_object_for_test(
"ChatContact",
ACCOUNT_ID,
"u1",
json!({
"id": "u1",
"identity": "blocked-user@example.org",
"login": "blocked-user@example.org",
"firstSeenAt": "2024-01-01T00:00:00Z",
"lastSeenAt": "2024-01-02T00:00:00Z",
"blocked": true
}),
);
let HandlerOutput { primary: resp, .. } = handle_chat_typing(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "chatId": "c1", "typing": true }),
)
.await
.expect("handle_chat_typing");
assert_eq!(
resp["accountId"], ACCOUNT_ID,
"wire response is unchanged when sender is blocked — suppression is consumer-side"
);
}
fn seed_group_chat(backend: &MemoryBackend<()>, id: &str, member_id: &str) {
backend.insert_object_for_test(
"Chat",
ACCOUNT_ID,
id,
json!({
"id": id,
"kind": "group",
"name": "Team",
"members": [
{ "id": member_id, "role": "admin", "joinedAt": "2024-01-01T00:00:00Z" }
],
"createdAt": "2024-01-01T00:00:00Z",
"unreadCount": 0,
"pinnedMessageIds": [],
"muted": false,
"receiveTypingIndicators": true
}),
);
}
#[tokio::test]
async fn chat_typing_unknown_or_non_participant_chat_is_invalid_arguments() {
use jmap_chat_server::handle_chat_typing;
let backend = common::account_backend();
seed_group_chat(&backend, "g1", "someone-else");
let mut errors = Vec::new();
for chat_id in ["nosuchchat", "g1"] {
let err = handle_chat_typing(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "chatId": chat_id, "typing": true }),
)
.await
.expect_err(chat_id);
assert_eq!(err.error_type.to_string(), "invalidArguments", "{chat_id}");
errors.push(err);
}
assert_eq!(
errors[0], errors[1],
"the two cases must be indistinguishable"
);
}
#[tokio::test]
async fn chat_typing_group_member_succeeds() {
use jmap_chat_server::handle_chat_typing;
let backend = common::account_backend();
seed_group_chat(&backend, "g1", ACCOUNT_ID);
let HandlerOutput { primary: resp, .. } = handle_chat_typing(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "chatId": "g1", "typing": false }),
)
.await
.expect("member may signal typing");
assert_eq!(resp["accountId"], ACCOUNT_ID);
}
#[tokio::test]
async fn chat_typing_does_not_check_block_in_sender_account() {
use jmap_chat_server::handle_chat_typing;
let backend = TrackingBackend::new();
backend.inner().insert_object_for_test(
"Chat",
ACCOUNT_ID,
"c1",
json!({
"id": "c1",
"kind": "direct",
"contactId": "u1",
"createdAt": "2024-01-01T00:00:00Z",
"unreadCount": 0,
"pinnedMessageIds": [],
"muted": false,
"receiveTypingIndicators": true
}),
);
backend.inner().insert_object_for_test(
"ChatContact",
ACCOUNT_ID,
"u1",
json!({
"id": "u1",
"identity": "recipient@example.org",
"login": "recipient@example.org",
"firstSeenAt": "2024-01-01T00:00:00Z",
"lastSeenAt": "2024-01-02T00:00:00Z",
"blocked": true
}),
);
let HandlerOutput { primary: resp, .. } = handle_chat_typing(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "chatId": "c1", "typing": true }),
)
.await
.expect("handle_chat_typing");
assert_eq!(resp["accountId"], ACCOUNT_ID);
assert_eq!(
backend.is_contact_blocked_call_count(),
0,
"the blocked check reads the recipient's list, which the sender's request does not name"
);
}
#[tokio::test]
async fn chat_typing_skips_is_contact_blocked_on_group_chat() {
use jmap_chat_server::handle_chat_typing;
let backend = TrackingBackend::new();
backend.inner().insert_object_for_test(
"Chat",
ACCOUNT_ID,
"c1",
json!({
"id": "c1",
"kind": "group",
"members": [
{ "id": ACCOUNT_ID, "role": "admin", "joinedAt": "2024-01-01T00:00:00Z" }
],
"createdAt": "2024-01-01T00:00:00Z",
"unreadCount": 0,
"pinnedMessageIds": [],
"muted": false,
"receiveTypingIndicators": true
}),
);
let HandlerOutput { .. } = handle_chat_typing(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "chatId": "c1", "typing": true }),
)
.await
.expect("handle_chat_typing");
assert_eq!(
backend.is_contact_blocked_call_count(),
0,
"group/channel chats are skipped — fan-out is consumer-side"
);
}
#[tokio::test]
async fn chat_typing_skips_is_contact_blocked_when_chat_not_found() {
use jmap_chat_server::handle_chat_typing;
let backend = TrackingBackend::new();
let err = handle_chat_typing(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "chatId": "ghost", "typing": true }),
)
.await
.expect_err("unknown chatId");
assert_eq!(err.error_type.to_string(), "invalidArguments");
assert_eq!(
backend.is_contact_blocked_call_count(),
0,
"is_contact_blocked must not be consulted for a non-existent chatId"
);
}
#[tokio::test]
async fn message_set_create_missing_chat_id() {
let backend = common::account_backend();
let HandlerOutput { primary: resp, .. } = handle_message_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": { "m0": { "body": "Hello" } }
}),
&[],
)
.await
.expect("handle_message_set");
assert!(resp["notCreated"]["m0"].is_object());
let props = resp["notCreated"]["m0"]["properties"]
.as_array()
.expect("props");
assert!(props.iter().any(|p| p == "chatId"));
}
#[tokio::test]
async fn message_set_create_success() {
let backend = common::account_backend();
common::seed_group_chat(&backend, "c1");
let HandlerOutput { primary: resp, .. } = handle_message_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": {
"m0": { "chatId": "c1", "body": "Hello, world!", "sentAt": "2024-01-01T00:00:00Z" }
}
}),
&[],
)
.await
.expect("handle_message_set");
assert!(resp["created"]["m0"].is_object());
assert_eq!(resp["notCreated"], json!(null));
assert_eq!(resp["created"]["m0"]["body"], "Hello, world!");
}
#[tokio::test]
async fn message_set_update_readonly_field() {
let backend = common::account_backend();
common::seed_group_chat(&backend, "c1");
let HandlerOutput {
primary: create_resp,
..
} = handle_message_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": { "m0": { "chatId": "c1", "body": "hi", "sentAt": "2024-01-01T00:00:00Z" } }
}),
&[],
)
.await
.expect("create");
let msg_id = create_resp["created"]["m0"]["id"].as_str().expect("id");
let HandlerOutput { primary: resp, .. } = handle_message_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": {
msg_id: { "deliveryState": "delivered" }
}
}),
&[],
)
.await
.expect("update");
assert!(resp["notUpdated"][msg_id].is_object());
assert_eq!(resp["notUpdated"][msg_id]["type"], "invalidProperties");
}
#[tokio::test]
async fn message_get_returns_created() {
let backend = common::account_backend();
common::seed_group_chat(&backend, "c1");
let HandlerOutput { primary: create_resp, .. } = handle_message_set(&backend, &(), &std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": { "m0": { "chatId": "c1", "body": "Test body", "sentAt": "2024-01-01T00:00:00Z" } }
}),
&[],
)
.await
.expect("create");
let msg_id = create_resp["created"]["m0"]["id"]
.as_str()
.expect("id")
.to_owned();
let HandlerOutput {
primary: get_resp, ..
} = handle_message_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": [msg_id] }),
&[],
)
.await
.expect("get");
assert_eq!(get_resp["list"].as_array().expect("list").len(), 1);
assert_eq!(get_resp["list"][0]["body"], "Test body");
}
#[tokio::test]
async fn message_changes_after_create() {
let backend = common::account_backend();
common::seed_group_chat(&backend, "c1");
handle_message_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": { "m0": { "chatId": "c1", "body": "Hi", "sentAt": "2024-01-01T00:00:00Z" } }
}),
&[],
)
.await
.expect("create");
let HandlerOutput { primary: resp, .. } = handle_message_changes(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "sinceState": "0" }),
&[],
)
.await
.expect("changes");
assert_eq!(resp["created"].as_array().expect("created").len(), 1);
}
#[tokio::test]
async fn message_query_order() {
let backend = common::account_backend();
common::seed_group_chat(&backend, "c1");
for i in 0..3u32 {
handle_message_set(&backend, &(), &std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": { format!("m{i}"): { "chatId": "c1", "body": format!("msg {i}"), "sentAt": "2024-01-01T00:00:00Z" } }
}),
&[],
)
.await
.expect("create");
}
let HandlerOutput { primary: resp, .. } = handle_message_query(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "calculateTotal": true, "filter": { "chatId": "c1" } }),
&[],
)
.await
.expect("query");
assert_eq!(resp["total"], json!(3u64));
let ids = resp["ids"].as_array().expect("ids");
assert_eq!(ids.len(), 3);
}
#[tokio::test]
async fn message_set_update_body_injects_edited_at() {
let backend = common::account_backend();
common::seed_group_chat(&backend, "c1");
let HandlerOutput { primary: create_resp, .. } = handle_message_set(&backend, &(), &std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": { "m0": { "chatId": "c1", "body": "original", "sentAt": "2024-01-01T00:00:00Z" } }
}),
&[],
)
.await
.expect("create");
let msg_id = create_resp["created"]["m0"]["id"]
.as_str()
.expect("id")
.to_owned();
let HandlerOutput {
primary: update_resp,
..
} = handle_message_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": { &msg_id: { "body": "edited" } }
}),
&[],
)
.await
.expect("update");
assert_eq!(update_resp["updated"][&msg_id], json!(null));
assert_eq!(update_resp["notUpdated"], json!(null));
let HandlerOutput {
primary: get_resp, ..
} = handle_message_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": [&msg_id] }),
&[],
)
.await
.expect("get");
let msg = &get_resp["list"][0];
assert_eq!(msg["body"], "edited", "body must be updated");
assert!(
msg["editedAt"].is_string(),
"editedAt must be present after body update"
);
}
#[tokio::test]
async fn message_set_update_delete_for_all_injects_deleted_at() {
let backend = common::account_backend();
common::seed_group_chat(&backend, "c1");
let HandlerOutput { primary: create_resp, .. } = handle_message_set(&backend, &(), &std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": { "m0": { "chatId": "c1", "body": "hello", "sentAt": "2024-01-01T00:00:00Z" } }
}),
&[],
)
.await
.expect("create");
let msg_id = create_resp["created"]["m0"]["id"]
.as_str()
.expect("id")
.to_owned();
let HandlerOutput {
primary: update_resp,
..
} = handle_message_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": { &msg_id: { "deletedForAll": true } }
}),
&[],
)
.await
.expect("update");
assert_eq!(update_resp["updated"][&msg_id], json!(null));
assert_eq!(update_resp["notUpdated"], json!(null));
let HandlerOutput {
primary: get_resp, ..
} = handle_message_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": [&msg_id] }),
&[],
)
.await
.expect("get");
let msg = &get_resp["list"][0];
assert_eq!(msg["deletedForAll"], true, "deletedForAll must be true");
assert!(
msg["deletedAt"].is_string(),
"deletedAt must be present after deletedForAll update"
);
}
#[tokio::test]
async fn message_set_update_delete_for_all_purges_content() {
let backend = common::account_backend();
backend.set_retains_edit_history_for_test(true);
backend.insert_object_for_test(
"Message",
ACCOUNT_ID,
"m1",
json!({
"id": "m1",
"senderMsgId": "smsg1",
"senderId": ACCOUNT_ID,
"chatId": "c1",
"body": "edited",
"bodyType": "text/plain",
"attachments": [
{
"blobId": "b1",
"filename": "plan.pdf",
"contentType": "application/pdf",
"size": 1024,
"sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
}
],
"mentions": [],
"broadcastMentions": [],
"actions": [],
"reactions": {},
"sentAt": "2024-01-01T00:00:00Z",
"receivedAt": "2024-01-01T00:00:01Z",
"deliveryState": "delivered",
"editedAt": "2024-01-02T00:00:00Z",
"editHistory": [
{
"body": "original",
"bodyType": "text/plain",
"editedAt": "2024-01-02T00:00:00Z"
}
]
}),
);
let HandlerOutput {
primary: update_resp,
..
} = handle_message_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": { "m1": { "deletedForAll": true } }
}),
&[],
)
.await
.expect("update");
assert_eq!(update_resp["notUpdated"], json!(null));
let HandlerOutput {
primary: get_resp, ..
} = handle_message_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": ["m1"] }),
&[],
)
.await
.expect("get");
let msg = &get_resp["list"][0];
assert!(msg["deletedAt"].is_string(), "deletedAt must be set");
assert_eq!(msg["body"], "", "deleted Message body must be empty");
assert_eq!(
msg["attachments"],
json!([]),
"deleted Message attachments must be empty"
);
assert!(
msg.get("editHistory").is_none(),
"deleted Message must not carry editHistory, got: {msg}"
);
}
fn insert_deletable_message(backend: &MemoryBackend<()>, sender_id: &str) {
backend.set_retains_edit_history_for_test(true);
backend.insert_object_for_test(
"Message",
ACCOUNT_ID,
"m1",
json!({
"id": "m1",
"senderMsgId": "smsg1",
"senderId": sender_id,
"chatId": "c1",
"body": "edited",
"bodyType": "text/plain",
"attachments": [
{
"blobId": "b1",
"filename": "plan.pdf",
"contentType": "application/pdf",
"size": 1024,
"sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
}
],
"mentions": [],
"broadcastMentions": [],
"actions": [],
"reactions": {},
"sentAt": "2024-01-01T00:00:00Z",
"receivedAt": "2024-01-01T00:00:01Z",
"deliveryState": "delivered",
"editedAt": "2024-01-02T00:00:00Z",
"editHistory": [
{
"body": "original",
"bodyType": "text/plain",
"editedAt": "2024-01-02T00:00:00Z"
}
]
}),
);
}
#[tokio::test]
async fn message_set_update_local_delete_purges_content() {
let backend = common::account_backend();
insert_deletable_message(&backend, "self");
let HandlerOutput {
primary: update_resp,
..
} = handle_message_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": { "m1": { "deletedAt": "2024-01-03T00:00:00Z" } }
}),
&[],
)
.await
.expect("update");
assert_eq!(update_resp["notUpdated"], json!(null));
let HandlerOutput {
primary: get_resp, ..
} = handle_message_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": ["m1"] }),
&[],
)
.await
.expect("get");
let msg = &get_resp["list"][0];
assert_eq!(msg["deletedAt"], "2024-01-03T00:00:00Z");
assert_eq!(msg["body"], "", "deleted Message body must be empty");
assert_eq!(
msg["attachments"],
json!([]),
"deleted Message attachments must be empty"
);
assert!(
msg.get("editHistory").is_none(),
"deleted Message must not carry editHistory, got: {msg}"
);
}
#[tokio::test]
async fn message_set_update_delete_for_all_rejects_other_sender() {
let backend = common::account_backend();
insert_deletable_message(&backend, "contact-alice");
let HandlerOutput {
primary: update_resp,
..
} = handle_message_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": { "m1": { "deletedForAll": true } }
}),
&[],
)
.await
.expect("update");
assert_eq!(update_resp["notUpdated"]["m1"]["type"], "forbidden");
assert_eq!(update_resp["updated"], json!(null));
let HandlerOutput {
primary: get_resp, ..
} = handle_message_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": ["m1"] }),
&[],
)
.await
.expect("get");
let msg = &get_resp["list"][0];
assert!(msg.get("deletedAt").is_none(), "got: {msg}");
assert!(msg.get("deletedForAll").is_none(), "got: {msg}");
assert_eq!(msg["body"], "edited");
assert_eq!(msg["attachments"][0]["blobId"], "b1");
assert_eq!(msg["editHistory"][0]["body"], "original");
}
#[tokio::test]
async fn message_set_update_edit_rejects_other_sender() {
let backend = common::account_backend();
insert_deletable_message(&backend, "contact-alice");
let HandlerOutput {
primary: update_resp,
..
} = handle_message_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": { "m1": { "body": "rewritten", "bodyType": "text/plain" } }
}),
&[],
)
.await
.expect("update");
assert_eq!(update_resp["notUpdated"]["m1"]["type"], "forbidden");
assert_eq!(update_resp["updated"], json!(null));
let HandlerOutput {
primary: get_resp, ..
} = handle_message_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": ["m1"] }),
&[],
)
.await
.expect("get");
let msg = &get_resp["list"][0];
assert_eq!(msg["body"], "edited");
assert_eq!(msg["editedAt"], "2024-01-02T00:00:00Z");
}
#[tokio::test]
async fn message_set_update_edit_rejects_deleted_message() {
let backend = common::account_backend();
insert_deletable_message(&backend, ACCOUNT_ID);
let HandlerOutput {
primary: delete_resp,
..
} = handle_message_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": { "m1": { "deletedAt": "2024-01-03T00:00:00Z" } }
}),
&[],
)
.await
.expect("delete");
assert_eq!(delete_resp["notUpdated"], json!(null));
let HandlerOutput {
primary: update_resp,
..
} = handle_message_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": {
"m1": { "mentions": [{ "id": "contact-alice", "offset": 0, "length": 0 }] }
}
}),
&[],
)
.await
.expect("update");
assert_eq!(update_resp["notUpdated"]["m1"]["type"], "forbidden");
assert_eq!(update_resp["updated"], json!(null));
let HandlerOutput {
primary: get_resp, ..
} = handle_message_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": ["m1"] }),
&[],
)
.await
.expect("get");
assert_eq!(get_resp["list"][0]["mentions"], json!([]));
}
#[tokio::test]
async fn message_set_update_mark_as_read() {
let backend = common::account_backend();
common::seed_group_chat(&backend, "c1");
let HandlerOutput { primary: create_resp, .. } = handle_message_set(&backend, &(), &std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": { "m0": { "chatId": "c1", "body": "read me", "sentAt": "2024-01-01T00:00:00Z" } }
}),
&[],
)
.await
.expect("create");
let msg_id = create_resp["created"]["m0"]["id"]
.as_str()
.expect("id")
.to_owned();
let read_ts = "2024-01-01T00:00:00Z";
let HandlerOutput {
primary: update_resp,
..
} = handle_message_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": { &msg_id: { "readAt": read_ts } }
}),
&[],
)
.await
.expect("update");
assert_eq!(update_resp["updated"][&msg_id], json!(null));
assert_eq!(update_resp["notUpdated"], json!(null));
let HandlerOutput {
primary: get_resp, ..
} = handle_message_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": [&msg_id] }),
&[],
)
.await
.expect("get");
assert_eq!(
get_resp["list"][0]["readAt"], read_ts,
"readAt must match the client-provided timestamp"
);
}
#[tokio::test]
async fn message_set_read_at_defaults_disposition() {
let backend = common::account_backend();
common::seed_group_chat(&backend, "c1");
let HandlerOutput { primary: create_resp, .. } = handle_message_set(&backend, &(), &std::collections::BTreeMap::new(),
json!({ "accountId": ACCOUNT_ID, "create": { "m0": { "chatId": "c1", "body": "hi", "sentAt": "2026-01-01T00:00:00Z" } } }),
&[],
).await.expect("create");
let msg_id = create_resp["created"]["m0"]["id"]
.as_str()
.expect("id")
.to_owned();
let HandlerOutput { primary: update_resp, .. } = handle_message_set(&backend, &(), &std::collections::BTreeMap::new(),
json!({ "accountId": ACCOUNT_ID, "update": { msg_id.as_str(): { "readAt": "2026-01-05T10:00:00Z" } } }),
&[],
).await.expect("update");
assert_eq!(update_resp["updated"][msg_id.as_str()], json!(null));
assert_eq!(update_resp["notUpdated"], json!(null));
let HandlerOutput {
primary: get_resp, ..
} = handle_message_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": [msg_id.as_str()] }),
&[],
)
.await
.expect("get");
let msg = &get_resp["list"][0];
assert_eq!(msg["readAt"], "2026-01-05T10:00:00Z");
assert_eq!(
msg["readDisposition"], "displayed",
"server must store \"displayed\" when readDisposition is omitted"
);
}
#[tokio::test]
async fn message_set_explicit_disposition_preserved() {
let backend = common::account_backend();
common::seed_group_chat(&backend, "c1");
let HandlerOutput { primary: create_resp, .. } = handle_message_set(&backend, &(), &std::collections::BTreeMap::new(),
json!({ "accountId": ACCOUNT_ID, "create": { "m0": { "chatId": "c1", "body": "hi", "sentAt": "2026-01-01T00:00:00Z" } } }),
&[],
).await.expect("create");
let msg_id = create_resp["created"]["m0"]["id"]
.as_str()
.expect("id")
.to_owned();
let HandlerOutput { primary: update_resp, .. } = handle_message_set(&backend, &(), &std::collections::BTreeMap::new(),
json!({ "accountId": ACCOUNT_ID, "update": { msg_id.as_str(): { "readAt": "2026-01-05T10:00:00Z", "readDisposition": "deleted" } } }),
&[],
).await.expect("update");
assert_eq!(update_resp["updated"][msg_id.as_str()], json!(null));
assert_eq!(update_resp["notUpdated"], json!(null));
let HandlerOutput {
primary: get_resp, ..
} = handle_message_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": [msg_id.as_str()] }),
&[],
)
.await
.expect("get");
let msg = &get_resp["list"][0];
assert_eq!(
msg["readDisposition"], "deleted",
"explicit \"deleted\" disposition must be preserved"
);
}
#[tokio::test]
async fn message_set_extension_disposition_stored_as_is() {
let backend = common::account_backend();
common::seed_group_chat(&backend, "c1");
let HandlerOutput { primary: create_resp, .. } = handle_message_set(&backend, &(), &std::collections::BTreeMap::new(),
json!({ "accountId": ACCOUNT_ID, "create": { "m0": { "chatId": "c1", "body": "hi", "sentAt": "2026-01-01T00:00:00Z" } } }),
&[],
).await.expect("create");
let msg_id = create_resp["created"]["m0"]["id"]
.as_str()
.expect("id")
.to_owned();
let HandlerOutput { primary: update_resp, .. } = handle_message_set(&backend, &(), &std::collections::BTreeMap::new(),
json!({ "accountId": ACCOUNT_ID, "update": { msg_id.as_str(): { "readAt": "2026-01-05T10:00:00Z", "readDisposition": "voice-listened" } } }),
&[],
).await.expect("update");
assert_eq!(update_resp["updated"][msg_id.as_str()], json!(null));
assert_eq!(update_resp["notUpdated"], json!(null));
let HandlerOutput {
primary: get_resp, ..
} = handle_message_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": [msg_id.as_str()] }),
&[],
)
.await
.expect("get");
let msg = &get_resp["list"][0];
assert_eq!(
msg["readDisposition"], "voice-listened",
"unrecognized extension value must be stored as-is per spec §335"
);
}
#[tokio::test]
async fn message_set_no_read_at_no_disposition_injected() {
let backend = common::account_backend();
common::seed_group_chat(&backend, "c1");
let HandlerOutput { primary: create_resp, .. } = handle_message_set(&backend, &(), &std::collections::BTreeMap::new(),
json!({ "accountId": ACCOUNT_ID, "create": { "m0": { "chatId": "c1", "body": "original", "sentAt": "2026-01-01T00:00:00Z" } } }),
&[],
).await.expect("create");
let msg_id = create_resp["created"]["m0"]["id"]
.as_str()
.expect("id")
.to_owned();
let HandlerOutput { primary: update_resp, .. } = handle_message_set(&backend, &(), &std::collections::BTreeMap::new(),
json!({ "accountId": ACCOUNT_ID, "update": { msg_id.as_str(): { "body": "edited text" } } }),
&[],
)
.await
.expect("update");
assert_eq!(update_resp["updated"][msg_id.as_str()], json!(null));
assert_eq!(update_resp["notUpdated"], json!(null));
let HandlerOutput {
primary: get_resp, ..
} = handle_message_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": [msg_id.as_str()] }),
&[],
)
.await
.expect("get");
let msg = &get_resp["list"][0];
assert_eq!(msg["body"], "edited text");
assert_eq!(
msg["readDisposition"],
json!(null),
"readDisposition must be absent when readAt is not set"
);
}
#[tokio::test]
async fn message_set_lone_read_disposition_is_invalid_properties() {
let backend = common::account_backend();
common::seed_group_chat(&backend, "c1");
let HandlerOutput { primary: create_resp, .. } = handle_message_set(&backend, &(), &std::collections::BTreeMap::new(),
json!({ "accountId": ACCOUNT_ID, "create": { "m0": { "chatId": "c1", "body": "hi", "sentAt": "2026-01-01T00:00:00Z" } } }),
&[],
).await.expect("create");
let msg_id = create_resp["created"]["m0"]["id"]
.as_str()
.expect("id")
.to_owned();
for patch in [
json!({ "readDisposition": "deleted" }),
json!({ "readDisposition": "deleted", "readAt": null }),
] {
let HandlerOutput {
primary: update_resp,
..
} = handle_message_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({ "accountId": ACCOUNT_ID, "update": { msg_id.as_str(): patch } }),
&[],
)
.await
.expect("update");
assert_eq!(
update_resp["notUpdated"][msg_id.as_str()],
json!({ "type": "invalidProperties", "properties": ["readDisposition"] }),
"patch {patch}"
);
}
let HandlerOutput {
primary: get_resp, ..
} = handle_message_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": [msg_id.as_str()] }),
&[],
)
.await
.expect("get");
assert_eq!(get_resp["list"][0]["readDisposition"], json!(null));
}
#[tokio::test]
async fn message_set_unsupported_body_type_is_invalid_properties() {
let backend = common::account_backend();
common::seed_group_chat(&backend, "c1");
let HandlerOutput { primary: create_resp, .. } = handle_message_set(&backend, &(), &std::collections::BTreeMap::new(),
json!({ "accountId": ACCOUNT_ID, "create": {
"bad": { "chatId": "c1", "body": "hi", "bodyType": "text/html", "sentAt": "2026-01-01T00:00:00Z" },
"m0": { "chatId": "c1", "body": "hi", "sentAt": "2026-01-01T00:00:00Z" }
} }),
&[],
)
.await
.expect("create");
assert_eq!(
create_resp["notCreated"]["bad"],
json!({ "type": "invalidProperties", "properties": ["bodyType"] })
);
let msg_id = create_resp["created"]["m0"]["id"]
.as_str()
.expect("id")
.to_owned();
let HandlerOutput { primary: update_resp, .. } = handle_message_set(&backend, &(), &std::collections::BTreeMap::new(),
json!({ "accountId": ACCOUNT_ID, "update": { msg_id.as_str(): { "bodyType": "text/html" } } }),
&[],
)
.await
.expect("update");
assert_eq!(
update_resp["notUpdated"][msg_id.as_str()],
json!({ "type": "invalidProperties", "properties": ["bodyType"] })
);
let HandlerOutput {
primary: get_resp, ..
} = handle_message_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": [msg_id.as_str()] }),
&[],
)
.await
.expect("get");
assert_eq!(get_resp["list"][0]["bodyType"], json!("text/plain"));
}
#[tokio::test]
async fn message_set_read_at_null_clears_read_disposition() {
let backend = common::account_backend();
common::seed_group_chat(&backend, "c1");
let HandlerOutput { primary: create_resp, .. } = handle_message_set(&backend, &(), &std::collections::BTreeMap::new(),
json!({ "accountId": ACCOUNT_ID, "create": { "m0": { "chatId": "c1", "body": "hi", "sentAt": "2026-01-01T00:00:00Z" } } }),
&[],
).await.expect("create");
let msg_id = create_resp["created"]["m0"]["id"]
.as_str()
.expect("id")
.to_owned();
for (step, patch, disposition) in [
("unread never-read", json!({ "readAt": null }), json!(null)),
(
"read",
json!({ "readAt": "2026-01-05T10:00:00Z", "readDisposition": "deleted" }),
json!("deleted"),
),
("unread after read", json!({ "readAt": null }), json!(null)),
] {
let HandlerOutput {
primary: update_resp,
..
} = handle_message_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({ "accountId": ACCOUNT_ID, "update": { msg_id.as_str(): patch } }),
&[],
)
.await
.expect("update");
assert_eq!(update_resp["notUpdated"], json!(null), "{step}");
let HandlerOutput {
primary: get_resp, ..
} = handle_message_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": [msg_id.as_str()] }),
&[],
)
.await
.expect("get");
assert_eq!(
get_resp["list"][0]["readDisposition"], disposition,
"{step}"
);
}
}
#[tokio::test]
async fn message_set_burn_on_read_fires_on_read_at() {
let backend = common::account_backend();
common::seed_group_chat(&backend, "c1");
let HandlerOutput {
primary: create_resp,
..
} = handle_message_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": {
"m0": {
"chatId": "c1",
"body": "this will burn",
"sentAt": "2024-01-01T00:00:00Z",
"burnOnRead": true
}
}
}),
&[],
)
.await
.expect("create");
let msg_id = create_resp["created"]["m0"]["id"]
.as_str()
.expect("id")
.to_owned();
assert_eq!(
create_resp["created"]["m0"]["burnOnRead"],
json!(true),
"burnOnRead must be stored verbatim on create"
);
common::make_received(&backend, &msg_id).await;
let HandlerOutput {
primary: update_resp,
..
} = handle_message_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": { &msg_id: { "readAt": "2024-01-02T00:00:00Z" } }
}),
&[],
)
.await
.expect("update");
assert_eq!(
update_resp["updated"][&msg_id],
json!(null),
"the readAt patch itself succeeds"
);
assert_eq!(update_resp["notUpdated"], json!(null));
let HandlerOutput {
primary: get_resp, ..
} = handle_message_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": [&msg_id] }),
&[],
)
.await
.expect("get");
assert_eq!(
get_resp["list"].as_array().expect("list").len(),
0,
"the burnt message must not be returned by Message/get"
);
let not_found = get_resp["notFound"].as_array().expect("notFound");
assert_eq!(not_found.len(), 1);
assert_eq!(not_found[0], msg_id);
let HandlerOutput {
primary: changes_resp,
..
} = handle_message_changes(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "sinceState": "0" }),
&[],
)
.await
.expect("changes");
let destroyed = changes_resp["destroyed"]
.as_array()
.expect("destroyed array");
assert!(
destroyed.iter().any(|v| v == &json!(&msg_id)),
"destroyed must contain the burnt message id (got {destroyed:?})"
);
}
#[tokio::test]
async fn message_set_burn_on_read_no_fire_without_read_at() {
let backend = common::account_backend();
common::seed_group_chat(&backend, "c1");
let HandlerOutput {
primary: create_resp,
..
} = handle_message_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": {
"m0": {
"chatId": "c1",
"body": "burnable but unread",
"sentAt": "2024-01-01T00:00:00Z",
"burnOnRead": true
}
}
}),
&[],
)
.await
.expect("create");
let msg_id = create_resp["created"]["m0"]["id"]
.as_str()
.expect("id")
.to_owned();
let HandlerOutput {
primary: update_resp,
..
} = handle_message_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": { &msg_id: { "body": "edited body" } }
}),
&[],
)
.await
.expect("update");
assert_eq!(update_resp["updated"][&msg_id], json!(null));
assert_eq!(update_resp["notUpdated"], json!(null));
let HandlerOutput {
primary: get_resp, ..
} = handle_message_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": [&msg_id] }),
&[],
)
.await
.expect("get");
assert_eq!(get_resp["list"].as_array().expect("list").len(), 1);
assert_eq!(get_resp["list"][0]["body"], "edited body");
assert_eq!(get_resp["list"][0]["burnOnRead"], json!(true));
assert_eq!(get_resp["list"][0]["readAt"], json!(null));
}
#[tokio::test]
async fn message_set_no_burn_when_burn_on_read_absent() {
let backend = common::account_backend();
common::seed_group_chat(&backend, "c1");
let HandlerOutput {
primary: create_resp,
..
} = handle_message_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": {
"m0": {
"chatId": "c1",
"body": "not burnable",
"sentAt": "2024-01-01T00:00:00Z"
}
}
}),
&[],
)
.await
.expect("create");
let msg_id = create_resp["created"]["m0"]["id"]
.as_str()
.expect("id")
.to_owned();
let HandlerOutput {
primary: update_resp,
..
} = handle_message_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": { &msg_id: { "readAt": "2024-01-02T00:00:00Z" } }
}),
&[],
)
.await
.expect("update");
assert_eq!(update_resp["updated"][&msg_id], json!(null));
assert_eq!(update_resp["notUpdated"], json!(null));
let HandlerOutput {
primary: get_resp, ..
} = handle_message_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": [&msg_id] }),
&[],
)
.await
.expect("get");
assert_eq!(get_resp["list"].as_array().expect("list").len(), 1);
assert_eq!(get_resp["list"][0]["readAt"], "2024-01-02T00:00:00Z");
}
#[tokio::test]
async fn message_set_burn_on_read_spares_senders_own_copy() {
let backend = common::account_backend();
common::seed_group_chat(&backend, "c1");
backend.insert_object_for_test(
"Message",
ACCOUNT_ID,
"own",
json!({
"id": "own",
"senderMsgId": "smid-own",
"senderId": ACCOUNT_ID,
"chatId": "c1",
"body": "my own burnable message",
"bodyType": "text/plain",
"attachments": [],
"sentAt": "2024-01-01T00:00:00Z",
"receivedAt": "2024-01-01T00:00:00Z",
"deliveryState": "delivered",
"burnOnRead": true
}),
);
let HandlerOutput {
primary: update_resp,
..
} = handle_message_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": { "own": { "readAt": "2024-01-02T00:00:00Z" } }
}),
&[],
)
.await
.expect("update");
assert_eq!(update_resp["notUpdated"], json!(null), "{update_resp}");
let HandlerOutput {
primary: get_resp, ..
} = handle_message_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": ["own"] }),
&[],
)
.await
.expect("get");
assert_eq!(get_resp["notFound"], json!([]), "{get_resp}");
assert_eq!(get_resp["list"][0]["readAt"], "2024-01-02T00:00:00Z");
assert_eq!(get_resp["list"][0]["burnOnRead"], json!(true));
}
#[tokio::test]
async fn message_set_burn_on_read_no_fire_on_read_at_null() {
let backend = common::account_backend();
common::seed_group_chat(&backend, "c1");
let HandlerOutput {
primary: create_resp,
..
} = handle_message_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": {
"m0": {
"chatId": "c1",
"body": "still here",
"sentAt": "2024-01-01T00:00:00Z",
"burnOnRead": true
}
}
}),
&[],
)
.await
.expect("create");
let msg_id = create_resp["created"]["m0"]["id"]
.as_str()
.expect("id")
.to_owned();
let HandlerOutput {
primary: update_resp,
..
} = handle_message_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": { &msg_id: { "readAt": serde_json::Value::Null } }
}),
&[],
)
.await
.expect("update");
assert_eq!(update_resp["updated"][&msg_id], json!(null));
assert_eq!(update_resp["notUpdated"], json!(null));
let HandlerOutput {
primary: get_resp, ..
} = handle_message_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": [&msg_id] }),
&[],
)
.await
.expect("get");
assert_eq!(get_resp["list"].as_array().expect("list").len(), 1);
assert_eq!(get_resp["list"][0]["burnOnRead"], json!(true));
}
#[tokio::test]
async fn memory_backend_expire_message_direct_call() {
let backend = common::account_backend();
common::seed_group_chat(&backend, "c1");
let HandlerOutput {
primary: create_resp,
..
} = handle_message_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": {
"m0": {
"chatId": "c1",
"body": "scheduled expiry",
"sentAt": "2024-01-01T00:00:00Z"
}
}
}),
&[],
)
.await
.expect("create");
let msg_id_str = create_resp["created"]["m0"]["id"]
.as_str()
.expect("id")
.to_owned();
let account_id = Id::from(ACCOUNT_ID);
let msg_id = Id::from(msg_id_str.as_str());
backend
.expire_message(&(), &account_id, &msg_id)
.await
.expect("expire_message must succeed on the reference backend");
let HandlerOutput {
primary: get_resp, ..
} = handle_message_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": [&msg_id_str] }),
&[],
)
.await
.expect("get");
assert_eq!(get_resp["list"].as_array().expect("list").len(), 0);
let not_found = get_resp["notFound"].as_array().expect("notFound");
assert_eq!(not_found.len(), 1);
assert_eq!(not_found[0], msg_id_str);
let HandlerOutput {
primary: changes_resp,
..
} = handle_message_changes(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "sinceState": "0" }),
&[],
)
.await
.expect("changes");
let destroyed = changes_resp["destroyed"]
.as_array()
.expect("destroyed array");
assert!(
destroyed.iter().any(|v| v == &json!(&msg_id_str)),
"destroyed must contain the expired message id (got {destroyed:?})"
);
}
#[tokio::test]
async fn memory_backend_expire_message_idempotent_on_missing() {
let backend = common::account_backend();
let account_id = Id::from(ACCOUNT_ID);
let missing_id = Id::from("never-existed");
backend
.expire_message(&(), &account_id, &missing_id)
.await
.expect("expire_message on missing id must be Ok(())");
let state_after: jmap_types::State = backend
.get_state::<jmap_chat_types::Message>(&(), &account_id)
.await
.expect("get_state");
assert_eq!(
state_after.as_ref(),
"0",
"expire_message on missing id must not bump the state counter"
);
}
#[tokio::test]
async fn message_set_burn_on_read_expire_failure_redacts_backend_display() {
use common::{INJECTABLE_BACKEND_CANARY, InjectableBackend};
let backend = InjectableBackend::new();
common::seed_group_chat(&backend.inner, "c1");
backend.inner.register_account(&Id::from(ACCOUNT_ID));
let HandlerOutput {
primary: create_resp,
..
} = handle_message_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": {
"m0": {
"chatId": "c1",
"body": "will fail to burn",
"sentAt": "2024-01-01T00:00:00Z",
"burnOnRead": true
}
}
}),
&[],
)
.await
.expect("create");
let msg_id = create_resp["created"]["m0"]["id"]
.as_str()
.expect("id in created response")
.to_owned();
common::make_received(&backend.inner, &msg_id).await;
backend.inject("Message", "read_and_burn");
let HandlerOutput { primary: resp, .. } = handle_message_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": { &msg_id: { "readAt": "2024-01-02T00:00:00Z" } }
}),
&[],
)
.await
.expect("update");
let wire = resp.to_string();
assert!(
!wire.contains(INJECTABLE_BACKEND_CANARY),
"backend-error Display canary must not appear in /set response \
(burn-on-read failure Value path must redact); wire: {wire}"
);
assert_eq!(
resp["notUpdated"][&msg_id]["type"].as_str(),
Some("serverFail"),
"notUpdated[{msg_id}] must have type serverFail; resp: {resp}"
);
assert_eq!(
resp["notUpdated"][&msg_id]["description"].as_str(),
Some(jmap_server::SERVER_FAIL_INTERNAL_DESC),
"description must be the static SERVER_FAIL_INTERNAL_DESC; resp: {resp}"
);
}
#[tokio::test]
async fn chat_set_duplicate_direct_cleanup_destroy_failure_redacts_backend_display() {
use common::{INJECTABLE_BACKEND_CANARY, InjectableBackend};
let backend = InjectableBackend::new();
backend.inner.register_account(&Id::from(ACCOUNT_ID));
backend.queue_chat_race_phantom(ACCOUNT_ID, "0", "contact-1");
backend.inject("Chat", "destroy");
let HandlerOutput { primary: resp, .. } = handle_chat_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": {
"c0": {
"kind": "direct",
"contactId": "contact-1"
}
}
}),
&[],
)
.await
.expect("chat_set");
let wire = resp.to_string();
assert!(
!wire.contains(INJECTABLE_BACKEND_CANARY),
"backend-error Display canary must not appear in /set response \
(duplicate-Direct cleanup destroy failure Value path must redact); wire: {wire}"
);
assert_eq!(
resp["notCreated"]["c0"]["type"].as_str(),
Some("serverFail"),
"notCreated[c0] must have type serverFail; resp: {resp}"
);
assert_eq!(
resp["notCreated"]["c0"]["description"].as_str(),
Some(jmap_server::SERVER_FAIL_INTERNAL_DESC),
"description must be the static SERVER_FAIL_INTERNAL_DESC; resp: {resp}"
);
}
#[tokio::test]
async fn chat_set_direct_recheck_read_failure_rolls_back_create() {
use common::{INJECTABLE_BACKEND_CANARY, InjectableBackend};
let backend = InjectableBackend::new();
let account_id = Id::from(ACCOUNT_ID);
backend.inner.register_account(&account_id);
backend.queue_chat_get_fault_after_create();
let HandlerOutput { primary: resp, .. } = handle_chat_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": {
"c0": { "kind": "direct", "contactId": "contact-1" },
"c1": { "kind": "direct", "contactId": "contact-2" }
}
}),
&[],
)
.await
.expect("re-check read failure must not be a method-level error");
let wire = resp.to_string();
assert!(
!wire.contains(INJECTABLE_BACKEND_CANARY),
"backend error text must not reach the wire: {wire}"
);
assert_eq!(
resp["notCreated"]["c0"]["type"].as_str(),
Some("serverFail"),
"resp: {resp}"
);
assert_eq!(
resp["notCreated"]["c0"]["description"].as_str(),
Some(jmap_server::SERVER_FAIL_INTERNAL_DESC),
"resp: {resp}"
);
assert!(resp["created"].get("c0").is_none(), "resp: {resp}");
assert!(resp["created"]["c1"]["id"].is_string(), "resp: {resp}");
let (chats, _) = backend
.inner
.get_objects::<Chat>(&(), &account_id, None, None)
.await
.expect("get_objects");
let contacts: Vec<Option<&str>> = chats
.iter()
.map(|c| c.contact_id.as_ref().map(|id| id.as_ref()))
.collect();
assert_eq!(
contacts,
vec![Some("contact-2")],
"the c0 Chat must be rolled back; only c1 may remain"
);
}
#[tokio::test]
async fn chat_set_direct_recheck_and_rollback_failure_advances_state() {
use common::{INJECTABLE_BACKEND_CANARY, InjectableBackend};
let backend = InjectableBackend::new();
let account_id = Id::from(ACCOUNT_ID);
backend.inner.register_account(&account_id);
backend.queue_chat_get_fault_after_create();
backend.inject("Chat", "destroy");
let HandlerOutput { primary: resp, .. } = handle_chat_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": { "c0": { "kind": "direct", "contactId": "contact-1" } }
}),
&[],
)
.await
.expect("re-check read failure must not be a method-level error");
let wire = resp.to_string();
assert!(
!wire.contains(INJECTABLE_BACKEND_CANARY),
"backend error text must not reach the wire: {wire}"
);
assert_eq!(
resp["notCreated"]["c0"]["type"].as_str(),
Some("serverFail"),
"resp: {resp}"
);
assert_eq!(
resp["notCreated"]["c0"]["description"].as_str(),
Some(jmap_server::SERVER_FAIL_INTERNAL_DESC),
"resp: {resp}"
);
let (chats, _) = backend
.inner
.get_objects::<Chat>(&(), &account_id, None, None)
.await
.expect("get_objects");
assert_eq!(chats.len(), 1, "the failed rollback leaves the Chat live");
assert_ne!(
resp["newState"], resp["oldState"],
"the live Chat must be visible from newState; resp: {resp}"
);
}
#[tokio::test]
async fn chat_set_direct_lost_race_new_state_matches_get() {
use common::InjectableBackend;
let backend = InjectableBackend::new();
let account_id = Id::from(ACCOUNT_ID);
backend.inner.register_account(&account_id);
backend.queue_chat_race_phantom(ACCOUNT_ID, "0", "contact-1");
let HandlerOutput { primary: resp, .. } = handle_chat_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": { "c0": { "kind": "direct", "contactId": "contact-1" } }
}),
&[],
)
.await
.expect("chat_set");
assert_eq!(
resp["notCreated"]["c0"]["type"].as_str(),
Some("alreadyExists"),
"resp: {resp}"
);
assert_eq!(
resp["notCreated"]["c0"]["existingId"].as_str(),
Some("0"),
"resp: {resp}"
);
let (chats, _) = backend
.inner
.get_objects::<Chat>(&(), &account_id, None, None)
.await
.expect("get_objects");
let state = backend
.inner
.get_state::<Chat>(&(), &account_id)
.await
.expect("get_state");
assert_eq!(chats.len(), 1, "only the canonical Chat remains");
assert_eq!(
resp["newState"],
json!(state),
"newState must be what Chat/get now returns; resp: {resp}"
);
}
#[tokio::test]
async fn chat_set_direct_lost_race_cleanup_failure_new_state_matches_get() {
use common::InjectableBackend;
let backend = InjectableBackend::new();
let account_id = Id::from(ACCOUNT_ID);
backend.inner.register_account(&account_id);
backend.queue_chat_race_phantom(ACCOUNT_ID, "0", "contact-1");
backend.inject("Chat", "destroy");
let HandlerOutput { primary: resp, .. } = handle_chat_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": { "c0": { "kind": "direct", "contactId": "contact-1" } }
}),
&[],
)
.await
.expect("chat_set");
assert_eq!(
resp["notCreated"]["c0"]["type"].as_str(),
Some("serverFail"),
"resp: {resp}"
);
let (chats, _) = backend
.inner
.get_objects::<Chat>(&(), &account_id, None, None)
.await
.expect("get_objects");
let state = backend
.inner
.get_state::<Chat>(&(), &account_id)
.await
.expect("get_state");
assert_eq!(chats.len(), 2, "the failed cleanup leaves both Chats live");
assert_eq!(
resp["newState"],
json!(state),
"newState must be what Chat/get now returns; resp: {resp}"
);
}
#[tokio::test]
async fn message_get_default_omits_edit_history() {
let backend = common::account_backend();
backend.insert_object_for_test(
"Message",
ACCOUNT_ID,
"m1",
json!({
"id": "m1",
"senderMsgId": "smsg1",
"senderId": "self",
"chatId": "c1",
"body": "edited",
"bodyType": "text/plain",
"attachments": [],
"mentions": [],
"broadcastMentions": [],
"actions": [],
"reactions": {},
"sentAt": "2024-01-01T00:00:00Z",
"receivedAt": "2024-01-01T00:00:01Z",
"deliveryState": "delivered",
"editedAt": "2024-01-02T00:00:00Z",
"editHistory": [
{
"body": "original",
"bodyType": "text/plain",
"editedAt": "2024-01-02T00:00:00Z"
}
]
}),
);
let HandlerOutput { primary: resp, .. } = handle_message_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": ["m1"] }),
&[],
)
.await
.expect("handle_message_get");
let msg = &resp["list"][0];
assert_eq!(msg["body"], "edited", "the message itself round-trips");
assert_eq!(
msg["editHistory"],
json!(null),
"editHistory MUST be omitted (default retains_edit_history == false)"
);
}
#[tokio::test]
async fn message_get_with_retention_returns_edit_history() {
let backend = common::account_backend();
backend.set_retains_edit_history_for_test(true);
backend.insert_object_for_test(
"Message",
ACCOUNT_ID,
"m1",
json!({
"id": "m1",
"senderMsgId": "smsg1",
"senderId": "self",
"chatId": "c1",
"body": "edited",
"bodyType": "text/plain",
"attachments": [],
"mentions": [],
"broadcastMentions": [],
"actions": [],
"reactions": {},
"sentAt": "2024-01-01T00:00:00Z",
"receivedAt": "2024-01-01T00:00:01Z",
"deliveryState": "delivered",
"editedAt": "2024-01-02T00:00:00Z",
"editHistory": [
{
"body": "original",
"bodyType": "text/plain",
"editedAt": "2024-01-02T00:00:00Z"
}
]
}),
);
let HandlerOutput { primary: resp, .. } = handle_message_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": ["m1"] }),
&[],
)
.await
.expect("handle_message_get");
let history = resp["list"][0]["editHistory"]
.as_array()
.expect("editHistory must be an array when retention is on");
assert_eq!(history.len(), 1);
assert_eq!(history[0]["body"], "original");
assert_eq!(history[0]["editedAt"], "2024-01-02T00:00:00Z");
}
#[tokio::test]
async fn message_get_properties_does_not_force_edit_history_when_retention_off() {
let backend = common::account_backend();
backend.insert_object_for_test(
"Message",
ACCOUNT_ID,
"m1",
json!({
"id": "m1",
"senderMsgId": "smsg1",
"senderId": "self",
"chatId": "c1",
"body": "edited",
"bodyType": "text/plain",
"attachments": [],
"mentions": [],
"broadcastMentions": [],
"actions": [],
"reactions": {},
"sentAt": "2024-01-01T00:00:00Z",
"receivedAt": "2024-01-01T00:00:01Z",
"deliveryState": "delivered",
"editedAt": "2024-01-02T00:00:00Z",
"editHistory": [
{
"body": "original",
"bodyType": "text/plain",
"editedAt": "2024-01-02T00:00:00Z"
}
]
}),
);
let HandlerOutput { primary: resp, .. } = handle_message_get(
&backend,
&(),
json!({
"accountId": ACCOUNT_ID,
"ids": ["m1"],
"properties": ["editHistory"]
}),
&[],
)
.await
.expect("handle_message_get");
let msg = &resp["list"][0];
assert_eq!(
msg["editHistory"],
json!(null),
"editHistory MUST be omitted even when the client explicitly asks for it"
);
}
#[tokio::test]
async fn memory_backend_retains_edit_history_default_is_false() {
let backend = common::account_backend();
assert!(
!backend.retains_edit_history(),
"default MemoryBackend must report retains_edit_history() == false"
);
}
#[tokio::test]
async fn message_set_create_no_slow_mode_on_memory_backend() {
let backend = common::account_backend();
common::seed_group_chat(&backend, "c1");
let HandlerOutput { primary: resp, .. } = handle_message_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": {
"m0": {
"chatId": "c1",
"body": "send fast, send often",
"sentAt": "2024-01-01T00:00:00Z"
}
}
}),
&[],
)
.await
.expect("handle_message_set");
assert!(
resp["created"]["m0"].is_object(),
"MemoryBackend's default slow_mode_check is Ok(()); create must succeed"
);
assert_eq!(resp["notCreated"], json!(null));
}
#[tokio::test]
async fn message_set_create_slow_mode_rejects_with_retry_after() {
let retry_after = jmap_types::UTCDate::from("2099-12-31T00:00:00Z");
let backend = TrackingBackend::with_slow_mode_blocking(retry_after.clone());
common::seed_group_chat(backend.inner(), "c1");
let HandlerOutput { primary: resp, .. } = handle_message_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": {
"m0": {
"chatId": "c1",
"body": "throttled",
"sentAt": "2024-01-01T00:00:00Z"
}
}
}),
&[],
)
.await
.expect("handle_message_set");
assert_eq!(
resp["created"],
json!(null),
"create map must be absent (or null) when no entry succeeded"
);
let not_created_m0 = &resp["notCreated"]["m0"];
assert!(
not_created_m0.is_object(),
"m0 must appear in notCreated (got {resp})"
);
assert_eq!(
not_created_m0["type"], "rateLimit",
"SetError.type must be the RFC 8620 \"rateLimit\", not the method-level \"rateLimited\""
);
assert_eq!(
not_created_m0["serverRetryAfter"],
retry_after.as_ref(),
"serverRetryAfter must equal the UTCDate returned by slow_mode_check"
);
}
#[tokio::test]
async fn message_set_create_tracking_backend_default_allows() {
let backend = TrackingBackend::new();
common::seed_group_chat(backend.inner(), "c1");
let HandlerOutput { primary: resp, .. } = handle_message_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": {
"m0": {
"chatId": "c1",
"body": "no throttle configured",
"sentAt": "2024-01-01T00:00:00Z"
}
}
}),
&[],
)
.await
.expect("handle_message_set");
assert!(
resp["created"]["m0"].is_object(),
"TrackingBackend without slow_mode_block must forward to MemoryBackend (Ok(()))"
);
assert_eq!(resp["notCreated"], json!(null));
}
#[tokio::test]
async fn message_set_create_slow_mode_skipped_when_validation_fails() {
let retry_after = jmap_types::UTCDate::from("2099-12-31T00:00:00Z");
let backend = TrackingBackend::with_slow_mode_blocking(retry_after);
let HandlerOutput { primary: resp, .. } = handle_message_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": {
"m0": {
"body": "throttled but also malformed",
"sentAt": "2024-01-01T00:00:00Z"
}
}
}),
&[],
)
.await
.expect("handle_message_set");
let not_created_m0 = &resp["notCreated"]["m0"];
assert_eq!(
not_created_m0["type"], "invalidProperties",
"validation must short-circuit before slow_mode_check is consulted"
);
assert_eq!(
not_created_m0["serverRetryAfter"],
json!(null),
"serverRetryAfter must be absent on a validation failure"
);
}
#[tokio::test]
async fn message_set_create_with_reply_to() {
let backend = common::account_backend();
common::seed_group_chat(&backend, "c1");
let HandlerOutput { primary: first_resp, .. } = handle_message_set(&backend, &(), &std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": { "m0": { "chatId": "c1", "body": "original", "sentAt": "2024-01-01T00:00:00Z" } }
}),
&[],
)
.await
.expect("create first message");
let first_id = first_resp["created"]["m0"]["id"]
.as_str()
.expect("first message id")
.to_owned();
let HandlerOutput { primary: resp, .. } = handle_message_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": {
"m1": {
"chatId": "c1",
"body": "reply",
"replyTo": first_id,
"sentAt": "2024-01-01T00:00:00Z"
}
}
}),
&[],
)
.await
.expect("create reply");
assert!(resp["created"]["m1"].is_object(), "m1 must be in created");
assert_eq!(resp["notCreated"], json!(null));
assert_eq!(
resp["created"]["m1"]["replyTo"], first_id,
"replyTo must equal the first message id"
);
}
#[tokio::test]
async fn message_set_create_with_malformed_expiry_rejected() {
let backend = common::account_backend();
common::seed_group_chat(&backend, "c1");
let HandlerOutput { primary: resp, .. } = handle_message_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": {
"m0": {
"chatId": "c1",
"body": "expires sometime",
"sentAt": "2024-01-01T00:00:00Z",
"senderExpiresAt": "tomorrow"
}
}
}),
&[],
)
.await
.expect("handle_message_set");
assert_eq!(resp["created"], json!(null));
assert!(resp["notCreated"]["m0"].is_object());
assert_eq!(resp["notCreated"]["m0"]["type"], "invalidProperties");
let props = resp["notCreated"]["m0"]["properties"]
.as_array()
.expect("properties array");
assert!(
props.iter().any(|p| p == "senderExpiresAt"),
"senderExpiresAt must be listed in rejected properties"
);
}
#[tokio::test]
async fn message_set_create_with_past_expiry_rejected() {
let backend = common::account_backend();
common::seed_group_chat(&backend, "c1");
let HandlerOutput { primary: resp, .. } = handle_message_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": {
"m0": {
"chatId": "c1",
"body": "expires in the past",
"sentAt": "2024-01-01T00:00:00Z",
"senderExpiresAt": "2020-01-01T00:00:00Z"
}
}
}),
&[],
)
.await
.expect("handle_message_set");
assert_eq!(resp["created"], json!(null));
assert!(resp["notCreated"]["m0"].is_object());
assert_eq!(resp["notCreated"]["m0"]["type"], "invalidProperties");
let props = resp["notCreated"]["m0"]["properties"]
.as_array()
.expect("properties array");
assert!(
props.iter().any(|p| p == "senderExpiresAt"),
"senderExpiresAt must be listed in rejected properties"
);
}
#[tokio::test]
async fn message_set_past_expiry_set_error_matches_draft() {
let backend = common::account_backend();
common::seed_group_chat(&backend, "c1");
let HandlerOutput { primary: resp, .. } = handle_message_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": {
"m0": {
"chatId": "c1",
"body": "already expired",
"sentAt": "2024-01-01T00:00:00Z",
"senderExpiresAt": "2000-01-01T00:00:00Z"
}
}
}),
&[],
)
.await
.expect("handle_message_set");
assert_eq!(resp["notCreated"]["m0"]["type"], "invalidProperties");
assert_eq!(
resp["notCreated"]["m0"]["properties"],
json!(["senderExpiresAt"])
);
}
#[tokio::test]
async fn message_set_create_with_malformed_sent_at_rejected() {
let backend = common::account_backend();
let HandlerOutput { primary: resp, .. } = handle_message_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": {
"m0": {
"chatId": "c1",
"body": "ok",
"sentAt": "yesterday"
}
}
}),
&[],
)
.await
.expect("handle_message_set");
assert_eq!(resp["created"], json!(null));
assert!(resp["notCreated"]["m0"].is_object());
assert_eq!(resp["notCreated"]["m0"]["type"], "invalidProperties");
let props = resp["notCreated"]["m0"]["properties"]
.as_array()
.expect("properties array");
assert!(
props.iter().any(|p| p == "sentAt"),
"sentAt must be listed in rejected properties: {props:?}"
);
}
#[tokio::test]
async fn position_set_create_with_malformed_last_read_at_rejected() {
let backend = common::account_backend();
let HandlerOutput { primary: resp, .. } = handle_position_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": {
"rp0": {
"chatId": "c1",
"lastReadAt": "not-a-date"
}
}
}),
)
.await
.expect("handle_position_set");
assert!(resp["created"].is_null());
assert!(resp["notCreated"]["rp0"].is_object());
assert_eq!(resp["notCreated"]["rp0"]["type"], "forbidden");
}
#[tokio::test]
async fn message_set_update_reaction_add_overrides_sender_id_to_account_id() {
let backend = common::account_backend();
common::seed_group_chat(&backend, "c1");
let HandlerOutput { primary: create_resp, .. } = handle_message_set(&backend, &(), &std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": { "m0": { "chatId": "c1", "body": "react to me", "sentAt": "2024-01-01T00:00:00Z" } }
}),
&[],
)
.await
.expect("create");
let msg_id = create_resp["created"]["m0"]["id"]
.as_str()
.expect("id")
.to_owned();
let HandlerOutput {
primary: update_resp,
..
} = handle_message_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": {
&msg_id: { "reactions/abc": { "emoji": "👍" } }
}
}),
&[],
)
.await
.expect("update");
assert_eq!(update_resp["updated"][&msg_id], json!(null));
assert_eq!(update_resp["notUpdated"], json!(null));
let HandlerOutput {
primary: get_resp, ..
} = handle_message_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": [&msg_id] }),
&[],
)
.await
.expect("get");
let stored = &get_resp["list"][0]["reactions"]["abc"];
assert!(
stored.is_object(),
"reactions.abc must be stored as an object"
);
assert_eq!(stored["emoji"], "👍");
assert_eq!(
stored["senderId"], ACCOUNT_ID,
"server MUST set senderId to the accountId on owner-authored reactions"
);
assert!(
stored["sentAt"].is_string(),
"server MUST inject sentAt when client omits it"
);
}
#[tokio::test]
async fn message_set_update_reaction_add_overrides_client_supplied_sender_id() {
let backend = common::account_backend();
common::seed_group_chat(&backend, "c1");
let HandlerOutput {
primary: create_resp,
..
} = handle_message_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": { "m0": { "chatId": "c1", "body": "test", "sentAt": "2024-01-01T00:00:00Z" } }
}),
&[],
)
.await
.expect("create");
let msg_id = create_resp["created"]["m0"]["id"]
.as_str()
.expect("id")
.to_owned();
let HandlerOutput {
primary: update_resp,
..
} = handle_message_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": {
&msg_id: { "reactions/bar": { "emoji": "❤️", "senderId": "someone-else" } }
}
}),
&[],
)
.await
.expect("update");
assert_eq!(update_resp["notUpdated"], json!(null));
let HandlerOutput {
primary: get_resp, ..
} = handle_message_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": [&msg_id] }),
&[],
)
.await
.expect("get");
assert_eq!(
get_resp["list"][0]["reactions"]["bar"]["senderId"], ACCOUNT_ID,
"client-supplied senderId MUST be overridden to the accountId"
);
}
#[tokio::test]
async fn message_set_update_reaction_remove_others_rejected_forbidden() {
let backend = common::account_backend();
backend.insert_object_for_test(
"Message",
ACCOUNT_ID,
"m1",
json!({
"id": "m1",
"senderMsgId": "smsg1",
"senderId": "self",
"chatId": "c1",
"body": "Hello",
"bodyType": "text/plain",
"attachments": [],
"mentions": [],
"broadcastMentions": [],
"actions": [],
"reactions": {
"foo": {
"emoji": "👎",
"senderId": "someone-else",
"sentAt": "2024-01-01T00:00:00Z"
}
},
"sentAt": "2024-01-01T00:00:00Z",
"receivedAt": "2024-01-01T00:00:01Z",
"deliveryState": "delivered"
}),
);
let HandlerOutput { primary: resp, .. } = handle_message_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": {
"m1": { "reactions/foo": serde_json::Value::Null }
}
}),
&[],
)
.await
.expect("handle_message_set");
assert_eq!(resp["updated"], json!(null));
let nu = &resp["notUpdated"]["m1"];
assert!(nu.is_object());
assert_eq!(nu["type"], "forbidden");
assert!(
nu["description"]
.as_str()
.is_some_and(|s| s.contains("foo")),
"description must name the rejected reaction key"
);
let HandlerOutput {
primary: get_resp, ..
} = handle_message_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": ["m1"] }),
&[],
)
.await
.expect("get");
assert_eq!(
get_resp["list"][0]["reactions"]["foo"]["emoji"], "👎",
"the foreign reaction must survive the forbidden rejection unchanged"
);
}
#[tokio::test]
async fn message_set_update_reaction_modify_others_rejected_forbidden() {
let backend = common::account_backend();
backend.insert_object_for_test(
"Message",
ACCOUNT_ID,
"m1",
json!({
"id": "m1",
"senderMsgId": "smsg1",
"senderId": "self",
"chatId": "c1",
"body": "Hello",
"bodyType": "text/plain",
"attachments": [],
"mentions": [],
"broadcastMentions": [],
"actions": [],
"reactions": {
"foo": {
"emoji": "👎",
"senderId": "someone-else",
"sentAt": "2024-01-01T00:00:00Z"
}
},
"sentAt": "2024-01-01T00:00:00Z",
"receivedAt": "2024-01-01T00:00:01Z",
"deliveryState": "delivered"
}),
);
let HandlerOutput { primary: resp, .. } = handle_message_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": {
"m1": { "reactions/foo": { "emoji": "🎉" } }
}
}),
&[],
)
.await
.expect("handle_message_set");
assert_eq!(resp["notUpdated"]["m1"]["type"], "forbidden");
}
#[tokio::test]
async fn message_set_update_reaction_pointer_with_slash_rejected() {
let backend = common::account_backend();
common::seed_group_chat(&backend, "c1");
let HandlerOutput {
primary: create_resp,
..
} = handle_message_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": { "m0": { "chatId": "c1", "body": "test", "sentAt": "2024-01-01T00:00:00Z" } }
}),
&[],
)
.await
.expect("create");
let msg_id = create_resp["created"]["m0"]["id"]
.as_str()
.expect("id")
.to_owned();
let HandlerOutput {
primary: update_resp,
..
} = handle_message_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": {
&msg_id: { "reactions/a/b": { "emoji": "👍" } }
}
}),
&[],
)
.await
.expect("update");
assert_eq!(update_resp["notUpdated"][&msg_id]["type"], "invalidPatch");
}
#[tokio::test]
async fn message_set_update_reaction_non_object_value_rejected() {
let backend = common::account_backend();
common::seed_group_chat(&backend, "c1");
let HandlerOutput {
primary: create_resp,
..
} = handle_message_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": { "m0": { "chatId": "c1", "body": "test", "sentAt": "2024-01-01T00:00:00Z" } }
}),
&[],
)
.await
.expect("create");
let msg_id = create_resp["created"]["m0"]["id"]
.as_str()
.expect("id")
.to_owned();
let HandlerOutput {
primary: update_resp,
..
} = handle_message_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": {
&msg_id: { "reactions/abc": "👍" }
}
}),
&[],
)
.await
.expect("update");
assert_eq!(update_resp["notUpdated"][&msg_id]["type"], "invalidPatch");
}
#[tokio::test]
async fn message_set_update_reaction_remove_self_succeeds() {
let backend = common::account_backend();
common::seed_group_chat(&backend, "c1");
let HandlerOutput {
primary: create_resp,
..
} = handle_message_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": { "m0": { "chatId": "c1", "body": "test", "sentAt": "2024-01-01T00:00:00Z" } }
}),
&[],
)
.await
.expect("create");
let msg_id = create_resp["created"]["m0"]["id"]
.as_str()
.expect("id")
.to_owned();
let HandlerOutput {
primary: add_resp, ..
} = handle_message_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": {
&msg_id: { "reactions/r1": { "emoji": "👍" } }
}
}),
&[],
)
.await
.expect("add");
assert_eq!(add_resp["notUpdated"], json!(null));
let HandlerOutput {
primary: remove_resp,
..
} = handle_message_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": {
&msg_id: { "reactions/r1": serde_json::Value::Null }
}
}),
&[],
)
.await
.expect("remove");
assert_eq!(remove_resp["notUpdated"], json!(null));
let HandlerOutput {
primary: get_resp, ..
} = handle_message_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": [&msg_id] }),
&[],
)
.await
.expect("get");
assert!(
get_resp["list"][0]["reactions"].get("r1").is_none()
|| get_resp["list"][0]["reactions"]["r1"].is_null(),
"removed reaction must not appear in stored reactions"
);
}
#[tokio::test]
async fn message_set_update_reaction_mixed_top_level_and_pointer_rejected() {
let backend = common::account_backend();
common::seed_group_chat(&backend, "c1");
let HandlerOutput {
primary: create_resp,
..
} = handle_message_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": { "m0": { "chatId": "c1", "body": "test", "sentAt": "2024-01-01T00:00:00Z" } }
}),
&[],
)
.await
.expect("create");
let msg_id = create_resp["created"]["m0"]["id"]
.as_str()
.expect("id")
.to_owned();
let HandlerOutput {
primary: update_resp,
..
} = handle_message_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": {
&msg_id: {
"reactions": {},
"reactions/abc": { "emoji": "👍" }
}
}
}),
&[],
)
.await
.expect("update");
assert_eq!(update_resp["notUpdated"][&msg_id]["type"], "invalidPatch");
}
#[tokio::test]
async fn space_set_create_missing_name() {
let backend = common::account_backend();
let HandlerOutput { primary: resp, .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": { "s0": { "isPublic": false } }
}),
&[],
)
.await
.expect("handle_space_set");
assert!(resp["notCreated"]["s0"].is_object());
let props = resp["notCreated"]["s0"]["properties"]
.as_array()
.expect("props");
assert!(props.iter().any(|p| p == "name"));
}
#[tokio::test]
async fn space_set_create_success() {
let backend = common::account_backend();
let HandlerOutput { primary: resp, .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": { "s0": { "name": "My Server", "isPublic": true } }
}),
&[],
)
.await
.expect("handle_space_set");
assert!(resp["created"]["s0"].is_object());
assert_eq!(resp["created"]["s0"]["name"], "My Server");
}
#[tokio::test]
async fn space_get_returns_created() {
let backend = common::account_backend();
let space_id = make_space(&backend, "The Space").await;
let HandlerOutput {
primary: get_resp, ..
} = handle_space_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": [space_id] }),
&[],
)
.await
.expect("get");
assert_eq!(get_resp["list"][0]["name"], "The Space");
}
#[tokio::test]
async fn space_set_update_readonly_fields_rejected() {
let backend = common::account_backend();
let space_id = make_space(&backend, "Readonly Test").await;
for (field, value) in [
("roles", json!([])),
("members", json!([])),
(
"categories",
json!([{ "id": "cat9", "name": "Ops", "position": 0, "channelIds": [] }]),
),
("uncategorizedChannelIds", json!(["chan9"])),
] {
let HandlerOutput { primary: resp, .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": { &space_id: { field: value } }
}),
&[],
)
.await
.expect("handle_space_set");
assert!(
resp["notUpdated"][&space_id].is_object(),
"field {field} should be rejected"
);
assert_eq!(
resp["notUpdated"][&space_id]["type"], "invalidProperties",
"field {field} should yield invalidProperties"
);
}
}
#[tokio::test]
async fn space_set_update_role_member_variants_dispatch_to_backend() {
let backend = common::account_backend();
let space_id = make_space(&backend, "Mutation Test").await;
let HandlerOutput {
primary: add_role_resp,
..
} = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": { &space_id: { "addRoles": [
{ "id": "placeholder", "name": "Mod", "permissions": ["chat:read"], "position": 1 }
]}}
}),
&[],
)
.await
.expect("handle_space_set (addRoles)");
assert!(
add_role_resp["updated"][&space_id].is_object()
|| add_role_resp["updated"][&space_id].is_null(),
"addRoles should land in `updated`, got {add_role_resp:?}"
);
assert!(
add_role_resp["notUpdated"][&space_id].is_null(),
"addRoles should NOT produce notUpdated for the owner-admin: {add_role_resp:?}"
);
let HandlerOutput {
primary: get_resp, ..
} = handle_space_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": [&space_id] }),
&[],
)
.await
.expect("Space/get");
let role_id = get_resp["list"][0]["roles"]
.as_array()
.and_then(|roles| roles.iter().find(|r| r["name"] == "Mod"))
.and_then(|r| r["id"].as_str())
.expect("server-assigned role id")
.to_owned();
let HandlerOutput { primary: resp, .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": { &space_id: { "updateRoles": [
{ "id": role_id, "name": "Renamed" }
]}}
}),
&[],
)
.await
.expect("handle_space_set (updateRoles)");
assert!(
resp["notUpdated"][&space_id].is_null(),
"updateRoles on existing id should succeed: {resp:?}"
);
let HandlerOutput { primary: resp, .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": { &space_id: { "addMembers": [
{ "id": "u1", "roleIds": [role_id] }
]}}
}),
&[],
)
.await
.expect("handle_space_set (addMembers)");
assert!(
resp["notUpdated"][&space_id].is_null(),
"addMembers should succeed for the owner-admin: {resp:?}"
);
let HandlerOutput { primary: resp, .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": { &space_id: { "updateMembers": [
{ "id": "u1", "nick": "Mark" }
]}}
}),
&[],
)
.await
.expect("handle_space_set (updateMembers)");
assert!(
resp["notUpdated"][&space_id].is_null(),
"updateMembers should succeed: {resp:?}"
);
let HandlerOutput { primary: resp, .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": { &space_id: { "removeMembers": ["u1"] }}
}),
&[],
)
.await
.expect("handle_space_set (removeMembers)");
assert!(
resp["notUpdated"][&space_id].is_null(),
"removeMembers on existing member should succeed: {resp:?}"
);
let HandlerOutput { primary: resp, .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": { &space_id: { "removeRoles": [role_id] }}
}),
&[],
)
.await
.expect("handle_space_set (removeRoles)");
assert!(
resp["notUpdated"][&space_id].is_null(),
"removeRoles on existing id should succeed: {resp:?}"
);
let HandlerOutput { primary: resp, .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": { &space_id: { "removeRoles": ["nonexistent"] }}
}),
&[],
)
.await
.expect("handle_space_set (removeRoles nonexistent)");
assert_eq!(
resp["notUpdated"][&space_id]["type"], "notFound",
"removeRoles on missing id should be NotFound: {resp:?}"
);
}
#[tokio::test]
async fn space_set_update_structural_empty_array_is_empty_patch() {
let backend = common::account_backend();
let space_id = make_space(&backend, "Empty Test").await;
let HandlerOutput { primary: resp, .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": { &space_id: { "addRoles": [] } }
}),
&[],
)
.await
.expect("handle_space_set");
assert_eq!(
resp["notUpdated"][&space_id]["type"], "invalidPatch",
"empty structural array with no other fields is an empty patch"
);
}
#[tokio::test]
async fn space_set_update_malformed_structural_rejected() {
let backend = common::account_backend();
let space_id = make_space(&backend, "Malformed Test").await;
let HandlerOutput { primary: resp, .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": { &space_id: { "addRoles": ["not-an-object"] } }
}),
&[],
)
.await
.expect("handle_space_set");
assert_eq!(
resp["notUpdated"][&space_id]["type"], "invalidProperties",
"malformed entry must produce invalidProperties, not forbidden: {:?}",
resp["notUpdated"][&space_id]
);
assert_eq!(resp["notUpdated"][&space_id]["properties"][0], "addRoles");
let HandlerOutput { primary: resp, .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": { &space_id: { "removeMembers": "not-an-array" } }
}),
&[],
)
.await
.expect("handle_space_set");
assert_eq!(
resp["notUpdated"][&space_id]["type"], "invalidProperties",
"non-array structural payload must be invalidProperties: {:?}",
resp["notUpdated"][&space_id]
);
assert_eq!(
resp["notUpdated"][&space_id]["properties"][0],
"removeMembers"
);
}
#[tokio::test]
async fn space_set_add_roles_position_zero_rejected() {
let backend = common::account_backend();
let space_id = make_space(&backend, "Test").await;
let HandlerOutput { primary: resp, .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": {
&space_id: {
"addRoles": [{
"id": "placeholder",
"name": "BadRole",
"permissions": [],
"position": 0
}]
}
}
}),
&[],
)
.await
.expect("handle_space_set");
let nu = &resp["notUpdated"][&space_id];
assert!(nu.is_object(), "{} must appear in notUpdated", space_id);
assert_eq!(
nu["type"], "invalidProperties",
"wire type must be invalidProperties (the only SetError that carries a `properties` array)"
);
let props = nu["properties"].as_array().expect("properties array");
assert!(
props.iter().any(|p| p == "position"),
"properties must include `position`, got {props:?}"
);
assert!(
nu["description"]
.as_str()
.is_some_and(|s| s.contains("@everyone")),
"description must mention the @everyone reservation, got {nu:?}"
);
}
#[tokio::test]
async fn space_set_add_roles_position_one_passes_handler_check() {
let backend = common::account_backend();
let space_id = make_space(&backend, "Test").await;
let HandlerOutput { primary: resp, .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": {
&space_id: {
"addRoles": [{
"id": "placeholder",
"name": "Mod",
"permissions": [],
"position": 1
}]
}
}
}),
&[],
)
.await
.expect("handle_space_set");
let nu = &resp["notUpdated"][&space_id];
assert_ne!(
nu["type"], "invalidProperties",
"position=1 must NOT be rejected by the handler-level position check"
);
let props = nu["properties"].as_array();
assert!(
!props.is_some_and(|arr| arr.iter().any(|p| p == "position")),
"the rejection must not list `position` as the offending field"
);
}
#[tokio::test]
async fn space_set_update_roles_position_zero_rejected() {
let backend = common::account_backend();
let space_id = make_space(&backend, "Test").await;
let HandlerOutput { primary: resp, .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": {
&space_id: {
"updateRoles": [{
"id": "some-role-id",
"position": 0
}]
}
}
}),
&[],
)
.await
.expect("handle_space_set");
let nu = &resp["notUpdated"][&space_id];
assert!(nu.is_object());
assert_eq!(nu["type"], "invalidProperties");
assert_eq!(nu["properties"][0], "position");
}
#[tokio::test]
async fn space_set_add_roles_position_zero_rejects_whole_target_atomically() {
let backend = common::account_backend();
let space_id = make_space(&backend, "Atomic").await;
let HandlerOutput { primary: resp, .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": {
&space_id: {
"name": "RenamedAttempt",
"addRoles": [
{ "id": "p1", "name": "Mod", "permissions": [], "position": 1 },
{ "id": "p2", "name": "Bad", "permissions": [], "position": 0 }
]
}
}
}),
&[],
)
.await
.expect("handle_space_set");
assert_eq!(
resp["notUpdated"][&space_id]["type"], "invalidProperties",
"whole-target atomicity: one position-0 violation rejects the entire update"
);
let HandlerOutput {
primary: get_resp, ..
} = handle_space_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": [&space_id] }),
&[],
)
.await
.expect("handle_space_get");
assert_eq!(
get_resp["list"][0]["name"], "Atomic",
"structural failure must abort the metadata write"
);
}
#[tokio::test]
async fn space_set_update_mixed_structural_and_metadata_partial_fail() {
let backend = common::account_backend();
let space_id = make_space(&backend, "Original Name").await;
let HandlerOutput { primary: resp, .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": {
&space_id: {
"name": "Renamed",
"updateRoles": [{ "id": "nonexistent", "name": "Mod" }],
}
}
}),
&[],
)
.await
.expect("handle_space_set");
assert_eq!(resp["notUpdated"][&space_id]["type"], "notFound");
let HandlerOutput {
primary: get_resp, ..
} = handle_space_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": [&space_id] }),
&[],
)
.await
.expect("handle_space_get");
assert_eq!(
get_resp["list"][0]["name"], "Original Name",
"structural failure must abort the metadata write — per-target atomicity"
);
}
#[tokio::test]
async fn space_set_update_unknown_property_rejected() {
let backend = common::account_backend();
let space_id = make_space(&backend, "Unknown Property Test").await;
let HandlerOutput { primary: resp, .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": { &space_id: { "name": "OK", "totallyUnknownProperty": 42 } }
}),
&[],
)
.await
.expect("handle_space_set");
assert_eq!(
resp["notUpdated"][&space_id]["type"], "invalidProperties",
"unknown property must be rejected as invalidProperties: {:?}",
resp["notUpdated"][&space_id]
);
let props: Vec<&str> = resp["notUpdated"][&space_id]["properties"]
.as_array()
.expect("properties array")
.iter()
.filter_map(|v| v.as_str())
.collect();
assert!(
props.contains(&"totallyUnknownProperty"),
"properties must name the unknown key: {props:?}"
);
}
fn seed_channel(
backend: &MemoryBackend<()>,
account_id: &str,
chat_id: &str,
space_id: &str,
category_id: Option<&str>,
) {
use jmap_server::JmapObject;
let mut chat = json!({
"id": chat_id,
"kind": "channel",
"muted": false,
"receiveTypingIndicators": true,
"spaceId": space_id,
});
if let Some(cid) = category_id {
chat["categoryId"] = json!(cid);
}
let type_name = <jmap_chat_types::Chat as JmapObject>::TYPE_NAME;
backend.insert_object_for_test(type_name, account_id, chat_id, chat);
}
#[tokio::test]
async fn space_set_category_add_assigns_id_and_pushes() {
let backend = common::account_backend();
let space_id = make_space(&backend, "Cat Add Test").await;
let HandlerOutput { primary: resp, .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": {
&space_id: {
"addCategories": [{
"id": "placeholder",
"name": "General",
"position": 0,
"channelIds": [],
}]
}
}
}),
&[],
)
.await
.expect("handle_space_set");
assert!(
resp["notUpdated"].is_null(),
"addCategories should succeed: {:?}",
resp["notUpdated"]
);
let HandlerOutput {
primary: get_resp, ..
} = handle_space_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": [&space_id] }),
&[],
)
.await
.expect("handle_space_get");
let cats = get_resp["list"][0]["categories"]
.as_array()
.expect("categories array");
assert_eq!(cats.len(), 1, "exactly one category present");
let new_id = cats[0]["id"].as_str().expect("category id");
assert_ne!(
new_id, "placeholder",
"server must replace placeholder with a real id"
);
assert_eq!(cats[0]["name"], "General");
assert_eq!(cats[0]["position"], 0);
}
#[tokio::test]
async fn space_set_category_add_without_id_is_accepted() {
let backend = common::account_backend();
let space_id = make_space(&backend, "Cat No Id Test").await;
let HandlerOutput { primary: resp, .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": {
&space_id: {
"addCategories": [{
"name": "General",
"position": 0,
"channelIds": [],
}]
}
}
}),
&[],
)
.await
.expect("handle_space_set");
assert!(
resp["notUpdated"].is_null(),
"addCategories entries without id must be accepted: {:?}",
resp["notUpdated"]
);
assert!(
resp["updated"].get(&space_id).is_some(),
"addCategories should land in `updated`: {resp:?}"
);
let HandlerOutput {
primary: get_resp, ..
} = handle_space_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": [&space_id] }),
&[],
)
.await
.expect("handle_space_get");
let cats = get_resp["list"][0]["categories"]
.as_array()
.expect("categories array");
assert_eq!(cats.len(), 1, "exactly one category present: {cats:?}");
let id = cats[0]["id"].as_str().expect("category id is a string");
assert!(!id.is_empty(), "server must assign a category id: {cats:?}");
assert_eq!(cats[0]["name"], "General");
assert_eq!(cats[0]["position"], 0);
}
#[tokio::test]
async fn space_set_category_add_assigns_unique_ids() {
let backend = common::account_backend();
let space_a = make_space(&backend, "Cat Unique A").await;
let space_b = make_space(&backend, "Cat Unique B").await;
for (space_id, name) in [
(&space_a, "First"),
(&space_a, "Second"),
(&space_b, "Third"),
] {
let HandlerOutput { primary: resp, .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": {
space_id: {
"addCategories": [{ "name": name, "position": 0, "channelIds": [] }]
}
}
}),
&[],
)
.await
.expect("handle_space_set");
assert!(
resp["notUpdated"].is_null(),
"addCategories {name} should succeed: {:?}",
resp["notUpdated"]
);
}
let HandlerOutput {
primary: get_resp, ..
} = handle_space_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": [&space_a, &space_b] }),
&[],
)
.await
.expect("handle_space_get");
let mut ids: Vec<String> = get_resp["list"]
.as_array()
.expect("list array")
.iter()
.flat_map(|space| space["categories"].as_array().expect("categories array"))
.map(|cat| cat["id"].as_str().expect("category id").to_owned())
.collect();
assert_eq!(ids.len(), 3, "three categories present: {get_resp:?}");
ids.sort();
ids.dedup();
assert_eq!(ids.len(), 3, "category ids must be unique: {get_resp:?}");
}
#[tokio::test]
async fn space_set_category_add_reassigns_existing_channels() {
let backend = common::account_backend();
let space_id = make_space(&backend, "Cat Reassign Test").await;
seed_channel(&backend, ACCOUNT_ID, "ch-1", &space_id, None);
seed_channel(&backend, ACCOUNT_ID, "ch-2", &space_id, None);
let HandlerOutput { primary: resp, .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": {
&space_id: {
"addCategories": [{
"id": "placeholder",
"name": "Voice",
"position": 0,
"channelIds": ["ch-1", "ch-2"],
}]
}
}
}),
&[],
)
.await
.expect("handle_space_set");
assert!(
resp["notUpdated"].is_null(),
"addCategories with channels should succeed: {:?}",
resp["notUpdated"]
);
let new_cat_id = backend.first_category_id(&Id::from(space_id.as_str()));
let chat1 = backend.peek_chat(&Id::from("ch-1"));
let chat2 = backend.peek_chat(&Id::from("ch-2"));
assert_eq!(
chat1["categoryId"].as_str(),
Some(new_cat_id.as_ref()),
"ch-1.categoryId must point at the new category"
);
assert_eq!(
chat2["categoryId"].as_str(),
Some(new_cat_id.as_ref()),
"ch-2.categoryId must point at the new category"
);
}
#[tokio::test]
async fn space_set_category_add_unknown_channel_rejected() {
let backend = common::account_backend();
let space_id = make_space(&backend, "Cat Unknown Channel Test").await;
let HandlerOutput { primary: resp, .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": {
&space_id: {
"addCategories": [{
"id": "placeholder",
"name": "Voice",
"position": 0,
"channelIds": ["nonexistent-channel"],
}]
}
}
}),
&[],
)
.await
.expect("handle_space_set");
assert_eq!(
resp["notUpdated"][&space_id]["type"], "invalidProperties",
"unknown channelId must be invalidProperties: {:?}",
resp["notUpdated"][&space_id]
);
let props: Vec<&str> = resp["notUpdated"][&space_id]["properties"]
.as_array()
.expect("properties array")
.iter()
.filter_map(|v| v.as_str())
.collect();
assert!(
props.contains(&"channelIds"),
"properties must name channelIds: {props:?}"
);
}
#[tokio::test]
async fn space_set_category_remove_unknown_yields_not_found() {
let backend = common::account_backend();
let space_id = make_space(&backend, "Cat Remove Unknown").await;
let HandlerOutput { primary: resp, .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": { &space_id: { "removeCategories": ["does-not-exist"] } }
}),
&[],
)
.await
.expect("handle_space_set");
assert_eq!(
resp["notUpdated"][&space_id]["type"], "notFound",
"removeCategory for unknown id must surface notFound: {:?}",
resp["notUpdated"][&space_id]
);
}
#[tokio::test]
async fn space_set_category_remove_cascades_channels_to_uncategorized() {
let backend = common::account_backend();
let space_id = make_space(&backend, "Cat Cascade Test").await;
seed_channel(&backend, ACCOUNT_ID, "ch-a", &space_id, None);
seed_channel(&backend, ACCOUNT_ID, "ch-b", &space_id, None);
let HandlerOutput { primary: resp, .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": {
&space_id: {
"addCategories": [{
"id": "placeholder",
"name": "TempCat",
"position": 0,
"channelIds": ["ch-a", "ch-b"],
}]
}
}
}),
&[],
)
.await
.expect("add cat");
assert!(resp["notUpdated"].is_null(), "add failed: {:?}", resp);
let cat_id = backend.first_category_id(&Id::from(space_id.as_str()));
let HandlerOutput { primary: resp, .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": { &space_id: { "removeCategories": [cat_id.as_ref()] } }
}),
&[],
)
.await
.expect("remove cat");
assert!(
resp["notUpdated"].is_null(),
"removeCategories should succeed: {:?}",
resp["notUpdated"]
);
let HandlerOutput {
primary: get_resp, ..
} = handle_space_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": [&space_id] }),
&[],
)
.await
.expect("get");
assert_eq!(
get_resp["list"][0]["categories"]
.as_array()
.expect("categories")
.len(),
0,
"category must be removed from Space"
);
let unc: Vec<&str> = get_resp["list"][0]["uncategorizedChannelIds"]
.as_array()
.expect("uncategorized array")
.iter()
.filter_map(|v| v.as_str())
.collect();
assert!(
unc.contains(&"ch-a") && unc.contains(&"ch-b"),
"both channels must cascade into uncategorized: {unc:?}"
);
assert!(
backend
.peek_chat(&Id::from("ch-a"))
.get("categoryId")
.is_none(),
"ch-a categoryId must be cleared after cascade"
);
assert!(
backend
.peek_chat(&Id::from("ch-b"))
.get("categoryId")
.is_none(),
"ch-b categoryId must be cleared after cascade"
);
}
#[tokio::test]
async fn space_set_category_update_rename_and_reassign_channels() {
let backend = common::account_backend();
let space_id = make_space(&backend, "Cat Update Test").await;
seed_channel(&backend, ACCOUNT_ID, "ch-x", &space_id, None);
seed_channel(&backend, ACCOUNT_ID, "ch-y", &space_id, None);
let HandlerOutput { primary: resp, .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": {
&space_id: {
"addCategories": [{
"id": "placeholder",
"name": "Original",
"position": 0,
"channelIds": ["ch-x"],
}]
}
}
}),
&[],
)
.await
.expect("seed cat");
assert!(resp["notUpdated"].is_null());
let cat_id = backend.first_category_id(&Id::from(space_id.as_str()));
let HandlerOutput { primary: resp, .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": {
&space_id: {
"updateCategories": [{
"id": cat_id.as_ref(),
"name": "Renamed",
"channelIds": ["ch-y"],
}]
}
}
}),
&[],
)
.await
.expect("update cat");
assert!(
resp["notUpdated"].is_null(),
"updateCategories must succeed: {:?}",
resp["notUpdated"]
);
let HandlerOutput {
primary: get_resp, ..
} = handle_space_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": [&space_id] }),
&[],
)
.await
.expect("get");
let cats = get_resp["list"][0]["categories"]
.as_array()
.expect("categories");
assert_eq!(cats[0]["name"], "Renamed", "name must update");
let channel_ids: Vec<&str> = cats[0]["channelIds"]
.as_array()
.expect("channelIds")
.iter()
.filter_map(|v| v.as_str())
.collect();
assert_eq!(channel_ids, vec!["ch-y"], "channelIds replaced wholesale");
let unc: Vec<&str> = get_resp["list"][0]["uncategorizedChannelIds"]
.as_array()
.expect("uncategorized")
.iter()
.filter_map(|v| v.as_str())
.collect();
assert!(
unc.contains(&"ch-x"),
"ch-x must land in uncategorized: {unc:?}"
);
assert!(
!unc.contains(&"ch-y"),
"ch-y must have left uncategorized: {unc:?}"
);
assert!(
backend
.peek_chat(&Id::from("ch-x"))
.get("categoryId")
.is_none(),
"ch-x.categoryId must be cleared"
);
assert_eq!(
backend.peek_chat(&Id::from("ch-y"))["categoryId"].as_str(),
Some(cat_id.as_ref()),
"ch-y.categoryId must point at the (renamed) category"
);
}
async fn seed_two_categories(backend: &MemoryBackend<()>, space_id: &str) {
seed_channel(backend, ACCOUNT_ID, "ch-m", space_id, Some("cat-a"));
let HandlerOutput {
primary: get_resp, ..
} = handle_space_get(
backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": [space_id] }),
&[],
)
.await
.expect("get");
let mut space = get_resp["list"][0].clone();
space["categories"] = json!([
{ "id": "cat-a", "name": "A", "position": 0, "channelIds": ["ch-m"] },
{ "id": "cat-b", "name": "B", "position": 1, "channelIds": [] },
]);
backend.insert_object_for_test("Space", ACCOUNT_ID, space_id, space);
}
#[tokio::test]
async fn space_set_category_add_moves_channel_out_of_previous_category() {
let backend = common::account_backend();
let space_id = make_space(&backend, "Cat Add Move Test").await;
seed_two_categories(&backend, &space_id).await;
let HandlerOutput { primary: resp, .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": {
&space_id: {
"addCategories": [{
"id": "placeholder",
"name": "C",
"position": 2,
"channelIds": ["ch-m"],
}]
}
}
}),
&[],
)
.await
.expect("add cat");
assert!(
resp["notUpdated"].is_null(),
"addCategories must succeed: {:?}",
resp["notUpdated"]
);
let HandlerOutput {
primary: get_resp, ..
} = handle_space_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": [&space_id] }),
&[],
)
.await
.expect("get");
let cats = &get_resp["list"][0]["categories"];
assert_eq!(cats[0]["id"], "cat-a");
assert_eq!(
cats[0]["channelIds"],
json!([]),
"ch-m must have left category A"
);
assert_eq!(cats[2]["name"], "C");
assert_eq!(cats[2]["channelIds"], json!(["ch-m"]));
assert_eq!(
backend.peek_chat(&Id::from("ch-m"))["categoryId"],
cats[2]["id"],
"ch-m.categoryId must point at the new category"
);
}
#[tokio::test]
async fn space_set_category_update_moves_channel_out_of_previous_category() {
let backend = common::account_backend();
let space_id = make_space(&backend, "Cat Update Move Test").await;
seed_two_categories(&backend, &space_id).await;
let HandlerOutput { primary: resp, .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": {
&space_id: {
"updateCategories": [{ "id": "cat-b", "channelIds": ["ch-m"] }]
}
}
}),
&[],
)
.await
.expect("update cat");
assert!(
resp["notUpdated"].is_null(),
"updateCategories must succeed: {:?}",
resp["notUpdated"]
);
let HandlerOutput {
primary: get_resp, ..
} = handle_space_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": [&space_id] }),
&[],
)
.await
.expect("get");
let cats = &get_resp["list"][0]["categories"];
assert_eq!(
cats[0]["channelIds"],
json!([]),
"ch-m must have left category A"
);
assert_eq!(cats[1]["channelIds"], json!(["ch-m"]));
assert_eq!(
backend.peek_chat(&Id::from("ch-m"))["categoryId"],
"cat-b",
"ch-m.categoryId must point at category B"
);
}
#[tokio::test]
async fn space_set_category_cascade_emits_chat_changes() {
let backend = common::account_backend();
let space_id = make_space(&backend, "Cat Cascade Chat-changes Test").await;
seed_channel(&backend, ACCOUNT_ID, "ch-p", &space_id, None);
seed_channel(&backend, ACCOUNT_ID, "ch-q", &space_id, None);
let HandlerOutput { .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": {
&space_id: {
"addCategories": [{
"id": "placeholder",
"name": "Cascade",
"position": 0,
"channelIds": ["ch-p", "ch-q"],
}]
}
}
}),
&[],
)
.await
.expect("addCategories");
let HandlerOutput {
primary: changes, ..
} = handle_chat_changes(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "sinceState": "0" }),
&[],
)
.await
.expect("chat_changes");
let mut updated: Vec<&str> = changes["updated"]
.as_array()
.expect("updated array")
.iter()
.filter_map(|v| v.as_str())
.collect();
updated.sort();
assert_eq!(
updated,
vec!["ch-p", "ch-q"],
"Chat/changes must list both cascaded channels as updated: {updated:?}"
);
}
#[tokio::test]
async fn space_set_channel_add_assigns_id_and_lands_uncategorized() {
let backend = common::account_backend();
let space_id = make_space(&backend, "Channel Add Test").await;
let HandlerOutput { primary: resp, .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": {
&space_id: { "addChannels": [{ "name": "general" }] }
}
}),
&[],
)
.await
.expect("handle_space_set");
assert!(
resp["notUpdated"].is_null(),
"addChannels should succeed: {:?}",
resp["notUpdated"]
);
let HandlerOutput {
primary: get_resp, ..
} = handle_space_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": [&space_id] }),
&[],
)
.await
.expect("handle_space_get");
let unc: Vec<&str> = get_resp["list"][0]["uncategorizedChannelIds"]
.as_array()
.expect("uncategorizedChannelIds")
.iter()
.filter_map(|v| v.as_str())
.collect();
assert_eq!(
unc.len(),
1,
"exactly one channel should be uncategorized: {unc:?}"
);
let new_id = unc[0];
let chat = backend.peek_chat(&Id::from(new_id));
assert_eq!(chat["kind"], "channel");
assert_eq!(chat["spaceId"].as_str(), Some(space_id.as_str()));
assert_eq!(chat["name"], "general");
assert_eq!(chat["unreadCount"], 0);
assert_eq!(chat["muted"], false);
assert_eq!(chat["receiveTypingIndicators"], true);
assert!(chat["pinnedMessageIds"].is_array());
assert!(chat["pinnedMessageIds"].as_array().unwrap().is_empty());
assert!(
chat["createdAt"].is_string(),
"createdAt must be set: {chat:?}"
);
assert!(chat.get("categoryId").is_none());
assert!(chat.get("topic").is_none());
assert!(chat.get("position").is_none());
}
#[tokio::test]
async fn space_set_channel_add_into_existing_category() {
let backend = common::account_backend();
let space_id = make_space(&backend, "Channel Add Into Cat").await;
let HandlerOutput { primary: resp, .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": {
&space_id: {
"addCategories": [{
"id": "placeholder",
"name": "Voice",
"position": 0,
"channelIds": [],
}]
}
}
}),
&[],
)
.await
.expect("addCategories");
assert!(resp["notUpdated"].is_null(), "addCategories: {resp:?}");
let cat_id = backend.first_category_id(&Id::from(space_id.as_str()));
let HandlerOutput { primary: resp, .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": {
&space_id: {
"addChannels": [{
"name": "lounge",
"categoryId": cat_id.as_ref(),
"position": 1,
"topic": "general chit-chat",
}]
}
}
}),
&[],
)
.await
.expect("addChannels");
assert!(
resp["notUpdated"].is_null(),
"addChannels should succeed: {:?}",
resp["notUpdated"]
);
let HandlerOutput {
primary: get_resp, ..
} = handle_space_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": [&space_id] }),
&[],
)
.await
.expect("handle_space_get");
let cats = get_resp["list"][0]["categories"]
.as_array()
.expect("categories");
let ch_ids: Vec<&str> = cats[0]["channelIds"]
.as_array()
.expect("channelIds")
.iter()
.filter_map(|v| v.as_str())
.collect();
assert_eq!(
ch_ids.len(),
1,
"category should hold exactly one channel: {ch_ids:?}"
);
assert!(
get_resp["list"][0]["uncategorizedChannelIds"]
.as_array()
.expect("uncategorizedChannelIds")
.is_empty(),
"uncategorizedChannelIds should be empty"
);
let chat = backend.peek_chat(&Id::from(ch_ids[0]));
assert_eq!(chat["categoryId"].as_str(), Some(cat_id.as_ref()));
assert_eq!(chat["position"], 1);
assert_eq!(chat["topic"], "general chit-chat");
}
#[tokio::test]
async fn space_set_channel_add_unknown_category_rejected() {
let backend = common::account_backend();
let space_id = make_space(&backend, "Channel Add Unknown Cat").await;
let HandlerOutput { primary: resp, .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": {
&space_id: {
"addChannels": [{
"name": "ghost",
"categoryId": "nonexistent-cat",
}]
}
}
}),
&[],
)
.await
.expect("handle_space_set");
assert_eq!(
resp["notUpdated"][&space_id]["type"], "invalidProperties",
"unknown categoryId must surface invalidProperties: {:?}",
resp["notUpdated"][&space_id]
);
let props: Vec<&str> = resp["notUpdated"][&space_id]["properties"]
.as_array()
.expect("properties array")
.iter()
.filter_map(|v| v.as_str())
.collect();
assert!(
props.contains(&"categoryId"),
"properties must name categoryId: {props:?}"
);
let HandlerOutput {
primary: get_resp, ..
} = handle_space_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": [&space_id] }),
&[],
)
.await
.expect("handle_space_get");
assert!(
get_resp["list"][0]["uncategorizedChannelIds"]
.as_array()
.expect("uncategorizedChannelIds")
.is_empty(),
"no channel should be created on failed addChannels"
);
}
#[tokio::test]
async fn space_set_channel_remove_unknown_yields_not_found() {
let backend = common::account_backend();
let space_id = make_space(&backend, "Channel Remove Unknown").await;
let HandlerOutput { primary: resp, .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": { &space_id: { "removeChannels": ["does-not-exist"] } }
}),
&[],
)
.await
.expect("handle_space_set");
assert_eq!(
resp["notUpdated"][&space_id]["type"], "notFound",
"removeChannels for unknown id must surface notFound: {:?}",
resp["notUpdated"][&space_id]
);
}
#[tokio::test]
async fn space_set_channel_remove_cascades_messages() {
let backend = common::account_backend();
let space_id = make_space(&backend, "Channel Remove Cascade").await;
let HandlerOutput { primary: resp, .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": {
&space_id: { "addChannels": [
{ "name": "general" },
{ "name": "keep-me" },
] }
}
}),
&[],
)
.await
.expect("addChannels");
assert!(resp["notUpdated"].is_null(), "addChannels: {resp:?}");
let HandlerOutput {
primary: get_resp, ..
} = handle_space_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": [&space_id] }),
&[],
)
.await
.expect("handle_space_get");
let unc: Vec<String> = get_resp["list"][0]["uncategorizedChannelIds"]
.as_array()
.expect("uncategorizedChannelIds")
.iter()
.filter_map(|v| v.as_str().map(str::to_owned))
.collect();
assert_eq!(unc.len(), 2, "two channels uncategorized: {unc:?}");
let (general_id, keep_id) = {
let mut general = None;
let mut keep = None;
for cid in &unc {
let chat = backend.peek_chat(&Id::from(cid.as_str()));
match chat["name"].as_str() {
Some("general") => general = Some(cid.clone()),
Some("keep-me") => keep = Some(cid.clone()),
other => panic!("unexpected channel name: {other:?}"),
}
}
(
general.expect("general channel created"),
keep.expect("keep-me channel created"),
)
};
backend.insert_object_for_test(
<jmap_chat_types::Message as jmap_server::JmapObject>::TYPE_NAME,
ACCOUNT_ID,
"m1",
json!({ "id": "m1", "chatId": general_id, "body": "one" }),
);
backend.insert_object_for_test(
<jmap_chat_types::Message as jmap_server::JmapObject>::TYPE_NAME,
ACCOUNT_ID,
"m2",
json!({ "id": "m2", "chatId": general_id, "body": "two" }),
);
backend.insert_object_for_test(
<jmap_chat_types::Message as jmap_server::JmapObject>::TYPE_NAME,
ACCOUNT_ID,
"m3",
json!({ "id": "m3", "chatId": general_id, "body": "three" }),
);
backend.insert_object_for_test(
<jmap_chat_types::Message as jmap_server::JmapObject>::TYPE_NAME,
ACCOUNT_ID,
"k1",
json!({ "id": "k1", "chatId": keep_id, "body": "keep" }),
);
let HandlerOutput { primary: resp, .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": { &space_id: { "removeChannels": [&general_id] } }
}),
&[],
)
.await
.expect("removeChannels");
assert!(
resp["notUpdated"].is_null(),
"removeChannels should succeed: {:?}",
resp["notUpdated"]
);
let HandlerOutput {
primary: changes_resp,
..
} = handle_message_changes(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "sinceState": "0" }),
&[],
)
.await
.expect("message_changes");
let mut destroyed: Vec<String> = changes_resp["destroyed"]
.as_array()
.expect("destroyed array")
.iter()
.filter_map(|v| v.as_str().map(str::to_owned))
.collect();
destroyed.sort();
assert_eq!(
destroyed,
vec!["m1".to_owned(), "m2".to_owned(), "m3".to_owned()],
"cascade must destroy exactly the three messages in the removed channel: {destroyed:?}"
);
let HandlerOutput {
primary: get_resp, ..
} = handle_space_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": [&space_id] }),
&[],
)
.await
.expect("space_get");
let unc: Vec<&str> = get_resp["list"][0]["uncategorizedChannelIds"]
.as_array()
.expect("uncategorizedChannelIds")
.iter()
.filter_map(|v| v.as_str())
.collect();
assert_eq!(
unc,
vec![keep_id.as_str()],
"only keep-me must remain uncategorized: {unc:?}"
);
}
#[tokio::test]
async fn space_set_channel_update_name_and_position() {
let backend = common::account_backend();
let space_id = make_space(&backend, "Channel Update Basic").await;
let HandlerOutput { primary: resp, .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": {
&space_id: { "addChannels": [{ "name": "old-name", "topic": "old topic" }] }
}
}),
&[],
)
.await
.expect("addChannels");
assert!(resp["notUpdated"].is_null(), "addChannels: {resp:?}");
let HandlerOutput {
primary: get_resp, ..
} = handle_space_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": [&space_id] }),
&[],
)
.await
.expect("space_get");
let ch_id = get_resp["list"][0]["uncategorizedChannelIds"][0]
.as_str()
.expect("channel id")
.to_owned();
let HandlerOutput { primary: resp, .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": {
&space_id: {
"updateChannels": [{
"id": &ch_id,
"name": "renamed",
"position": 7,
}]
}
}
}),
&[],
)
.await
.expect("updateChannels");
assert!(
resp["notUpdated"].is_null(),
"updateChannels should succeed: {:?}",
resp["notUpdated"]
);
let chat = backend.peek_chat(&Id::from(ch_id.as_str()));
assert_eq!(chat["name"], "renamed");
assert_eq!(chat["position"], 7);
assert_eq!(chat["topic"], "old topic");
}
#[tokio::test]
async fn space_set_channel_update_topic_cleared_by_null() {
let backend = common::account_backend();
let space_id = make_space(&backend, "Channel Update Clearable").await;
let HandlerOutput { .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": {
&space_id: { "addChannels": [{ "name": "ch", "topic": "to-clear" }] }
}
}),
&[],
)
.await
.expect("addChannels");
let HandlerOutput {
primary: get_resp, ..
} = handle_space_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": [&space_id] }),
&[],
)
.await
.expect("space_get");
let ch_id = get_resp["list"][0]["uncategorizedChannelIds"][0]
.as_str()
.expect("channel id")
.to_owned();
let HandlerOutput { primary: resp, .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": {
&space_id: { "updateChannels": [{ "id": &ch_id, "topic": null }] }
}
}),
&[],
)
.await
.expect("updateChannels");
assert!(
resp["notUpdated"].is_null(),
"updateChannels should succeed: {:?}",
resp["notUpdated"]
);
let chat = backend.peek_chat(&Id::from(ch_id.as_str()));
assert!(
chat.get("topic").is_none(),
"topic must be cleared (absent): {chat:?}"
);
assert_eq!(chat["name"], "ch");
}
#[tokio::test]
async fn space_set_channel_update_category_move() {
let backend = common::account_backend();
let space_id = make_space(&backend, "Channel Update Move Cat").await;
let HandlerOutput { .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": {
&space_id: {
"addCategories": [{
"id": "placeholder",
"name": "Voice",
"position": 0,
"channelIds": [],
}],
"addChannels": [{ "name": "wandering" }],
}
}
}),
&[],
)
.await
.expect("seed");
let cat_id = backend.first_category_id(&Id::from(space_id.as_str()));
let HandlerOutput {
primary: get_resp, ..
} = handle_space_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": [&space_id] }),
&[],
)
.await
.expect("space_get");
let ch_id = get_resp["list"][0]["uncategorizedChannelIds"][0]
.as_str()
.expect("channel id")
.to_owned();
let HandlerOutput { primary: resp, .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": {
&space_id: {
"updateChannels": [{ "id": &ch_id, "categoryId": cat_id.as_ref() }]
}
}
}),
&[],
)
.await
.expect("updateChannels");
assert!(
resp["notUpdated"].is_null(),
"updateChannels should succeed: {:?}",
resp["notUpdated"]
);
let chat = backend.peek_chat(&Id::from(ch_id.as_str()));
assert_eq!(chat["categoryId"].as_str(), Some(cat_id.as_ref()));
let HandlerOutput {
primary: get_resp, ..
} = handle_space_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": [&space_id] }),
&[],
)
.await
.expect("space_get");
assert!(
get_resp["list"][0]["uncategorizedChannelIds"]
.as_array()
.expect("uncategorizedChannelIds")
.is_empty(),
"uncategorized must be empty after move"
);
let new_ch_ids: Vec<&str> = get_resp["list"][0]["categories"][0]["channelIds"]
.as_array()
.expect("channelIds")
.iter()
.filter_map(|v| v.as_str())
.collect();
assert_eq!(
new_ch_ids,
vec![ch_id.as_str()],
"category channelIds must now hold the channel: {new_ch_ids:?}"
);
}
#[tokio::test]
async fn space_set_channel_update_category_cleared_by_null() {
let backend = common::account_backend();
let space_id = make_space(&backend, "Channel Update Clear Cat").await;
let HandlerOutput { primary: resp, .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": {
&space_id: {
"addCategories": [{
"id": "placeholder",
"name": "Voice",
"position": 0,
"channelIds": [],
}]
}
}
}),
&[],
)
.await
.expect("addCategories");
assert!(resp["notUpdated"].is_null());
let cat_id = backend.first_category_id(&Id::from(space_id.as_str()));
let HandlerOutput { .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": {
&space_id: {
"addChannels": [{ "name": "ch", "categoryId": cat_id.as_ref() }]
}
}
}),
&[],
)
.await
.expect("addChannels");
let HandlerOutput {
primary: get_resp, ..
} = handle_space_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": [&space_id] }),
&[],
)
.await
.expect("space_get");
let ch_id = get_resp["list"][0]["categories"][0]["channelIds"][0]
.as_str()
.expect("channel id")
.to_owned();
let HandlerOutput { primary: resp, .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": {
&space_id: {
"updateChannels": [{ "id": &ch_id, "categoryId": null }]
}
}
}),
&[],
)
.await
.expect("updateChannels");
assert!(resp["notUpdated"].is_null(), "{resp:?}");
let chat = backend.peek_chat(&Id::from(ch_id.as_str()));
assert!(
chat.get("categoryId").is_none(),
"Chat.categoryId must be absent after clear: {chat:?}"
);
let HandlerOutput {
primary: get_resp, ..
} = handle_space_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": [&space_id] }),
&[],
)
.await
.expect("space_get");
let unc: Vec<&str> = get_resp["list"][0]["uncategorizedChannelIds"]
.as_array()
.expect("uncategorizedChannelIds")
.iter()
.filter_map(|v| v.as_str())
.collect();
assert_eq!(
unc,
vec![ch_id.as_str()],
"channel must move back to uncategorized: {unc:?}"
);
assert!(
get_resp["list"][0]["categories"][0]["channelIds"]
.as_array()
.expect("channelIds")
.is_empty(),
"former category's channelIds must drop the channel"
);
}
#[tokio::test]
async fn space_set_channel_update_unknown_category_rejected() {
let backend = common::account_backend();
let space_id = make_space(&backend, "Channel Update Unknown Cat").await;
let HandlerOutput { .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": { &space_id: { "addChannels": [{ "name": "ch" }] } }
}),
&[],
)
.await
.expect("addChannels");
let HandlerOutput {
primary: get_resp, ..
} = handle_space_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": [&space_id] }),
&[],
)
.await
.expect("space_get");
let ch_id = get_resp["list"][0]["uncategorizedChannelIds"][0]
.as_str()
.expect("channel id")
.to_owned();
let HandlerOutput { primary: resp, .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": {
&space_id: {
"updateChannels": [{ "id": &ch_id, "categoryId": "no-such-cat" }]
}
}
}),
&[],
)
.await
.expect("updateChannels");
assert_eq!(
resp["notUpdated"][&space_id]["type"], "invalidProperties",
"unknown categoryId on update must surface invalidProperties: {:?}",
resp["notUpdated"][&space_id]
);
let chat = backend.peek_chat(&Id::from(ch_id.as_str()));
assert!(
chat.get("categoryId").is_none(),
"categoryId must remain unset after failed update: {chat:?}"
);
}
#[tokio::test]
async fn space_set_channel_update_unknown_channel_yields_not_found() {
let backend = common::account_backend();
let space_id = make_space(&backend, "Channel Update Unknown Channel").await;
let HandlerOutput { primary: resp, .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": {
&space_id: {
"updateChannels": [{ "id": "no-such-channel", "name": "x" }]
}
}
}),
&[],
)
.await
.expect("updateChannels");
assert_eq!(
resp["notUpdated"][&space_id]["type"], "notFound",
"updateChannels for unknown id must surface notFound: {:?}",
resp["notUpdated"][&space_id]
);
}
#[tokio::test]
async fn space_set_channel_changelog_dedups_create_then_destroy() {
let backend = common::account_backend();
let space_id = make_space(&backend, "Channel Changelog Dedup").await;
let HandlerOutput {
primary: chat_state_resp,
..
} = handle_chat_changes(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "sinceState": "0" }),
&[],
)
.await
.expect("chat_changes baseline");
let baseline_state = chat_state_resp["newState"]
.as_str()
.expect("baseline state")
.to_owned();
let HandlerOutput { primary: resp, .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": {
&space_id: {
"addChannels": [{ "name": "ephemeral" }]
}
}
}),
&[],
)
.await
.expect("addChannels");
assert!(resp["notUpdated"].is_null(), "addChannels: {resp:?}");
let HandlerOutput {
primary: get_resp, ..
} = handle_space_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": [&space_id] }),
&[],
)
.await
.expect("space_get");
let ch_id = get_resp["list"][0]["uncategorizedChannelIds"][0]
.as_str()
.expect("channel id")
.to_owned();
let HandlerOutput {
primary: chat_state_resp,
..
} = handle_chat_changes(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "sinceState": &baseline_state }),
&[],
)
.await
.expect("chat_changes after create");
let created_list: Vec<&str> = chat_state_resp["created"]
.as_array()
.expect("created array")
.iter()
.filter_map(|v| v.as_str())
.collect();
assert_eq!(
created_list,
vec![ch_id.as_str()],
"Chat/changes after create must list the new channel: {created_list:?}"
);
let after_create_state = chat_state_resp["newState"]
.as_str()
.expect("post-create state")
.to_owned();
let HandlerOutput { primary: resp, .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": { &space_id: { "removeChannels": [&ch_id] } }
}),
&[],
)
.await
.expect("removeChannels");
assert!(resp["notUpdated"].is_null(), "removeChannels: {resp:?}");
let HandlerOutput {
primary: chat_state_resp,
..
} = handle_chat_changes(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "sinceState": &after_create_state }),
&[],
)
.await
.expect("chat_changes after destroy");
let destroyed: Vec<&str> = chat_state_resp["destroyed"]
.as_array()
.expect("destroyed array")
.iter()
.filter_map(|v| v.as_str())
.collect();
assert_eq!(
destroyed,
vec![ch_id.as_str()],
"destroy delta must list the channel id: {destroyed:?}"
);
assert!(
chat_state_resp["created"]
.as_array()
.expect("created array")
.is_empty(),
"created list in destroy delta must be empty: {:?}",
chat_state_resp["created"]
);
assert!(
chat_state_resp["updated"]
.as_array()
.expect("updated array")
.is_empty(),
"updated list in destroy delta must be empty: {:?}",
chat_state_resp["updated"]
);
}
#[tokio::test]
async fn space_set_update_metadata_success() {
let backend = common::account_backend();
let space_id = make_space(&backend, "Original Name").await;
let HandlerOutput { primary: resp, .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": {
&space_id: {
"name": "New Name",
"description": "Updated description",
"isPublic": true
}
}
}),
&[],
)
.await
.expect("handle_space_set");
assert!(
resp["notUpdated"].is_null(),
"metadata update should not produce notUpdated: {:?}",
resp["notUpdated"]
);
assert!(
resp["updated"][&space_id].is_null(),
"updated entry for the space should be present (null sentinel)"
);
let HandlerOutput {
primary: get_resp, ..
} = handle_space_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": [&space_id] }),
&[],
)
.await
.expect("handle_space_get");
assert_eq!(get_resp["list"][0]["name"], "New Name");
assert_eq!(get_resp["list"][0]["description"], "Updated description");
assert_eq!(get_resp["list"][0]["isPublic"], true);
}
#[tokio::test]
async fn contact_set_create_without_identity_invalid_properties() {
let backend = common::account_backend();
let HandlerOutput { primary: resp, .. } = handle_contact_set(
&backend,
&(),
json!({
"accountId": ACCOUNT_ID,
"create": { "ct0": { "login": "alice@example.com", "blocked": false } }
}),
)
.await
.expect("handle_contact_set");
assert!(resp["created"].is_null());
assert_eq!(resp["notCreated"]["ct0"]["type"], "invalidProperties");
let mut props: Vec<&str> = resp["notCreated"]["ct0"]["properties"]
.as_array()
.expect("properties array")
.iter()
.map(|p| p.as_str().expect("property name"))
.collect();
props.sort_unstable();
assert_eq!(props, ["blocked", "identity", "login"]);
}
#[tokio::test]
async fn contact_set_destroy_forbidden() {
let backend = common::account_backend();
let HandlerOutput { primary: resp, .. } = handle_contact_set(
&backend,
&(),
json!({
"accountId": ACCOUNT_ID,
"destroy": ["some-id"]
}),
)
.await
.expect("handle_contact_set");
assert!(resp["destroyed"].is_null());
assert!(resp["notDestroyed"]["some-id"].is_object());
assert_eq!(resp["notDestroyed"]["some-id"]["type"], "forbidden");
}
#[tokio::test]
async fn contact_set_update_allowed_fields_apply() {
let backend = common::account_backend();
backend.register_account(&jmap_types::Id::from(ACCOUNT_ID));
backend.insert_object_for_test(
"ChatContact",
ACCOUNT_ID,
"ct1",
json!({
"id": "ct1",
"identity": "alice@example.com",
"login": "alice@example.com",
"firstSeenAt": "2024-01-01T00:00:00Z",
"lastSeenAt": "2024-01-02T00:00:00Z",
"blocked": false
}),
);
let HandlerOutput { primary: resp, .. } = handle_contact_set(
&backend,
&(),
json!({
"accountId": ACCOUNT_ID,
"update": { "ct1": { "blocked": true, "displayName": "Alice" } }
}),
)
.await
.expect("handle_contact_set");
assert!(
resp["notUpdated"].is_null(),
"spec-allowed patch must update: {:?}",
resp["notUpdated"]
);
let HandlerOutput {
primary: get_resp, ..
} = handle_contact_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": ["ct1"] }),
)
.await
.expect("handle_contact_get");
assert_eq!(get_resp["list"][0]["blocked"], json!(true));
assert_eq!(get_resp["list"][0]["displayName"], json!("Alice"));
}
#[tokio::test]
async fn contact_set_update_rejects_server_set_fields() {
let backend = common::account_backend();
backend.register_account(&jmap_types::Id::from(ACCOUNT_ID));
backend.insert_object_for_test(
"ChatContact",
ACCOUNT_ID,
"ct1",
json!({
"id": "ct1",
"identity": "alice@example.com",
"login": "alice@example.com",
"firstSeenAt": "2024-01-01T00:00:00Z",
"lastSeenAt": "2024-01-02T00:00:00Z",
"blocked": false
}),
);
let HandlerOutput { primary: resp, .. } = handle_contact_set(
&backend,
&(),
json!({
"accountId": ACCOUNT_ID,
"update": { "ct1": { "presence": "online", "lastActiveAt": "2030-01-01T00:00:00Z" } }
}),
)
.await
.expect("handle_contact_set");
assert!(
resp["updated"].is_null(),
"non-allowed patch must not update"
);
let not_updated = resp["notUpdated"]
.as_object()
.expect("notUpdated must be populated");
assert_eq!(
not_updated["ct1"],
json!({ "type": "invalidProperties", "properties": ["presence", "lastActiveAt"] }),
);
let HandlerOutput {
primary: get_resp, ..
} = handle_contact_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": ["ct1"] }),
)
.await
.expect("handle_contact_get");
assert!(
get_resp["list"][0].get("presence").is_none(),
"presence must not have leaked into the stored object"
);
assert!(
get_resp["list"][0].get("lastActiveAt").is_none(),
"lastActiveAt must not have leaked into the stored object"
);
}
#[tokio::test]
async fn contact_set_update_identity_rejected() {
let backend = common::account_backend();
backend.register_account(&jmap_types::Id::from(ACCOUNT_ID));
backend.insert_object_for_test(
"ChatContact",
ACCOUNT_ID,
"ct1",
json!({
"id": "ct1",
"identity": "alice@example.com",
"login": "alice@example.com",
"firstSeenAt": "2024-01-01T00:00:00Z",
"lastSeenAt": "2024-01-02T00:00:00Z",
"blocked": false
}),
);
let HandlerOutput { primary: resp, .. } = handle_contact_set(
&backend,
&(),
json!({
"accountId": ACCOUNT_ID,
"update": { "ct1": { "identity": "did:web:mallory.example", "blocked": true } }
}),
)
.await
.expect("handle_contact_set");
assert_eq!(
resp["notUpdated"]["ct1"],
json!({ "type": "invalidProperties", "properties": ["identity"] })
);
let HandlerOutput {
primary: get_resp, ..
} = handle_contact_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": ["ct1"] }),
)
.await
.expect("handle_contact_get");
assert_eq!(get_resp["list"][0]["identity"], "alice@example.com");
assert_eq!(get_resp["list"][0]["blocked"], false);
}
#[tokio::test]
async fn contact_set_update_mixed_patch_with_server_set_field_rejected() {
let backend = common::account_backend();
backend.register_account(&jmap_types::Id::from(ACCOUNT_ID));
backend.insert_object_for_test(
"ChatContact",
ACCOUNT_ID,
"ct1",
json!({
"id": "ct1",
"identity": "alice@example.com",
"login": "alice@example.com",
"firstSeenAt": "2024-01-01T00:00:00Z",
"lastSeenAt": "2024-01-02T00:00:00Z",
"blocked": false
}),
);
let HandlerOutput { primary: resp, .. } = handle_contact_set(
&backend,
&(),
json!({
"accountId": ACCOUNT_ID,
"update": { "ct1": { "blocked": true, "presence": "online" } }
}),
)
.await
.expect("handle_contact_set");
assert_eq!(
resp["notUpdated"]["ct1"],
json!({ "type": "invalidProperties", "properties": ["presence"] }),
);
let HandlerOutput {
primary: get_resp, ..
} = handle_contact_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": ["ct1"] }),
)
.await
.expect("handle_contact_get");
assert_eq!(get_resp["list"][0]["blocked"], json!(false));
assert!(
get_resp["list"][0].get("presence").is_none(),
"non-allowed `presence` field must not have leaked into the stored object"
);
}
#[tokio::test]
async fn contact_get_empty() {
let backend = common::account_backend();
let HandlerOutput {
primary: get_resp, ..
} = handle_contact_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": null }),
)
.await
.expect("get");
assert_eq!(get_resp["list"].as_array().expect("list").len(), 0);
}
#[tokio::test]
async fn contact_changes_empty() {
let backend = common::account_backend();
let HandlerOutput { primary: resp, .. } = handle_contact_changes(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "sinceState": "0" }),
)
.await
.expect("changes");
assert_eq!(resp["created"].as_array().expect("created").len(), 0);
assert_eq!(resp["updated"].as_array().expect("updated").len(), 0);
assert_eq!(resp["destroyed"].as_array().expect("destroyed").len(), 0);
}
#[tokio::test]
async fn position_set_create_missing_chat_id() {
let backend = common::account_backend();
let HandlerOutput { primary: resp, .. } = handle_position_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": { "rp0": { "lastReadMessageId": "m1" } }
}),
)
.await
.expect("handle_position_set");
assert!(resp["notCreated"]["rp0"].is_object());
assert_eq!(resp["notCreated"]["rp0"]["type"], "forbidden");
}
#[tokio::test]
async fn position_set_create_forbidden() {
let backend = common::account_backend();
let HandlerOutput { primary: resp, .. } = handle_position_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": { "rp0": { "chatId": "c1" } }
}),
)
.await
.expect("handle_position_set");
assert!(resp["created"]["rp0"].is_null());
assert_eq!(resp["notCreated"]["rp0"]["type"], "forbidden");
}
#[tokio::test]
async fn position_set_create_duplicate_chat_id_sequential_rejected() {
let backend = common::account_backend();
let HandlerOutput { primary: first, .. } = handle_position_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": { "rp0": { "chatId": "c1" } }
}),
)
.await
.expect("first create");
assert_eq!(first["notCreated"]["rp0"]["type"], "forbidden");
let HandlerOutput {
primary: second, ..
} = handle_position_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": { "rp1": { "chatId": "c1" } }
}),
)
.await
.expect("second create");
assert!(second["notCreated"]["rp1"].is_object());
assert_eq!(second["notCreated"]["rp1"]["type"], "forbidden");
assert!(second["created"].as_object().is_none_or(|m| m.is_empty()));
let HandlerOutput { primary: get, .. } =
handle_position_get(&backend, &(), json!({ "accountId": ACCOUNT_ID }))
.await
.expect("get");
assert_eq!(get["list"].as_array().expect("list").len(), 0);
}
#[tokio::test]
async fn position_set_create_duplicate_chat_id_intra_batch_rejected() {
let backend = common::account_backend();
let HandlerOutput { primary: resp, .. } = handle_position_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": {
"rp0": { "chatId": "c1" },
"rp1": { "chatId": "c1" }
}
}),
)
.await
.expect("handle_position_set");
let created_keys: Vec<&str> = resp["created"]
.as_object()
.map(|m| m.keys().map(String::as_str).collect())
.unwrap_or_default();
assert_eq!(created_keys.len(), 0, "no create may succeed");
assert_eq!(resp["notCreated"]["rp0"]["type"], "forbidden");
assert_eq!(resp["notCreated"]["rp1"]["type"], "forbidden");
}
#[tokio::test]
async fn position_set_update_chat_id_rejected() {
let backend = common::account_backend();
let rp_id = "rp0";
backend.insert_object_for_test(
"ReadPosition",
ACCOUNT_ID,
rp_id,
json!({ "id": rp_id, "chatId": "c1" }),
);
let HandlerOutput { primary: resp, .. } = handle_position_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": { rp_id: { "chatId": "c2" } }
}),
)
.await
.expect("update");
assert!(resp["notUpdated"][rp_id].is_object());
assert_eq!(resp["notUpdated"][rp_id]["type"], "invalidProperties");
}
#[tokio::test]
async fn position_get_returns_created() {
let backend = common::account_backend();
let rp_id = "rp0".to_owned();
backend.insert_object_for_test(
"ReadPosition",
ACCOUNT_ID,
&rp_id,
json!({ "id": rp_id, "chatId": "c99" }),
);
let HandlerOutput {
primary: get_resp, ..
} = handle_position_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": [rp_id] }),
)
.await
.expect("get");
assert_eq!(get_resp["list"][0]["chatId"], "c99");
}
#[tokio::test]
async fn chat_get_backend_error_maps_to_server_fail() {
let backend = FaultyBackend;
let err = handle_chat_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": null }),
&[],
)
.await
.unwrap_err();
assert_eq!(err.error_type.to_string(), "serverFail");
}
#[tokio::test]
async fn chat_set_backend_error_maps_to_server_fail() {
let backend = FaultyBackend;
let err = handle_chat_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({ "accountId": ACCOUNT_ID, "create": { "c0": { "kind": "group" } } }),
&[],
)
.await
.unwrap_err();
assert_eq!(err.error_type.to_string(), "serverFail");
}
#[tokio::test]
async fn chat_set_create_direct_duplicate_rejected() {
let backend = common::account_backend();
let HandlerOutput { primary: resp1, .. } = handle_chat_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": {
"c0": { "kind": "direct", "contactId": "u1" }
}
}),
&[],
)
.await
.expect("first create");
assert!(
resp1["created"]["c0"].is_object(),
"first create must succeed"
);
let existing_id = resp1["created"]["c0"]["id"]
.as_str()
.expect("id in created response")
.to_owned();
let HandlerOutput { primary: resp2, .. } = handle_chat_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": {
"c1": { "kind": "direct", "contactId": "u1" }
}
}),
&[],
)
.await
.expect("second create call");
assert_eq!(
resp2["created"],
json!(null),
"duplicate must not be created"
);
let err = &resp2["notCreated"]["c1"];
assert!(err.is_object(), "notCreated entry must be present");
assert_eq!(err["type"], "alreadyExists");
assert_eq!(err["existingId"], existing_id);
}
#[tokio::test]
async fn chat_set_create_direct_different_contacts_allowed() {
let backend = common::account_backend();
let HandlerOutput { primary: resp1, .. } = handle_chat_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": { "c0": { "kind": "direct", "contactId": "u1" } }
}),
&[],
)
.await
.expect("create u1");
assert!(resp1["created"]["c0"].is_object());
let HandlerOutput { primary: resp2, .. } = handle_chat_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": { "c1": { "kind": "direct", "contactId": "u2" } }
}),
&[],
)
.await
.expect("create u2");
assert!(
resp2["created"]["c1"].is_object(),
"different contactId must succeed"
);
assert_eq!(resp2["notCreated"], json!(null));
}
#[tokio::test]
async fn accounts_are_isolated() {
let backend = common::account_backend();
let a1 = Id::from(ACCOUNT_ID);
let a2 = Id::from(ACCOUNT_ID_B);
backend.register_account(&a1);
backend.register_account(&a2);
handle_chat_set(&backend, &(), &std::collections::BTreeMap::new(),
json!({ "accountId": ACCOUNT_ID, "create": { "c0": { "kind": "group", "name": "A's group" } } }),
&[],
)
.await
.expect("create in a1");
let HandlerOutput { primary: resp, .. } = handle_chat_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID_B, "ids": null }),
&[],
)
.await
.expect("get from a2");
assert_eq!(
resp["list"].as_array().expect("list").len(),
0,
"a2 must not see a1's chats"
);
}
#[tokio::test]
async fn contact_query_empty() {
let backend = common::account_backend();
let HandlerOutput {
primary: resp,
extra_invocations: invocations,
..
} = handle_contact_query(&backend, &(), json!({ "accountId": ACCOUNT_ID }))
.await
.expect("handle_contact_query");
assert!(invocations.is_empty());
assert_eq!(resp["accountId"], ACCOUNT_ID);
assert_eq!(resp["ids"], json!([]));
assert_eq!(resp["position"], 0);
}
#[tokio::test]
async fn contact_query_changes_requires_since_state() {
let backend = common::account_backend();
backend.register_account(&Id::from(ACCOUNT_ID));
let err = handle_contact_query_changes(&backend, &(), json!({ "accountId": ACCOUNT_ID }))
.await
.unwrap_err();
assert_eq!(err.error_type.to_string(), "invalidArguments");
}
#[tokio::test]
async fn invite_get_empty() {
let backend = common::account_backend();
let HandlerOutput {
primary: resp,
extra_invocations: invocations,
..
} = handle_invite_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": null }),
)
.await
.expect("handle_invite_get");
assert!(invocations.is_empty());
assert_eq!(resp["accountId"], ACCOUNT_ID);
assert_eq!(resp["list"], json!([]));
assert_eq!(resp["notFound"], json!([]));
}
#[tokio::test]
async fn invite_set_create_missing_space_id() {
let backend = common::account_backend();
let HandlerOutput { primary: resp, .. } = handle_invite_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": { "i0": { "maxUses": 5 } }
}),
)
.await
.expect("handle_invite_set");
assert!(resp["notCreated"]["i0"].is_object());
let props = resp["notCreated"]["i0"]["properties"]
.as_array()
.expect("properties");
assert!(props.iter().any(|p| p == "spaceId"));
}
#[tokio::test]
async fn invite_set_create_with_malformed_expiry_rejected() {
let backend = common::account_backend();
let HandlerOutput { primary: resp, .. } = handle_invite_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": {
"i0": { "spaceId": "s1", "expiresAt": "next-friday" }
}
}),
)
.await
.expect("handle_invite_set");
assert!(resp["notCreated"]["i0"].is_object());
assert_eq!(resp["notCreated"]["i0"]["type"], "invalidProperties");
let props = resp["notCreated"]["i0"]["properties"]
.as_array()
.expect("properties");
assert!(
props.iter().any(|p| p == "expiresAt"),
"expiresAt must be listed in rejected properties"
);
}
#[tokio::test]
async fn invite_set_create_success() {
let backend = common::account_backend();
let HandlerOutput { primary: resp, .. } = handle_invite_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": { "i0": { "spaceId": "s1" } }
}),
)
.await
.expect("handle_invite_set");
assert!(resp["created"]["i0"].is_object(), "should be in created");
assert_eq!(resp["created"]["i0"]["spaceId"], "s1");
let code = resp["created"]["i0"]["code"].as_str().expect("code field");
assert!(!code.is_empty(), "code must be non-empty");
assert_eq!(resp["created"]["i0"]["uses"], 0);
}
#[tokio::test]
async fn invite_set_update_forbidden() {
let backend = common::account_backend();
let HandlerOutput {
primary: create_resp,
..
} = handle_invite_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({ "accountId": ACCOUNT_ID, "create": { "i0": { "spaceId": "s1" } } }),
)
.await
.expect("create");
let invite_id = create_resp["created"]["i0"]["id"]
.as_str()
.expect("id")
.to_owned();
let HandlerOutput { primary: resp, .. } = handle_invite_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": { &invite_id: { "maxUses": 99 } }
}),
)
.await
.expect("handle_invite_set");
assert!(
resp["notUpdated"][&invite_id].is_object(),
"update must be rejected"
);
assert_eq!(
resp["notUpdated"][&invite_id]["type"], "forbidden",
"error type must be forbidden"
);
}
#[tokio::test]
async fn invite_get_returns_created() {
let backend = common::account_backend();
let HandlerOutput {
primary: create_resp,
..
} = handle_invite_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({ "accountId": ACCOUNT_ID, "create": { "i0": { "spaceId": "s2", "maxUses": 10 } } }),
)
.await
.expect("create");
let invite_id = create_resp["created"]["i0"]["id"]
.as_str()
.expect("id")
.to_owned();
let HandlerOutput { primary: resp, .. } = handle_invite_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": [invite_id] }),
)
.await
.expect("handle_invite_get");
let list = resp["list"].as_array().expect("list");
assert_eq!(list.len(), 1, "one invite should be returned");
assert_eq!(list[0]["spaceId"], "s2");
assert_eq!(list[0]["maxUses"], 10);
assert_eq!(list[0]["uses"], 0);
}
#[tokio::test]
async fn emoji_get_empty() {
use jmap_chat_server::handle_emoji_get;
let backend = common::account_backend();
let HandlerOutput {
primary: resp,
extra_invocations: invocations,
..
} = handle_emoji_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": null }),
)
.await
.expect("handle_emoji_get");
assert!(invocations.is_empty());
assert_eq!(resp["accountId"], ACCOUNT_ID);
assert_eq!(resp["state"], "0");
assert_eq!(resp["list"], json!([]));
assert_eq!(resp["notFound"], json!([]));
}
#[tokio::test]
async fn emoji_set_create_missing_name() {
use jmap_chat_server::handle_emoji_set;
let backend = common::account_backend();
let HandlerOutput { primary: resp, .. } = handle_emoji_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": { "e0": { "blobId": "b1" } }
}),
)
.await
.expect("handle_emoji_set");
assert!(resp["notCreated"]["e0"].is_object());
let props = resp["notCreated"]["e0"]["properties"]
.as_array()
.expect("properties");
assert!(props.iter().any(|p| p == "name"));
}
#[tokio::test]
async fn emoji_set_create_invalid_name() {
use jmap_chat_server::handle_emoji_set;
let backend = common::account_backend();
let HandlerOutput { primary: resp, .. } = handle_emoji_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": { "e0": { "name": "UPPERCASE!", "blobId": "b1" } }
}),
)
.await
.expect("handle_emoji_set");
assert!(resp["notCreated"]["e0"].is_object());
assert_eq!(resp["notCreated"]["e0"]["type"], "invalidProperties");
let props = resp["notCreated"]["e0"]["properties"]
.as_array()
.expect("properties");
assert!(props.iter().any(|p| p == "name"));
}
#[tokio::test]
async fn emoji_set_create_success() {
use jmap_chat_server::handle_emoji_set;
let backend = common::account_backend();
let HandlerOutput { primary: resp, .. } = handle_emoji_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": { "e0": { "name": "party-blob_2", "blobId": "b1" } }
}),
)
.await
.expect("handle_emoji_set");
assert!(resp["created"]["e0"].is_object(), "e0 must be in created");
assert_eq!(resp["notCreated"], json!(null));
assert_eq!(resp["created"]["e0"]["name"], "party-blob_2");
assert_ne!(resp["newState"], resp["oldState"], "state must advance");
}
#[tokio::test]
async fn emoji_get_returns_created() {
use jmap_chat_server::{handle_emoji_get, handle_emoji_set};
let backend = common::account_backend();
let HandlerOutput {
primary: create_resp,
..
} = handle_emoji_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": { "e0": { "name": "rocket", "blobId": "b99" } }
}),
)
.await
.expect("create");
let emoji_id = create_resp["created"]["e0"]["id"]
.as_str()
.expect("id")
.to_owned();
let HandlerOutput {
primary: get_resp, ..
} = handle_emoji_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": [emoji_id] }),
)
.await
.expect("get");
assert_eq!(get_resp["list"].as_array().expect("list").len(), 1);
assert_eq!(get_resp["list"][0]["name"], "rocket");
assert_eq!(get_resp["list"][0]["blobId"], "b99");
assert_eq!(get_resp["notFound"], json!([]));
}
#[tokio::test]
async fn emoji_set_create_server_global_no_authz_block() {
use jmap_chat_server::handle_emoji_set;
let backend = common::account_backend();
let HandlerOutput { primary: resp, .. } = handle_emoji_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": { "e0": { "name": "smile", "blobId": "b1" } }
}),
)
.await
.expect("handle_emoji_set");
assert!(resp["created"]["e0"].is_object());
assert_eq!(resp["notCreated"], json!(null));
assert_eq!(
resp["created"]["e0"]["spaceId"],
json!(null),
"server-global emoji has no spaceId"
);
}
#[tokio::test]
async fn emoji_set_create_space_scoped_no_authz_block() {
use jmap_chat_server::handle_emoji_set;
let backend = common::account_backend();
let HandlerOutput { primary: resp, .. } = handle_emoji_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": {
"e0": { "name": "wave", "blobId": "b1", "spaceId": "s1" }
}
}),
)
.await
.expect("handle_emoji_set");
assert!(resp["created"]["e0"].is_object());
assert_eq!(resp["notCreated"], json!(null));
assert_eq!(resp["created"]["e0"]["spaceId"], "s1");
}
#[tokio::test]
async fn emoji_set_create_authz_denied_returns_forbidden() {
use jmap_chat_server::handle_emoji_set;
let backend = TrackingBackend::with_emoji_set_denied();
let HandlerOutput { primary: resp, .. } = handle_emoji_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": { "e0": { "name": "blocked", "blobId": "b1" } }
}),
)
.await
.expect("handle_emoji_set");
assert_eq!(resp["created"], json!(null));
let nc = &resp["notCreated"]["e0"];
assert!(nc.is_object(), "e0 must appear in notCreated");
assert_eq!(nc["type"], "forbidden");
assert!(
nc["description"]
.as_str()
.is_some_and(|s| s.contains("emoji authorization")),
"description must reference the authorization gate (got {nc:?})"
);
}
#[tokio::test]
async fn emoji_set_update_authz_denied_returns_forbidden() {
use jmap_chat_server::handle_emoji_set;
let backend = TrackingBackend::with_emoji_set_denied();
backend.inner().insert_object_for_test(
"CustomEmoji",
ACCOUNT_ID,
"emoji1",
json!({
"id": "emoji1",
"name": "preexisting",
"blobId": "b1",
"createdBy": ACCOUNT_ID,
"createdAt": "2024-01-01T00:00:00Z"
}),
);
let HandlerOutput { primary: resp, .. } = handle_emoji_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": { "emoji1": { "name": "renamed" } }
}),
)
.await
.expect("handle_emoji_set");
assert_eq!(resp["updated"], json!(null));
let nu = &resp["notUpdated"]["emoji1"];
assert!(nu.is_object(), "emoji1 must appear in notUpdated");
assert_eq!(nu["type"], "forbidden");
}
#[tokio::test]
async fn emoji_set_destroy_authz_denied_returns_forbidden() {
use jmap_chat_server::handle_emoji_set;
let backend = TrackingBackend::with_emoji_set_denied();
backend.inner().insert_object_for_test(
"CustomEmoji",
ACCOUNT_ID,
"emoji1",
json!({
"id": "emoji1",
"name": "doomed",
"blobId": "b1",
"createdBy": ACCOUNT_ID,
"createdAt": "2024-01-01T00:00:00Z"
}),
);
let HandlerOutput { primary: resp, .. } = handle_emoji_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"destroy": ["emoji1"]
}),
)
.await
.expect("handle_emoji_set");
assert_eq!(
resp["destroyed"],
json!(null),
"destroyed array must be absent (null) when no entry succeeded"
);
let nd = &resp["notDestroyed"]["emoji1"];
assert!(nd.is_object(), "emoji1 must appear in notDestroyed");
assert_eq!(nd["type"], "forbidden");
}
#[tokio::test]
async fn emoji_set_update_missing_id_does_not_consult_gate() {
use jmap_chat_server::handle_emoji_set;
let backend = TrackingBackend::with_emoji_set_denied();
let HandlerOutput { primary: resp, .. } = handle_emoji_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": { "ghost": { "name": "ghost" } }
}),
)
.await
.expect("handle_emoji_set");
let nu = &resp["notUpdated"]["ghost"];
assert!(nu.is_object());
assert_eq!(
nu["type"], "notFound",
"non-existent target must surface notFound, NOT forbidden"
);
}
#[tokio::test]
async fn ban_get_empty() {
let backend = common::account_backend();
let HandlerOutput {
primary: resp,
extra_invocations: invocations,
..
} = handle_ban_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": null }),
)
.await
.expect("handle_ban_get");
assert!(invocations.is_empty());
assert_eq!(resp["accountId"], ACCOUNT_ID);
assert_eq!(resp["list"], json!([]));
assert_eq!(resp["notFound"], json!([]));
}
#[tokio::test]
async fn ban_set_create_missing_space_id() {
let backend = common::account_backend();
let HandlerOutput { primary: resp, .. } = handle_ban_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": { "b0": { "userId": "u2" } }
}),
)
.await
.expect("handle_ban_set");
assert!(resp["notCreated"]["b0"].is_object());
let props = resp["notCreated"]["b0"]["properties"]
.as_array()
.expect("properties");
assert!(props.iter().any(|p| p == "spaceId"));
}
#[tokio::test]
async fn ban_set_create_with_malformed_expiry_rejected() {
let backend = common::account_backend();
let HandlerOutput { primary: resp, .. } = handle_ban_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": {
"b0": {
"spaceId": "s1",
"userId": "u2",
"expiresAt": "later"
}
}
}),
)
.await
.expect("handle_ban_set");
assert!(resp["notCreated"]["b0"].is_object());
assert_eq!(resp["notCreated"]["b0"]["type"], "invalidProperties");
let props = resp["notCreated"]["b0"]["properties"]
.as_array()
.expect("properties");
assert!(
props.iter().any(|p| p == "expiresAt"),
"expiresAt must be listed in rejected properties"
);
}
#[tokio::test]
async fn ban_set_create_missing_user_id() {
let backend = common::account_backend();
let HandlerOutput { primary: resp, .. } = handle_ban_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": { "b0": { "spaceId": "s1" } }
}),
)
.await
.expect("handle_ban_set");
assert!(resp["notCreated"]["b0"].is_object());
let props = resp["notCreated"]["b0"]["properties"]
.as_array()
.expect("properties");
assert!(props.iter().any(|p| p == "userId"));
}
#[tokio::test]
async fn ban_set_create_success() {
let backend = common::account_backend();
let HandlerOutput { primary: resp, .. } = handle_ban_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": { "b0": { "spaceId": "s1", "userId": "u2" } }
}),
)
.await
.expect("handle_ban_set");
assert!(resp["created"]["b0"].is_object(), "should be in created");
assert_eq!(resp["created"]["b0"]["spaceId"], "s1");
assert_eq!(resp["created"]["b0"]["userId"], "u2");
assert_eq!(resp["created"]["b0"]["bannedBy"], ACCOUNT_ID);
assert_eq!(resp["notCreated"], json!(null));
}
#[tokio::test]
async fn ban_get_returns_created() {
let backend = common::account_backend();
let HandlerOutput {
primary: create_resp,
..
} = handle_ban_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": { "b0": { "spaceId": "s1", "userId": "u3", "reason": "spam" } }
}),
)
.await
.expect("create");
let ban_id = create_resp["created"]["b0"]["id"]
.as_str()
.expect("id")
.to_owned();
let HandlerOutput {
primary: get_resp, ..
} = handle_ban_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": [ban_id] }),
)
.await
.expect("get");
assert_eq!(get_resp["list"].as_array().expect("list").len(), 1);
assert_eq!(get_resp["list"][0]["spaceId"], "s1");
assert_eq!(get_resp["list"][0]["userId"], "u3");
assert_eq!(get_resp["list"][0]["reason"], "spam");
assert_eq!(get_resp["list"][0]["bannedBy"], ACCOUNT_ID);
assert_eq!(get_resp["notFound"], json!([]));
}
#[tokio::test]
async fn presence_get_empty() {
let backend = common::account_backend();
let HandlerOutput {
primary: resp,
extra_invocations: invocations,
..
} = handle_presence_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": null }),
)
.await
.expect("handle_presence_get");
assert!(invocations.is_empty());
assert_eq!(resp["accountId"], ACCOUNT_ID);
assert_eq!(resp["state"], "0");
assert_eq!(resp["list"], json!([]));
assert_eq!(resp["notFound"], json!([]));
}
#[tokio::test]
async fn presence_set_create_forbidden() {
let backend = common::account_backend();
let HandlerOutput { primary: resp, .. } = handle_presence_set(
&backend,
&(),
json!({
"accountId": ACCOUNT_ID,
"create": {
"ps0": { "presence": "online", "receiptSharing": true }
}
}),
)
.await
.expect("handle_presence_set");
assert_eq!(
resp["notCreated"]["ps0"]["type"], "forbidden",
"create must be forbidden"
);
assert_eq!(resp["created"], json!(null));
}
#[tokio::test]
async fn presence_set_destroy_forbidden() {
let backend = common::account_backend();
let HandlerOutput { primary: resp, .. } = handle_presence_set(
&backend,
&(),
json!({
"accountId": ACCOUNT_ID,
"destroy": ["ps1"]
}),
)
.await
.expect("handle_presence_set");
assert_eq!(
resp["notDestroyed"]["ps1"]["type"], "forbidden",
"destroy must be forbidden"
);
assert_eq!(resp["destroyed"], json!(null));
}
#[tokio::test]
async fn presence_set_update_readonly_id_rejected() {
let backend = common::account_backend();
backend.insert_object_for_test(
"PresenceStatus",
ACCOUNT_ID,
"ps1",
json!({ "id": "ps1", "presence": "online", "updatedAt": "2026-01-01T00:00:00Z" }),
);
let HandlerOutput { primary: resp, .. } = handle_presence_set(
&backend,
&(),
json!({
"accountId": ACCOUNT_ID,
"update": {
"ps1": { "id": "ps2", "presence": "away" }
}
}),
)
.await
.expect("handle_presence_set");
assert_eq!(
resp["notUpdated"]["ps1"]["type"], "invalidProperties",
"id must be rejected as readonly"
);
}
#[tokio::test]
async fn presence_set_update_readonly_updated_at_rejected() {
let backend = common::account_backend();
backend.insert_object_for_test(
"PresenceStatus",
ACCOUNT_ID,
"ps1",
json!({ "id": "ps1", "presence": "online", "updatedAt": "2026-01-01T00:00:00Z" }),
);
let HandlerOutput { primary: resp, .. } = handle_presence_set(
&backend,
&(),
json!({
"accountId": ACCOUNT_ID,
"update": {
"ps1": { "updatedAt": "2027-01-01T00:00:00Z", "presence": "away" }
}
}),
)
.await
.expect("handle_presence_set");
assert_eq!(
resp["notUpdated"]["ps1"]["type"], "invalidProperties",
"updatedAt must be rejected as readonly"
);
}
#[tokio::test]
async fn presence_set_update_not_found() {
let backend = common::account_backend();
let HandlerOutput { primary: resp, .. } = handle_presence_set(
&backend,
&(),
json!({
"accountId": ACCOUNT_ID,
"update": {
"ps1": { "presence": "away" }
}
}),
)
.await
.expect("handle_presence_set");
assert!(
resp["notUpdated"]["ps1"].is_object(),
"non-existent id must be in notUpdated"
);
assert_eq!(resp["updated"], json!(null));
}
#[tokio::test]
async fn presence_changes_empty() {
let backend = common::account_backend();
let HandlerOutput {
primary: resp,
extra_invocations: invocations,
..
} = handle_presence_changes(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "sinceState": "0" }),
)
.await
.expect("handle_presence_changes");
assert!(invocations.is_empty());
assert_eq!(resp["accountId"], ACCOUNT_ID);
assert_eq!(resp["oldState"], "0");
assert_eq!(resp["created"], json!([]));
assert_eq!(resp["updated"], json!([]));
assert_eq!(resp["destroyed"], json!([]));
assert_eq!(resp["hasMoreChanges"], false);
}
#[tokio::test]
async fn presence_changes_requires_since_state() {
let backend = common::account_backend();
let err = handle_presence_changes(&backend, &(), json!({ "accountId": ACCOUNT_ID }))
.await
.unwrap_err();
assert_eq!(err.error_type.to_string(), "invalidArguments");
}
#[tokio::test]
async fn space_join_requires_exactly_one_arg() {
let backend = common::account_backend();
let err = handle_space_join(&backend, &(), json!({ "accountId": ACCOUNT_ID }))
.await
.unwrap_err();
assert_eq!(err.error_type.to_string(), "invalidArguments");
}
#[tokio::test]
async fn space_join_both_args_rejected() {
let backend = common::account_backend();
let err = handle_space_join(
&backend,
&(),
json!({
"accountId": ACCOUNT_ID,
"inviteCode": "abc",
"spaceId": "s1"
}),
)
.await
.unwrap_err();
assert_eq!(err.error_type.to_string(), "invalidArguments");
}
#[tokio::test]
async fn space_join_invalid_invite_code() {
let backend = common::account_backend();
let err = handle_space_join(
&backend,
&(),
json!({
"accountId": ACCOUNT_ID,
"inviteCode": "doesnotexist"
}),
)
.await
.unwrap_err();
assert_eq!(err.error_type.to_string(), "invalidArguments");
}
#[tokio::test]
async fn space_join_public_space_not_found() {
let backend = common::account_backend();
let err = handle_space_join(
&backend,
&(),
json!({
"accountId": ACCOUNT_ID,
"spaceId": "nosuchspace"
}),
)
.await
.unwrap_err();
assert_eq!(err.error_type.to_string(), "notPermitted");
}
#[tokio::test]
async fn space_join_via_invite_code_success() {
use jmap_chat_server::handle_invite_get;
let backend = common::account_backend();
let HandlerOutput {
primary: space_resp,
..
} = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": { "s0": { "name": "Invite Space" } }
}),
&[],
)
.await
.expect("create Space");
let space_id = space_resp["created"]["s0"]["id"]
.as_str()
.expect("space id")
.to_owned();
let HandlerOutput {
primary: create_resp,
..
} = handle_invite_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": { "i0": { "spaceId": space_id } }
}),
)
.await
.expect("create SpaceInvite");
let invite_id = create_resp["created"]["i0"]["id"]
.as_str()
.expect("invite id")
.to_owned();
let code = create_resp["created"]["i0"]["code"]
.as_str()
.expect("code")
.to_owned();
clear_members(&backend, &space_id).await;
let HandlerOutput {
primary: resp,
extra_invocations: invocations,
..
} = handle_space_join(
&backend,
&(),
json!({
"accountId": ACCOUNT_ID,
"inviteCode": code
}),
)
.await
.expect("handle_space_join");
assert!(invocations.is_empty());
assert_eq!(resp["accountId"], ACCOUNT_ID);
assert_eq!(resp["spaceId"].as_str().expect("spaceId"), space_id);
let HandlerOutput {
primary: invite_list,
..
} = handle_invite_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": [invite_id] }),
)
.await
.expect("handle_invite_get");
assert_eq!(
invite_list["list"][0]["uses"], 1,
"uses must be incremented"
);
let HandlerOutput {
primary: space_list,
..
} = handle_space_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": [space_id] }),
&[],
)
.await
.expect("handle_space_get");
let members = space_list["list"][0]["members"]
.as_array()
.expect("members array");
assert_eq!(members.len(), 1, "one member should have been added");
assert_eq!(members[0]["id"], ACCOUNT_ID);
}
#[tokio::test]
async fn space_join_invite_code_from_other_account_not_found() {
use jmap_chat_server::handle_invite_get;
let backend = common::account_backend();
backend.register_account(&Id::from("a2"));
let HandlerOutput {
primary: space_resp,
..
} = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": "a1",
"create": { "s0": { "name": "Hosted in a1" } }
}),
&[],
)
.await
.expect("create Space");
let space_id = space_resp["created"]["s0"]["id"]
.as_str()
.expect("space id")
.to_owned();
let HandlerOutput {
primary: create_resp,
..
} = handle_invite_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": "a1",
"create": { "i0": { "spaceId": space_id } }
}),
)
.await
.expect("create SpaceInvite");
let invite_id = create_resp["created"]["i0"]["id"]
.as_str()
.expect("invite id")
.to_owned();
let code = create_resp["created"]["i0"]["code"]
.as_str()
.expect("code")
.to_owned();
let err = handle_space_join(
&backend,
&(),
json!({
"accountId": "a2",
"inviteCode": code
}),
)
.await
.unwrap_err();
assert_eq!(err.error_type.to_string(), "invalidArguments");
assert_eq!(err.description.as_deref(), Some("invite code not found"));
let HandlerOutput {
primary: invite_list,
..
} = handle_invite_get(
&backend,
&(),
json!({ "accountId": "a1", "ids": [invite_id] }),
)
.await
.expect("handle_invite_get");
assert_eq!(invite_list["list"][0]["uses"], 0, "uses must not change");
}
#[tokio::test]
async fn space_join_invite_at_max_uses_rejected() {
use jmap_chat_types::SpaceInvite;
use jmap_types::UTCDate;
let backend = common::account_backend();
let account_id = Id::from(ACCOUNT_ID);
let invite = |id: &Id| {
SpaceInvite::new(
id.clone(),
"exhaustedcode",
Id::from("s1"),
account_id.clone(),
1,
UTCDate::from("2026-01-01T00:00:00Z"),
None,
None,
Some(1),
)
};
backend
.create_object::<SpaceInvite, _>(&(), &account_id, "i0", invite)
.await
.expect("create SpaceInvite");
let err = handle_space_join(
&backend,
&(),
json!({
"accountId": ACCOUNT_ID,
"inviteCode": "exhaustedcode"
}),
)
.await
.unwrap_err();
assert_eq!(err.error_type.to_string(), "invalidArguments");
}
#[tokio::test]
async fn space_join_private_space_forbidden() {
let backend = common::account_backend();
let space_id = make_space_with_props(
&backend,
json!({ "name": "Private Space", "isPublic": false }),
)
.await;
let err = handle_space_join(
&backend,
&(),
json!({
"accountId": ACCOUNT_ID,
"spaceId": space_id
}),
)
.await
.unwrap_err();
assert_eq!(err.error_type.to_string(), "notPermitted");
}
#[tokio::test]
async fn space_join_public_space_success() {
let backend = common::account_backend();
let space_id = make_space_with_props(
&backend,
json!({ "name": "Public Space", "isPublic": true }),
)
.await;
clear_members(&backend, &space_id).await;
let HandlerOutput {
primary: resp,
extra_invocations: invocations,
..
} = handle_space_join(
&backend,
&(),
json!({
"accountId": ACCOUNT_ID,
"spaceId": space_id
}),
)
.await
.expect("handle_space_join");
assert!(invocations.is_empty());
assert_eq!(resp["accountId"], ACCOUNT_ID);
assert_eq!(resp["spaceId"].as_str().expect("spaceId"), space_id);
}
async fn ban_caller(backend: &MemoryBackend<()>, space_id: &str, expires_at: Option<&str>) {
let mut ban = json!({ "spaceId": space_id, "userId": ACCOUNT_ID });
if let Some(e) = expires_at {
ban["expiresAt"] = json!(e);
}
let HandlerOutput { primary: resp, .. } = handle_ban_set(
backend,
&(),
&std::collections::BTreeMap::new(),
json!({ "accountId": ACCOUNT_ID, "create": { "b0": ban } }),
)
.await
.expect("handle_ban_set");
assert!(resp["created"]["b0"].is_object(), "ban not created: {resp}");
}
async fn clear_members(backend: &MemoryBackend<()>, space_id: &str) {
let HandlerOutput {
primary: get_resp, ..
} = handle_space_get(
backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": [space_id] }),
&[],
)
.await
.expect("get");
let mut space = get_resp["list"][0].clone();
space["members"] = json!([]);
space["memberCount"] = json!(0);
backend.insert_object_for_test("Space", ACCOUNT_ID, space_id, space);
}
#[tokio::test]
async fn space_join_public_space_banned_forbidden() {
let backend = common::account_backend();
let space_id = make_space_with_props(
&backend,
json!({ "name": "Public Space", "isPublic": true }),
)
.await;
ban_caller(&backend, &space_id, None).await;
let err = handle_space_join(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "spaceId": space_id }),
)
.await
.unwrap_err();
assert_eq!(err.error_type.to_string(), "forbidden");
}
#[tokio::test]
async fn space_join_via_invite_banned_forbidden() {
let backend = common::account_backend();
let space_id = make_space_with_props(&backend, json!({ "name": "Invite Space" })).await;
let HandlerOutput {
primary: invite_resp,
..
} = handle_invite_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": { "i0": { "spaceId": space_id } }
}),
)
.await
.expect("create SpaceInvite");
let code = invite_resp["created"]["i0"]["code"]
.as_str()
.expect("code")
.to_owned();
ban_caller(&backend, &space_id, None).await;
let err = handle_space_join(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "inviteCode": code }),
)
.await
.unwrap_err();
assert_eq!(err.error_type.to_string(), "forbidden");
}
#[tokio::test]
async fn space_join_expired_ban_does_not_block() {
let backend = common::account_backend();
let space_id = make_space_with_props(
&backend,
json!({ "name": "Public Space", "isPublic": true }),
)
.await;
ban_caller(&backend, &space_id, Some("2020-01-01T00:00:00Z")).await;
clear_members(&backend, &space_id).await;
let HandlerOutput { primary: resp, .. } = handle_space_join(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "spaceId": space_id }),
)
.await
.expect("expired ban must not block Space/join");
assert_eq!(resp["spaceId"].as_str().expect("spaceId"), space_id);
}
#[tokio::test]
async fn space_join_argument_check_precedes_ban_check() {
let backend = common::account_backend();
let space_id = make_space_with_props(
&backend,
json!({ "name": "Public Space", "isPublic": true }),
)
.await;
ban_caller(&backend, &space_id, None).await;
let err = handle_space_join(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "spaceId": space_id, "inviteCode": "abc" }),
)
.await
.unwrap_err();
assert_eq!(err.error_type.to_string(), "invalidArguments");
}
#[tokio::test]
async fn message_set_create_body_too_large() {
let backend = common::account_backend();
let long_body: String = "a".repeat(100_001);
let HandlerOutput { primary: resp, .. } = handle_message_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": { "m0": { "chatId": "c1", "body": long_body } }
}),
&[],
)
.await
.expect("handle_message_set");
assert!(resp["notCreated"]["m0"].is_object());
assert_eq!(resp["notCreated"]["m0"]["type"], "tooLarge");
assert_eq!(resp["created"], json!(null));
}
#[tokio::test]
async fn emoji_set_create_name_too_long() {
use jmap_chat_server::handle_emoji_set;
let backend = common::account_backend();
let long_name: String = "a".repeat(65);
let HandlerOutput { primary: resp, .. } = handle_emoji_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": { "e0": { "name": long_name, "blobId": "b1" } }
}),
)
.await
.expect("handle_emoji_set");
assert!(resp["notCreated"]["e0"].is_object());
let props = resp["notCreated"]["e0"]["properties"]
.as_array()
.expect("props");
assert!(props.iter().any(|p| p == "name"));
assert_eq!(resp["created"], json!(null));
}
#[tokio::test]
async fn space_set_create_name_too_long() {
let backend = common::account_backend();
let long_name: String = "a".repeat(257);
let HandlerOutput { primary: resp, .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": { "s0": { "name": long_name } }
}),
&[],
)
.await
.expect("handle_space_set");
assert!(resp["notCreated"]["s0"].is_object());
let props = resp["notCreated"]["s0"]["properties"]
.as_array()
.expect("props");
assert!(props.iter().any(|p| p == "name"));
assert_eq!(resp["created"], json!(null));
}
#[tokio::test]
async fn invite_set_create_max_uses_zero() {
let backend = common::account_backend();
let HandlerOutput { primary: resp, .. } = handle_invite_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": { "i0": { "spaceId": "s1", "maxUses": 0 } }
}),
)
.await
.expect("handle_invite_set");
assert!(resp["notCreated"]["i0"].is_object());
let props = resp["notCreated"]["i0"]["properties"]
.as_array()
.expect("props");
assert!(props.iter().any(|p| p == "maxUses"));
assert_eq!(resp["created"], json!(null));
}
#[tokio::test]
async fn ban_set_create_reason_too_long() {
let backend = common::account_backend();
let long_reason: String = "a".repeat(1001);
let HandlerOutput { primary: resp, .. } = handle_ban_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": { "b0": { "spaceId": "s1", "userId": "u1", "reason": long_reason } }
}),
)
.await
.expect("handle_ban_set");
assert!(resp["notCreated"]["b0"].is_object());
let props = resp["notCreated"]["b0"]["properties"]
.as_array()
.expect("props");
assert!(props.iter().any(|p| p == "reason"));
assert_eq!(resp["created"], json!(null));
}
#[tokio::test]
async fn space_set_count_limits_default_caps_allow_normal_patch() {
let backend = common::account_backend();
let space_id = make_space(&backend, "Default Caps").await;
let HandlerOutput { primary: resp, .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": {
&space_id: {
"addCategories": [{
"id": "placeholder",
"name": "Voice",
"position": 0,
"channelIds": [],
}]
}
}
}),
&[],
)
.await
.expect("handle_space_set");
assert!(
resp["notUpdated"].is_null(),
"default 100-category cap should not reject 1 add: {:?}",
resp["notUpdated"]
);
}
#[tokio::test]
async fn space_set_count_limits_add_categories_over_cap_rejects() {
let backend = common::account_backend();
backend.set_limits_for_test(Some(
jmap_chat_server::ChatLimits::default().with_max_categories_per_space(1),
));
let space_id = make_space(&backend, "Tight Categories").await;
let HandlerOutput { primary: resp1, .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": {
&space_id: {
"addCategories": [{
"id": "placeholder",
"name": "Voice",
"position": 0,
"channelIds": [],
}]
}
}
}),
&[],
)
.await
.expect("first add");
assert!(resp1["notUpdated"].is_null(), "first add should succeed");
let HandlerOutput { primary: resp2, .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": {
&space_id: {
"addCategories": [{
"id": "placeholder",
"name": "Text",
"position": 1,
"channelIds": [],
}]
}
}
}),
&[],
)
.await
.expect("second add");
assert!(
resp2["notUpdated"][&space_id].is_object(),
"second add must be rejected"
);
assert_eq!(resp2["notUpdated"][&space_id]["type"], "overQuota");
let desc = resp2["notUpdated"][&space_id]["description"]
.as_str()
.expect("description");
assert!(
desc.contains("categories"),
"description must name the categories collection: {desc:?}"
);
assert!(
resp2["updated"].is_null(),
"the rejected target must not also appear in updated"
);
}
#[tokio::test]
async fn space_set_count_limits_atomic_reject_whole_target() {
let backend = common::account_backend();
backend.set_limits_for_test(Some(
jmap_chat_server::ChatLimits::default().with_max_categories_per_space(2),
));
let space_id = make_space(&backend, "Atomic Reject").await;
let HandlerOutput { primary: resp, .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": {
&space_id: {
"addCategories": [
{ "id": "p1", "name": "A", "position": 0, "channelIds": [] },
{ "id": "p2", "name": "B", "position": 1, "channelIds": [] },
{ "id": "p3", "name": "C", "position": 2, "channelIds": [] },
]
}
}
}),
&[],
)
.await
.expect("handle_space_set");
assert_eq!(resp["notUpdated"][&space_id]["type"], "overQuota");
let HandlerOutput {
primary: get_resp, ..
} = handle_space_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": [&space_id] }),
&[],
)
.await
.expect("handle_space_get");
let cats = get_resp["list"][0]["categories"]
.as_array()
.expect("categories array");
assert_eq!(
cats.len(),
0,
"no categories should have landed when the whole target is rejected"
);
}
#[tokio::test]
async fn space_set_count_limits_add_channels_over_cap_rejects() {
let backend = common::account_backend();
backend.set_limits_for_test(Some(
jmap_chat_server::ChatLimits::default().with_max_channels_per_space(2),
));
let space_id = make_space(&backend, "Tight Channels").await;
let HandlerOutput { primary: resp1, .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": {
&space_id: { "addChannels": [{ "name": "general" }, { "name": "random" }] }
}
}),
&[],
)
.await
.expect("first batch");
assert!(
resp1["notUpdated"].is_null(),
"first batch should succeed: {:?}",
resp1["notUpdated"]
);
let HandlerOutput { primary: resp2, .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": {
&space_id: { "addChannels": [{ "name": "off-topic" }] }
}
}),
&[],
)
.await
.expect("over-cap add");
assert_eq!(resp2["notUpdated"][&space_id]["type"], "overQuota");
let desc = resp2["notUpdated"][&space_id]["description"]
.as_str()
.expect("description");
assert!(
desc.contains("channels"),
"description must name the channels collection: {desc:?}"
);
}
#[tokio::test]
async fn space_set_count_limits_first_offender_surfaces() {
let backend = common::account_backend();
backend.set_limits_for_test(Some(
jmap_chat_server::ChatLimits::default()
.with_max_channels_per_space(0)
.with_max_categories_per_space(0),
));
let space_id = make_space(&backend, "First Offender").await;
let HandlerOutput { primary: resp, .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": {
&space_id: {
"addChannels": [{ "name": "general" }],
"addCategories": [
{ "id": "p1", "name": "Voice", "position": 0, "channelIds": [] }
]
}
}
}),
&[],
)
.await
.expect("handle_space_set");
assert_eq!(resp["notUpdated"][&space_id]["type"], "overQuota");
let desc = resp["notUpdated"][&space_id]["description"]
.as_str()
.expect("description");
assert!(
desc.contains("channels"),
"channels should be reported first (before categories): {desc:?}"
);
}
#[tokio::test]
async fn space_set_count_limits_no_add_ops_bypasses_check() {
let backend = common::account_backend();
backend.set_limits_for_test(Some(jmap_chat_server::ChatLimits::new(0, 0, 0, 0)));
let space_id = make_space(&backend, "No-Add Patch").await;
let HandlerOutput { primary: resp, .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": {
&space_id: { "removeRoles": ["nonexistent-role-id"] }
}
}),
&[],
)
.await
.expect("handle_space_set");
assert!(
resp["notUpdated"][&space_id].is_object(),
"Remove* patch should reach the backend stub: {:?}",
resp["notUpdated"]
);
assert_ne!(
resp["notUpdated"][&space_id]["type"], "overQuota",
"no-Add* patches must not be cap-rejected"
);
}
#[tokio::test]
async fn space_set_count_limits_create_only_unaffected() {
let backend = common::account_backend();
backend.set_limits_for_test(Some(jmap_chat_server::ChatLimits::new(0, 0, 0, 0)));
let HandlerOutput { primary: resp, .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": { "s0": { "name": "Free Standing" } }
}),
&[],
)
.await
.expect("handle_space_set");
assert!(
resp["created"]["s0"].is_object(),
"create should succeed regardless of cap settings: {:?}",
resp
);
}
#[tokio::test]
async fn apply_space_patch_direct_call_enforces_roles_cap() {
use jmap_chat_server::SpacePatchOp;
use jmap_chat_types::RoleCreate;
let backend = common::account_backend();
backend.set_limits_for_test(Some(jmap_chat_server::ChatLimits::new(0, 1024, 1024, 1024)));
let space_id = make_space(&backend, "Direct Caller Cap Test").await;
let role: RoleCreate = serde_json::from_value(json!({
"name": "admin",
"permissions": ["manage_space"],
"position": 10
}))
.expect("deserialize RoleCreate");
let ops = vec![SpacePatchOp::AddRole(role)];
let result = backend
.apply_space_patch(
&(),
&Id::from(ACCOUNT_ID),
&Id::from(space_id.as_str()),
ops,
)
.await;
match result {
Err(jmap_server::BackendSetError::SetError(set_err)) => {
let v = serde_json::to_value(&set_err).expect("set_err serializes");
assert_eq!(
v["type"], "overQuota",
"Direct backend call must surface overQuota when caps would be exceeded: {v:?}"
);
assert!(
v["description"]
.as_str()
.is_some_and(|s| s.contains("roles")),
"overQuota description must name the offending collection: {v:?}"
);
}
other => panic!("Direct backend call should be rejected with overQuota, got {other:?}"),
}
}
#[tokio::test]
async fn apply_space_patch_direct_call_no_add_ops_bypasses_cap_check() {
use jmap_chat_server::SpacePatchOp;
let backend = common::account_backend();
backend.set_limits_for_test(Some(jmap_chat_server::ChatLimits::new(0, 0, 0, 0)));
let space_id = make_space(&backend, "No-Add Direct").await;
let ops = vec![SpacePatchOp::RemoveRole(Id::from("nonexistent-role-id"))];
let result = backend
.apply_space_patch(
&(),
&Id::from(ACCOUNT_ID),
&Id::from(space_id.as_str()),
ops,
)
.await;
match result {
Ok(_) => {}
Err(jmap_server::BackendSetError::SetError(set_err)) => {
let v = serde_json::to_value(&set_err).expect("set_err serializes");
assert_ne!(
v["type"], "overQuota",
"no-Add* patches must NOT be cap-rejected at the backend: {v:?}"
);
}
Err(other) => panic!("unexpected backend error: {other:?}"),
}
}
#[tokio::test]
async fn space_set_overquota_description_does_not_leak_counts_or_caps() {
let backend = common::account_backend();
backend.set_limits_for_test(Some(
jmap_chat_server::ChatLimits::default().with_max_categories_per_space(1),
));
let space_id = make_space(&backend, "Leak Canary").await;
let _ = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": {
&space_id: {
"addCategories": [
{ "id": "p1", "name": "First", "position": 0, "channelIds": [] }
]
}
}
}),
&[],
)
.await
.expect("first add");
let HandlerOutput { primary: resp, .. } = handle_space_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": {
&space_id: {
"addCategories": [
{ "id": "p2", "name": "Second", "position": 1, "channelIds": [] }
]
}
}
}),
&[],
)
.await
.expect("second add");
assert_eq!(resp["notUpdated"][&space_id]["type"], "overQuota");
let desc = resp["notUpdated"][&space_id]["description"]
.as_str()
.expect("description");
assert!(
!desc.chars().any(|c| c.is_ascii_digit()),
"overQuota description must not contain ASCII digits (would leak count/cap): {desc:?}"
);
for forbidden in &["existing", "cap", "would have", "adding"] {
assert!(
!desc.contains(forbidden),
"overQuota description must not contain back-channel token {forbidden:?}: {desc:?}"
);
}
assert!(
desc.contains("categories"),
"overQuota description must still name the offending aggregate: {desc:?}"
);
}
#[tokio::test]
async fn apply_space_patch_direct_call_overquota_description_does_not_leak_counts_or_caps() {
use jmap_chat_server::SpacePatchOp;
let backend = common::account_backend();
backend.set_limits_for_test(Some(jmap_chat_server::ChatLimits::new(0, 0, 0, 0)));
let space_id = make_space(&backend, "Direct Leak Canary").await;
let role_to_add = serde_json::from_value::<jmap_chat_types::RoleCreate>(json!({
"name": "Moderator",
"permissions": [],
"position": 1,
}))
.expect("RoleCreate deserialize");
let ops = vec![SpacePatchOp::AddRole(role_to_add)];
let result = backend
.apply_space_patch(
&(),
&Id::from(ACCOUNT_ID),
&Id::from(space_id.as_str()),
ops,
)
.await;
match result {
Err(jmap_server::BackendSetError::SetError(set_err)) => {
let v = serde_json::to_value(&set_err).expect("set_err serializes");
assert_eq!(v["type"], "overQuota");
let desc = v["description"].as_str().expect("description");
assert!(
!desc.chars().any(|c| c.is_ascii_digit()),
"overQuota description must not contain ASCII digits: {desc:?}"
);
for forbidden in &["existing", "cap", "would have", "adding"] {
assert!(
!desc.contains(forbidden),
"overQuota description must not contain back-channel token {forbidden:?}: {desc:?}"
);
}
assert!(
desc.contains("roles"),
"overQuota description must still name the offending aggregate: {desc:?}"
);
}
other => panic!("expected overQuota SetError, got {other:?}"),
}
}
fn seed_message_for_mention_test(
backend: &MemoryBackend<()>,
msg_id: &str,
mentions: serde_json::Value,
broadcast_mentions: serde_json::Value,
) {
backend.insert_object_for_test(
"Chat",
ACCOUNT_ID,
"c-mention",
json!({
"id": "c-mention",
"kind": "dm",
"name": "mention-test",
"receivedAt": "2024-01-01T00:00:00Z"
}),
);
backend.insert_object_for_test(
"Message",
ACCOUNT_ID,
msg_id,
json!({
"id": msg_id,
"senderMsgId": format!("s-{msg_id}"),
"senderId": "other-user",
"chatId": "c-mention",
"body": "hello",
"bodyType": "text/plain",
"attachments": [],
"mentions": mentions,
"broadcastMentions": broadcast_mentions,
"actions": [],
"reactions": {},
"sentAt": "2024-01-01T00:00:00Z",
"receivedAt": "2024-01-01T00:00:01Z",
"deliveryState": "delivered"
}),
);
}
#[tokio::test]
async fn query_has_mention_matches_broadcast_everyone() {
let backend = common::account_backend();
seed_message_for_mention_test(
&backend,
"m-everyone",
json!([]),
json!([{"scope": "everyone"}]),
);
let HandlerOutput { primary: resp, .. } = handle_message_query(
&backend,
&(),
json!({
"accountId": ACCOUNT_ID,
"filter": { "hasMention": true },
"calculateTotal": true
}),
&[],
)
.await
.expect("query");
let ids = resp["ids"].as_array().expect("ids");
assert_eq!(ids.len(), 1, "broadcast everyone must match hasMention");
assert_eq!(ids[0], "m-everyone");
assert_eq!(resp["total"], json!(1u64));
}
#[tokio::test]
async fn query_has_mention_matches_broadcast_here() {
let backend = common::account_backend();
seed_message_for_mention_test(&backend, "m-here", json!([]), json!([{"scope": "here"}]));
let HandlerOutput { primary: resp, .. } = handle_message_query(
&backend,
&(),
json!({
"accountId": ACCOUNT_ID,
"filter": { "hasMention": true },
"calculateTotal": true
}),
&[],
)
.await
.expect("query");
let ids = resp["ids"].as_array().expect("ids");
assert_eq!(ids.len(), 1, "broadcast here must match hasMention");
assert_eq!(ids[0], "m-here");
}
#[tokio::test]
async fn query_has_mention_matches_broadcast_admins() {
let backend = common::account_backend();
seed_message_for_mention_test(
&backend,
"m-admins",
json!([]),
json!([{"scope": "admins"}]),
);
backend.insert_object_for_test(
"Chat",
ACCOUNT_ID,
"c-mention",
json!({
"id": "c-mention",
"kind": "group",
"name": "mention-test",
"members": [{ "id": ACCOUNT_ID, "role": "admin", "joinedAt": "2024-01-01T00:00:00Z" }],
"receivedAt": "2024-01-01T00:00:00Z"
}),
);
let HandlerOutput { primary: resp, .. } = handle_message_query(
&backend,
&(),
json!({
"accountId": ACCOUNT_ID,
"filter": { "hasMention": true },
"calculateTotal": true
}),
&[],
)
.await
.expect("query");
let ids = resp["ids"].as_array().expect("ids");
assert_eq!(ids.len(), 1, "broadcast admins must match hasMention");
assert_eq!(ids[0], "m-admins");
}
#[tokio::test]
async fn query_has_mention_no_broadcast_no_mention() {
let backend = common::account_backend();
seed_message_for_mention_test(&backend, "m-none", json!([]), json!([]));
let HandlerOutput { primary: resp, .. } = handle_message_query(
&backend,
&(),
json!({
"accountId": ACCOUNT_ID,
"filter": { "hasMention": true },
"calculateTotal": true
}),
&[],
)
.await
.expect("query");
let ids = resp["ids"].as_array().expect("ids");
assert_eq!(ids.len(), 0, "no mentions at all must not match hasMention");
assert_eq!(resp["total"], json!(0u64));
}
#[tokio::test]
async fn query_has_mention_unknown_scope_no_match() {
let backend = common::account_backend();
seed_message_for_mention_test(
&backend,
"m-unknown",
json!([]),
json!([{"scope": "channel"}]),
);
let HandlerOutput { primary: resp, .. } = handle_message_query(
&backend,
&(),
json!({
"accountId": ACCOUNT_ID,
"filter": { "hasMention": true },
"calculateTotal": true
}),
&[],
)
.await
.expect("query");
let ids = resp["ids"].as_array().expect("ids");
assert_eq!(
ids.len(),
0,
"unknown scope 'channel' must not match hasMention"
);
assert_eq!(resp["total"], json!(0u64));
}