mod common;
use common::{ACCOUNT_ID, MemoryBackend};
use jmap_chat_server::message::{
StoreOutcome, find_message_by_sender_msg_id, handle_message_get, store_server_message,
};
use jmap_chat_server::{handle_chat_get, handle_position_get};
use jmap_chat_types::{DeliveryState, Message};
use jmap_server::HandlerOutput;
use jmap_types::{Id, UTCDate};
use serde_json::{Value, json};
const FANOUT: &str = "application/mimi-fanout";
const HUB: &str = "contact-hub";
const SMID: &str = "01J00000000000000000000001";
fn seed_group(backend: &MemoryBackend<()>, id: &str) {
backend.insert_object_for_test(
"Chat",
ACCOUNT_ID,
id,
json!({
"id": id,
"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" }],
}),
);
}
fn setup() -> MemoryBackend<()> {
let backend = MemoryBackend::<()>::default();
backend.register_account(&Id::from(ACCOUNT_ID));
seed_group(&backend, "g");
seed_group(&backend, "h");
backend
}
fn fanout(
chat_id: &str,
sender_msg_id: &str,
body: &str,
) -> impl FnOnce(&Id) -> Message + Send + use<> {
let (chat_id, sender_msg_id, body) = (
chat_id.to_owned(),
sender_msg_id.to_owned(),
body.to_owned(),
);
move |id: &Id| {
Message::new(
id.clone(),
Id::from(sender_msg_id),
Id::from(HUB),
Id::from(chat_id),
body,
FANOUT,
UTCDate::from("2026-01-02T00:00:00Z"),
UTCDate::from("2026-01-02T00:00:01Z"),
DeliveryState::Delivered,
)
}
}
async fn messages(backend: &MemoryBackend<()>) -> Value {
let HandlerOutput { primary, .. } = handle_message_get(
backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": null }),
&[],
)
.await
.expect("Message/get");
primary
}
async fn positions(backend: &MemoryBackend<()>) -> Vec<Value> {
let HandlerOutput { primary, .. } = handle_position_get(
backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": null }),
)
.await
.expect("ReadPosition/get");
primary["list"].as_array().expect("list").clone()
}
async fn store(
backend: &MemoryBackend<()>,
chat_id: &str,
sender_msg_id: &str,
body: &str,
) -> StoreOutcome {
store_server_message(
backend,
&(),
&Id::from(ACCOUNT_ID),
&Id::from(chat_id),
&Id::from(sender_msg_id),
fanout(chat_id, sender_msg_id, body),
)
.await
.expect("store_server_message")
}
#[tokio::test]
async fn stored_keys_are_the_checked_keys() {
let backend = setup();
let StoreOutcome::Stored(_) = store_server_message(
&backend,
&(),
&Id::from(ACCOUNT_ID),
&Id::from("g"),
&Id::from(SMID),
fanout("other-chat", "other-smid", "AAEC"),
)
.await
.expect("store_server_message") else {
panic!("first store must not be a duplicate");
};
let list = messages(&backend).await["list"].clone();
assert_eq!(list[0]["chatId"], json!("g"), "{list}");
assert_eq!(list[0]["senderMsgId"], json!(SMID), "{list}");
assert!(
matches!(
store(&backend, "g", SMID, "AAEC").await,
StoreOutcome::Duplicate(_)
),
"a second store under the checked keys must be a duplicate"
);
}
#[tokio::test]
async fn stores_server_reserved_body_type() {
let backend = setup();
let StoreOutcome::Stored(id) = store(&backend, "g", SMID, "AAEC").await else {
panic!("first store must not be a duplicate");
};
let list = messages(&backend).await["list"].clone();
assert_eq!(list.as_array().map(Vec::len), Some(1), "{list}");
let m = &list[0];
assert_eq!(m["id"], json!(id.as_ref()));
assert_eq!(m["bodyType"], json!(FANOUT));
assert_eq!(m["senderMsgId"], json!(SMID));
assert_eq!(m["senderId"], json!(HUB));
assert_eq!(m["chatId"], json!("g"));
assert_eq!(m["body"], json!("AAEC"));
}
#[tokio::test]
async fn same_sender_msg_id_same_chat_is_duplicate() {
let backend = setup();
let StoreOutcome::Stored(first) = store(&backend, "g", SMID, "AAEC").await else {
panic!("first store must not be a duplicate");
};
let before = messages(&backend).await;
let again = store(&backend, "g", SMID, "different body").await;
assert_eq!(again, StoreOutcome::Duplicate(first));
let after = messages(&backend).await;
assert_eq!(
after["state"], before["state"],
"a duplicate writes nothing"
);
assert_eq!(after["list"], before["list"]);
}
#[tokio::test]
async fn same_sender_msg_id_other_chat_stores() {
let backend = setup();
let StoreOutcome::Stored(in_g) = store(&backend, "g", SMID, "AAEC").await else {
panic!("first store must not be a duplicate");
};
let StoreOutcome::Stored(in_h) = store(&backend, "h", SMID, "AAEC").await else {
panic!("another Chat is not a duplicate");
};
assert_ne!(in_g, in_h);
assert_eq!(
messages(&backend).await["list"].as_array().map(Vec::len),
Some(2)
);
}
#[tokio::test]
async fn first_message_creates_read_position() {
let backend = setup();
assert!(positions(&backend).await.is_empty());
store(&backend, "g", SMID, "AAEC").await;
let list = positions(&backend).await;
assert_eq!(list.len(), 1, "{list:?}");
assert_eq!(list[0]["chatId"], json!("g"));
store(&backend, "g", "01J00000000000000000000002", "AAED").await;
assert_eq!(positions(&backend).await.len(), 1);
let HandlerOutput { primary, .. } = handle_chat_get(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": ["g"] }),
&[],
)
.await
.expect("Chat/get");
assert_eq!(primary["list"][0]["unreadCount"], json!(2));
}
#[tokio::test]
async fn lookup_by_chat_and_sender_msg_id() {
let backend = setup();
let StoreOutcome::Stored(id) = store(&backend, "g", SMID, "AAEC").await else {
panic!("first store must not be a duplicate");
};
let account = Id::from(ACCOUNT_ID);
let smid = Id::from(SMID);
let found = find_message_by_sender_msg_id(&backend, &(), &account, &Id::from("g"), &smid)
.await
.expect("lookup");
assert_eq!(found.map(|m| m.id), Some(id));
let other = find_message_by_sender_msg_id(&backend, &(), &account, &Id::from("h"), &smid)
.await
.expect("lookup");
assert!(other.is_none());
}
#[tokio::test]
async fn placeholder_sender_msg_id_is_stored_verbatim() {
let backend = setup();
let StoreOutcome::Stored(id) = store(&backend, "g", "placeholder", "AAEC").await else {
panic!("first store must not be a duplicate");
};
let list = messages(&backend).await["list"].clone();
assert_eq!(list.as_array().map(Vec::len), Some(1), "{list}");
let m = &list[0];
assert_eq!(m["senderMsgId"], json!("placeholder"), "{m}");
assert_eq!(m["id"], json!(id.as_ref()), "{m}");
assert_ne!(m["id"], m["senderMsgId"], "{m}");
}