mod common;
use common::{ACCOUNT_ID, MemoryBackend};
use jmap_chat_server::{handle_chat_get, handle_chat_set};
use jmap_server::HandlerOutput;
use jmap_types::Id;
use serde_json::{Value, json};
const CHAT: &str = "chat1";
const CLOSED_AT: &str = "2026-02-01T00:00:00Z";
fn seed_closed_group(backend: &MemoryBackend<()>) {
backend.register_account(&Id::from(ACCOUNT_ID));
backend.insert_object_for_test(
"Chat",
ACCOUNT_ID,
CHAT,
json!({
"id": CHAT,
"kind": "group",
"createdAt": "2026-01-01T00:00:00Z",
"unreadCount": 0,
"closedAt": CLOSED_AT,
"activeCallId": "call1",
"activeCallAccountId": "shared1",
}),
);
}
async fn update(backend: &MemoryBackend<()>, patch: Value) -> Value {
let HandlerOutput { primary: resp, .. } = handle_chat_set(
backend,
&(),
&std::collections::BTreeMap::new(),
json!({ "accountId": ACCOUNT_ID, "update": { CHAT: patch } }),
&[],
)
.await
.expect("Chat/set");
resp
}
async fn stored(backend: &MemoryBackend<()>) -> Value {
let HandlerOutput { primary: resp, .. } = handle_chat_get(
backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": [CHAT] }),
&[],
)
.await
.expect("Chat/get");
resp["list"][0].clone()
}
#[tokio::test]
async fn chat_set_rejects_server_set_closed_at_and_active_call_id() {
let backend = MemoryBackend::<()>::default();
seed_closed_group(&backend);
for (key, value) in [
("closedAt", Value::Null),
("closedAt", json!("2026-03-01T00:00:00Z")),
("activeCallId", Value::Null),
("activeCallId", json!("call2")),
("activeCallAccountId", Value::Null),
("activeCallAccountId", json!("shared2")),
] {
let resp = update(&backend, json!({ key: value })).await;
assert_eq!(
resp["notUpdated"][CHAT],
json!({ "type": "invalidProperties", "properties": [key] }),
"{key}: {value}: {resp}"
);
let chat = stored(&backend).await;
assert_eq!(chat["closedAt"], CLOSED_AT, "{key}: {value}: {chat}");
assert_eq!(chat["activeCallId"], "call1", "{key}: {value}: {chat}");
assert_eq!(
chat["activeCallAccountId"], "shared1",
"{key}: {value}: {chat}"
);
}
}
#[tokio::test]
async fn chat_set_rejects_server_set_channel_fields() {
let backend = MemoryBackend::<()>::default();
seed_closed_group(&backend);
let before = stored(&backend).await;
for (key, value) in [
("categoryId", json!("cat1")),
("position", json!(3)),
("topic", json!("New topic")),
("slowModeSeconds", json!(30)),
(
"permissionOverrides",
json!([{ "targetId": "r1", "targetType": "role", "allow": [], "deny": [] }]),
),
] {
let resp = update(&backend, json!({ key: value })).await;
assert_eq!(
resp["notUpdated"][CHAT],
json!({ "type": "invalidProperties", "properties": [key] }),
"{key}: {resp}"
);
assert_eq!(stored(&backend).await, before, "{key}: Chat unchanged");
}
}
#[tokio::test]
async fn chat_set_admits_identical_server_set_values() {
let backend = MemoryBackend::<()>::default();
seed_closed_group(&backend);
let before = stored(&backend).await;
let same = json!({
"id": CHAT,
"kind": "group",
"createdAt": "2026-01-01T00:00:00Z",
"closedAt": CLOSED_AT,
"activeCallId": "call1",
"activeCallAccountId": "shared1",
});
let resp = update(&backend, same.clone()).await;
assert_eq!(resp["updated"], json!({ CHAT: null }), "{resp}");
assert_eq!(resp["notUpdated"], Value::Null, "{resp}");
assert_eq!(resp["newState"], resp["oldState"], "{resp}");
assert_eq!(stored(&backend).await, before);
let mut with_change = same.clone();
with_change["muted"] = json!(true);
let resp = update(&backend, with_change).await;
assert!(resp["updated"].get(CHAT).is_some(), "{resp}");
assert_eq!(stored(&backend).await["muted"], json!(true));
let mut changed = same.clone();
changed["activeCallId"] = json!("call2");
let resp = update(&backend, changed).await;
assert_eq!(
resp["notUpdated"][CHAT],
json!({ "type": "invalidProperties", "properties": ["activeCallId"] }),
"{resp}"
);
let mut shared = same;
shared["name"] = json!("Renamed");
let resp = update(&backend, shared).await;
assert_eq!(resp["notUpdated"][CHAT]["type"], "forbidden", "{resp}");
}
#[tokio::test]
async fn forbidden_update_with_read_only_change_is_forbidden() {
let backend = MemoryBackend::<()>::default();
seed_closed_group(&backend);
let resp = update(
&backend,
json!({ "name": "Renamed", "activeCallId": "call2" }),
)
.await;
assert_eq!(resp["notUpdated"][CHAT]["type"], "forbidden", "{resp}");
}
#[tokio::test]
async fn read_only_change_of_missing_chat_is_not_found() {
let backend = MemoryBackend::<()>::default();
seed_closed_group(&backend);
let HandlerOutput { primary: resp, .. } = handle_chat_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({ "accountId": ACCOUNT_ID, "update": { "nope": { "activeCallId": "call2" } } }),
&[],
)
.await
.expect("Chat/set");
assert_eq!(resp["notUpdated"]["nope"]["type"], "notFound", "{resp}");
}