mod common;
use common::{ACCOUNT_ID, MemoryBackend};
use jmap_chat_server::message::{
handle_message_changes, handle_message_get, handle_message_query, handle_message_set,
};
use jmap_chat_server::{ChatLimits, handle_chat_set, handle_position_set};
use jmap_server::HandlerOutput;
use serde_json::{Value, json};
const ROOT: &str = "01J0000000000000000000000A";
const A: &str = "01J0000000000000000000000B";
const B: &str = "01J0000000000000000000000C";
const C: &str = "01J0000000000000000000000D";
const OTHER_CHAT_MSG: &str = "01J0000000000000000000000E";
const OWN_REPLY: &str = "01J0000000000000000000000F";
const OTHER_SENDER: &str = "contact-bob";
async fn create_group(backend: &MemoryBackend) -> String {
let HandlerOutput { primary: resp, .. } = handle_chat_set(
backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": { "g": { "kind": "group", "name": "G", "memberIds": ["contact-bob"] } }
}),
&[],
)
.await
.expect("Chat/set");
resp["created"]["g"]["id"]
.as_str()
.unwrap_or_else(|| panic!("group not created: {resp}"))
.to_owned()
}
fn seed_message(
backend: &MemoryBackend,
id: &str,
chat_id: &str,
reply_to: Option<&str>,
root: Option<&str>,
) {
seed_message_from(backend, OTHER_SENDER, id, chat_id, reply_to, root);
}
fn seed_message_from(
backend: &MemoryBackend,
sender_id: &str,
id: &str,
chat_id: &str,
reply_to: Option<&str>,
root: Option<&str>,
) {
let mut msg = json!({
"id": id,
"senderMsgId": id,
"senderId": sender_id,
"chatId": chat_id,
"body": "x",
"bodyType": "text/plain",
"attachments": [],
"sentAt": "2024-01-01T00:00:00Z",
"receivedAt": "2024-01-01T00:00:00Z",
"deliveryState": "delivered",
});
if let Some(r) = reply_to {
msg["replyTo"] = json!(r);
}
if let Some(r) = root {
msg["threadRootId"] = json!(r);
}
backend.insert_object_for_test("Message", ACCOUNT_ID, id, msg);
}
async fn fixture(backend: &MemoryBackend) -> (String, String) {
let chat = create_group(backend).await;
let other = create_group(backend).await;
seed_message(backend, ROOT, &chat, None, None);
seed_message(backend, A, &chat, Some(ROOT), Some(ROOT));
seed_message(backend, B, &chat, Some(A), Some(ROOT));
seed_message(backend, C, &chat, Some(ROOT), Some(ROOT));
seed_message(backend, OTHER_CHAT_MSG, &other, None, None);
backend.insert_object_for_test(
"ReadPosition",
ACCOUNT_ID,
"rp1",
json!({
"id": "rp1",
"chatId": chat,
"lastReadMessageId": A,
"lastReadAt": "2024-01-01T00:00:00Z",
}),
);
(chat, other)
}
fn threads_on(backend: &MemoryBackend) {
backend.set_limits_for_test(Some(ChatLimits::default().with_supports_threads(true)));
}
async fn create(backend: &MemoryBackend, obj: Value) -> Value {
let HandlerOutput { primary: resp, .. } = handle_message_set(
backend,
&(),
&std::collections::BTreeMap::new(),
json!({ "accountId": ACCOUNT_ID, "create": { "m": obj } }),
&[],
)
.await
.expect("Message/set");
resp
}
fn reply(chat: &str, reply_to: &str, root: Option<&str>) -> Value {
let mut obj = json!({
"chatId": chat,
"body": "re",
"bodyType": "text/plain",
"sentAt": "2024-01-01T00:00:00Z",
"replyTo": reply_to,
});
if let Some(r) = root {
obj["threadRootId"] = json!(r);
}
obj
}
async fn get(backend: &MemoryBackend, ids: &[&str]) -> Vec<Value> {
let HandlerOutput { primary: resp, .. } = handle_message_get(
backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": ids }),
&[],
)
.await
.expect("Message/get");
resp["list"].as_array().expect("list").clone()
}
fn by_id<'a>(list: &'a [Value], id: &str) -> &'a Value {
list.iter()
.find(|m| m["id"] == id)
.unwrap_or_else(|| panic!("{id} missing from {list:?}"))
}
#[tokio::test]
async fn cross_chat_reply_to_rejected() {
let backend = common::account_backend();
let (chat, _) = fixture(&backend).await;
let resp = create(&backend, reply(&chat, OTHER_CHAT_MSG, None)).await;
assert_eq!(
resp["notCreated"]["m"]["type"], "invalidProperties",
"{resp}"
);
assert_eq!(
resp["notCreated"]["m"]["properties"],
json!(["replyTo"]),
"{resp}"
);
}
#[tokio::test]
async fn unknown_reply_to_rejected() {
let backend = common::account_backend();
let (chat, _) = fixture(&backend).await;
let resp = create(&backend, reply(&chat, "01J00000000000000000000ZZZ", None)).await;
assert_eq!(
resp["notCreated"]["m"]["properties"],
json!(["replyTo"]),
"{resp}"
);
}
#[tokio::test]
async fn invalid_thread_root_id_rejected() {
let backend = common::account_backend();
let (chat, _) = fixture(&backend).await;
let no_reply = json!({
"chatId": chat,
"body": "x",
"bodyType": "text/plain",
"sentAt": "2024-01-01T00:00:00Z",
"threadRootId": ROOT,
});
let cases = [
no_reply,
reply(&chat, ROOT, Some(A)),
reply(&chat, A, Some(A)),
];
for obj in cases {
let resp = create(&backend, obj.clone()).await;
assert_eq!(
resp["notCreated"]["m"]["type"], "invalidProperties",
"{obj} -> {resp}"
);
assert_eq!(
resp["notCreated"]["m"]["properties"],
json!(["threadRootId"]),
"{obj} -> {resp}"
);
}
}
#[tokio::test]
async fn thread_root_id_accepted_or_filled_in() {
let backend = common::account_backend();
let (chat, _) = fixture(&backend).await;
let cases = [
(reply(&chat, ROOT, Some(ROOT)), ROOT),
(reply(&chat, B, Some(ROOT)), ROOT),
(reply(&chat, ROOT, None), ROOT),
(reply(&chat, B, None), ROOT),
];
for (obj, root) in cases {
let resp = create(&backend, obj.clone()).await;
assert_eq!(
resp["created"]["m"]["threadRootId"], root,
"{obj} -> {resp}"
);
}
}
#[tokio::test]
async fn reply_counts_match_fixture() {
let backend = common::account_backend();
let _ = fixture(&backend).await;
threads_on(&backend);
let list = get(&backend, &[ROOT, A, B, C]).await;
let root = by_id(&list, ROOT);
assert_eq!(root["replyCount"], 2, "{root}");
assert_eq!(root["unreadReplyCount"], 1, "{root}");
let a = by_id(&list, A);
assert_eq!(a["replyCount"], 1, "{a}");
assert!(a.get("unreadReplyCount").is_none(), "{a}");
for id in [B, C] {
let m = by_id(&list, id);
assert_eq!(m["replyCount"], 0, "{m}");
assert!(m.get("unreadReplyCount").is_none(), "{m}");
}
}
#[tokio::test]
async fn unread_reply_count_without_read_position() {
let backend = common::account_backend();
let (chat, _) = fixture(&backend).await;
backend.insert_object_for_test(
"ReadPosition",
ACCOUNT_ID,
"rp1",
json!({ "id": "rp1", "chatId": chat }),
);
threads_on(&backend);
let list = get(&backend, &[ROOT]).await;
assert_eq!(list[0]["unreadReplyCount"], 2, "{list:?}");
}
#[tokio::test]
async fn counts_absent_without_supports_threads() {
let backend = common::account_backend();
let _ = fixture(&backend).await;
let list = get(&backend, &[ROOT, A]).await;
for m in &list {
assert!(m.get("replyCount").is_none(), "{m}");
assert!(m.get("unreadReplyCount").is_none(), "{m}");
}
}
#[tokio::test]
async fn thread_root_id_filter_with_supports_threads() {
let backend = common::account_backend();
let (chat, _) = fixture(&backend).await;
threads_on(&backend);
let HandlerOutput { primary: resp, .. } = handle_message_query(
&backend,
&(),
json!({
"accountId": ACCOUNT_ID,
"filter": { "chatId": chat, "threadRootId": ROOT },
}),
&[],
)
.await
.expect("Message/query");
let mut ids: Vec<&str> = resp["ids"]
.as_array()
.expect("ids")
.iter()
.map(|v| v.as_str().expect("id"))
.collect();
ids.sort_unstable();
assert_eq!(ids, [A, B, C], "{resp}");
}
async fn message_state(backend: &MemoryBackend) -> String {
let HandlerOutput { primary: resp, .. } = handle_message_get(
backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": [] }),
&[],
)
.await
.expect("Message/get");
resp["state"].as_str().expect("state").to_owned()
}
async fn message_changes(backend: &MemoryBackend, since: &str) -> Value {
let HandlerOutput { primary: resp, .. } = handle_message_changes(
backend,
&(),
json!({ "accountId": ACCOUNT_ID, "sinceState": since }),
&[],
)
.await
.expect("Message/changes");
resp
}
#[tokio::test]
async fn reply_create_lists_parent_updated() {
let backend = common::account_backend();
let (chat, _) = fixture(&backend).await;
threads_on(&backend);
let since = message_state(&backend).await;
let resp = create(&backend, reply(&chat, A, None)).await;
let new_id = resp["created"]["m"]["id"].clone();
let changes = message_changes(&backend, &since).await;
assert_eq!(changes["created"], json!([new_id]), "{changes}");
assert_eq!(changes["updated"], json!([A]), "{changes}");
}
#[tokio::test]
async fn reply_destroy_lists_parent_updated() {
let backend = common::account_backend();
let _ = fixture(&backend).await;
threads_on(&backend);
let since = message_state(&backend).await;
let HandlerOutput { primary: resp, .. } = handle_message_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({ "accountId": ACCOUNT_ID, "destroy": [B] }),
&[],
)
.await
.expect("Message/set");
assert_eq!(resp["destroyed"], json!([B]), "{resp}");
let changes = message_changes(&backend, &since).await;
assert_eq!(changes["destroyed"], json!([B]), "{changes}");
assert_eq!(changes["updated"], json!([A]), "{changes}");
}
#[tokio::test]
async fn read_position_update_lists_thread_root_updated() {
let backend = common::account_backend();
let _ = fixture(&backend).await;
threads_on(&backend);
let since = message_state(&backend).await;
let HandlerOutput { primary: resp, .. } = handle_position_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": { "rp1": { "lastReadMessageId": C } },
}),
)
.await
.expect("ReadPosition/set");
assert!(resp["updated"].get("rp1").is_some(), "{resp}");
let changes = message_changes(&backend, &since).await;
assert_eq!(changes["updated"], json!([ROOT]), "{changes}");
assert_eq!(changes["created"], json!([]), "{changes}");
assert_eq!(changes["destroyed"], json!([]), "{changes}");
}
#[tokio::test]
async fn unread_reply_count_excludes_owner_replies() {
let backend = common::account_backend();
let (chat, _) = fixture(&backend).await;
seed_message_from(
&backend,
ACCOUNT_ID,
OWN_REPLY,
&chat,
Some(ROOT),
Some(ROOT),
);
threads_on(&backend);
let list = get(&backend, &[ROOT]).await;
assert_eq!(list[0]["replyCount"], 3, "{list:?}");
assert_eq!(list[0]["unreadReplyCount"], 1, "{list:?}");
}
#[tokio::test]
async fn unread_reply_count_excludes_owner_replies_without_read_position() {
let backend = common::account_backend();
let (chat, _) = fixture(&backend).await;
seed_message_from(
&backend,
ACCOUNT_ID,
OWN_REPLY,
&chat,
Some(ROOT),
Some(ROOT),
);
backend.insert_object_for_test(
"ReadPosition",
ACCOUNT_ID,
"rp1",
json!({ "id": "rp1", "chatId": chat }),
);
threads_on(&backend);
let list = get(&backend, &[ROOT]).await;
assert_eq!(list[0]["unreadReplyCount"], 2, "{list:?}");
}
#[tokio::test]
async fn read_past_owner_reply_leaves_root_unchanged() {
let backend = common::account_backend();
let (chat, _) = fixture(&backend).await;
seed_message_from(
&backend,
ACCOUNT_ID,
OWN_REPLY,
&chat,
Some(ROOT),
Some(ROOT),
);
threads_on(&backend);
for last_read in [C, OWN_REPLY] {
let since = message_state(&backend).await;
let HandlerOutput { primary: resp, .. } = handle_position_set(
&backend,
&(),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": { "rp1": { "lastReadMessageId": last_read } },
}),
)
.await
.expect("ReadPosition/set");
assert!(resp["updated"].get("rp1").is_some(), "{resp}");
let changes = message_changes(&backend, &since).await;
let expected = if last_read == C {
json!([ROOT])
} else {
json!([])
};
assert_eq!(changes["updated"], expected, "{last_read}: {changes}");
}
let list = get(&backend, &[ROOT]).await;
assert_eq!(list[0]["unreadReplyCount"], 0, "{list:?}");
}