mod common;
use common::{ACCOUNT_ID, MemoryBackend, TrackingBackend};
use jmap_chat_server::handle_chat_set;
use jmap_chat_server::message::{StoreOutcome, handle_message_set, store_server_message};
use jmap_chat_types::{DeliveryState, Message};
use jmap_server::HandlerOutput;
use jmap_types::{Id, UTCDate};
use serde_json::{Value, json};
const GROUP: &str = "g1";
const OWN_MSG: &str = "m1";
fn seed(backend: &MemoryBackend<()>) {
backend.register_account(&Id::from(ACCOUNT_ID));
backend.insert_object_for_test(
"Chat",
ACCOUNT_ID,
GROUP,
json!({
"id": GROUP,
"kind": "group",
"name": "G",
"createdAt": "2026-01-01T00:00:00Z",
"unreadCount": 0,
"pinnedMessageIds": [],
"members": [{ "id": ACCOUNT_ID, "role": "admin", "joinedAt": "2026-01-01T00:00:00Z" }],
}),
);
backend.insert_object_for_test(
"Message",
ACCOUNT_ID,
OWN_MSG,
json!({
"id": OWN_MSG,
"senderMsgId": "01J00000000000000000000000",
"senderId": ACCOUNT_ID,
"chatId": GROUP,
"body": "hello",
"bodyType": "text/plain",
"reactions": {},
"attachments": [],
"sentAt": "2026-01-01T00:00:00Z",
"receivedAt": "2026-01-01T00:00:00Z",
"deliveryState": "delivered",
}),
);
}
async fn chat_set<B: jmap_chat_server::ChatBackend<CallerCtx = ()>>(
backend: &B,
args: Value,
) -> Value {
let mut args = args;
args["accountId"] = json!(ACCOUNT_ID);
let HandlerOutput { primary, .. } =
handle_chat_set(backend, &(), &std::collections::BTreeMap::new(), args, &[])
.await
.expect("Chat/set");
primary
}
fn properties(err: &Value) -> Vec<String> {
let mut props: Vec<String> = err["properties"]
.as_array()
.unwrap_or_else(|| panic!("no properties: {err}"))
.iter()
.map(|p| p.as_str().expect("string").to_owned())
.collect();
props.sort();
props
}
#[tokio::test]
async fn destroy_read_failure_is_per_id_server_fail() {
let backend = TrackingBackend::with_get_objects_failing("Chat");
seed(backend.inner());
let resp = chat_set(
&backend,
json!({
"create": { "c1": { "kind": "group", "name": "New", "memberIds": [] } },
"destroy": [GROUP],
}),
)
.await;
assert!(resp["created"]["c1"]["id"].is_string(), "{resp}");
assert_eq!(resp["notDestroyed"][GROUP]["type"], "serverFail", "{resp}");
assert!(
!resp["destroyed"]
.as_array()
.is_some_and(|d| d.contains(&json!(GROUP))),
"{resp}"
);
let (chats, _) = jmap_server::JmapReads::get_objects::<jmap_chat_types::Chat>(
backend.inner(),
&(),
&Id::from(ACCOUNT_ID),
Some(&[Id::from(GROUP)]),
None,
)
.await
.expect("read");
assert_eq!(chats.len(), 1, "the Chat must survive");
}
#[tokio::test]
async fn direct_create_rejects_group_only_properties() {
let backend = MemoryBackend::<()>::default();
backend.register_account(&Id::from(ACCOUNT_ID));
let resp = chat_set(
&backend,
json!({ "create": { "d": {
"kind": "direct",
"contactId": "contact-1",
"name": "N",
"description": "D",
"avatarBlobId": "blob-1",
} } }),
)
.await;
let err = &resp["notCreated"]["d"];
assert_eq!(err["type"], "invalidProperties", "{resp}");
assert_eq!(properties(err), ["avatarBlobId", "description", "name"]);
assert!(resp["created"].get("d").is_none(), "{resp}");
}
#[tokio::test]
async fn group_create_rejects_direct_and_channel_properties() {
let backend = MemoryBackend::<()>::default();
backend.register_account(&Id::from(ACCOUNT_ID));
let resp = chat_set(
&backend,
json!({ "create": { "g": {
"kind": "group",
"name": "G",
"memberIds": [],
"contactId": "contact-1",
"spaceId": "space-1",
} } }),
)
.await;
let err = &resp["notCreated"]["g"];
assert_eq!(err["type"], "invalidProperties", "{resp}");
assert_eq!(properties(err), ["contactId", "spaceId"]);
}
#[tokio::test]
async fn group_create_keeps_group_properties() {
let backend = MemoryBackend::<()>::default();
backend.register_account(&Id::from(ACCOUNT_ID));
let resp = chat_set(
&backend,
json!({ "create": { "g": {
"kind": "group",
"name": "G",
"memberIds": [],
"description": "D",
"avatarBlobId": "blob-1",
} } }),
)
.await;
let created = &resp["created"]["g"];
assert_eq!(created["description"], "D", "{resp}");
assert_eq!(created["avatarBlobId"], "blob-1", "{resp}");
}
#[tokio::test]
async fn store_server_message_builds_with_backend_id() {
let backend = TrackingBackend::new();
seed(backend.inner());
let at = UTCDate::from("2026-01-02T00:00:00Z");
let smid = Id::from("01J00000000000000000000009");
let build = |id: &Id| {
Message::new(
id.clone(),
smid.clone(),
Id::from("contact-hub"),
Id::from(GROUP),
"AAEC".to_owned(),
"application/mimi-fanout".to_owned(),
at.clone(),
at.clone(),
DeliveryState::Delivered,
)
};
let outcome = store_server_message(
&backend,
&(),
&Id::from(ACCOUNT_ID),
&Id::from(GROUP),
&smid,
build,
)
.await
.expect("store");
let StoreOutcome::Stored(id) = outcome else {
panic!("first store must not be a duplicate: {outcome:?}");
};
let ids = backend.create_input_ids();
assert_eq!(ids.first(), Some(&json!(id.as_ref())), "{ids:?}");
}
#[tokio::test]
async fn chat_update_reads_stored_chat_once() {
let backend = TrackingBackend::new();
seed(backend.inner());
let resp = chat_set(
&backend,
json!({ "update": { GROUP: {
"name": "Renamed",
"addMembers": [{ "id": "contact-2" }],
"pinnedMessageIds": [OWN_MSG],
} } }),
)
.await;
assert!(resp["updated"].get(GROUP).is_some(), "{resp}");
assert_eq!(backend.get_objects_call_count("Chat"), 1);
}
#[tokio::test]
async fn message_update_reads_stored_objects_once() {
let backend = TrackingBackend::new();
seed(backend.inner());
let HandlerOutput { primary: resp, .. } = handle_message_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": { OWN_MSG: {
"body": "edited",
"readAt": "2026-01-03T00:00:00Z",
"reactions/r1": { "emoji": "+1" },
} },
}),
&[],
)
.await
.expect("Message/set");
assert!(resp["updated"].get(OWN_MSG).is_some(), "{resp}");
assert_eq!(backend.get_objects_call_count("Message"), 1);
assert_eq!(backend.get_objects_call_count("Chat"), 1);
}