use std::future::Future;
use jmap_types::Id;
use serde_json::{Value, json};
use crate::{ChatBackend, OutboundEvent};
const ACCOUNT_ID: &str = "a1";
const OWNER_USER_ID: &str = "owner@example.org";
pub trait ConformanceBackend: ChatBackend {
fn caller(&self, account_id: &Id) -> Self::CallerCtx;
fn add_account(&self, account_id: &Id, owner_user_id: &str) -> impl Future<Output = ()> + Send;
fn seed(
&self,
account_id: &Id,
type_name: &'static str,
object: Value,
) -> impl Future<Output = ()> + Send;
fn take_outbound_events(&self) -> Option<Vec<OutboundEvent>>;
}
pub fn run<F: Future>(test: F) -> F::Output {
tokio::runtime::Builder::new_multi_thread()
.worker_threads(4)
.build()
.expect("build the tokio runtime")
.block_on(test)
}
#[macro_export]
macro_rules! chat_backend_conformance {
(@tests ($make:expr) $($name:ident),* $(,)?) => {
$(
#[test]
fn $name() {
$crate::testkit::run($crate::testkit::$name(($make)()));
}
)*
};
($make:expr $(,)?) => {
$crate::chat_backend_conformance!(@tests ($make)
state_advances_after_create,
create_then_get,
is_contact_blocked_reads_chat_contact_blocked_field,
is_contact_blocked_reads_only_the_owner_list,
path_key_updates_nested_member,
top_level_object_value_replaces_property,
path_through_absent_parent_is_invalid_patch,
prefix_conflict_is_invalid_patch,
path_depth_counts_toward_nesting_cap,
chat_muted_null_resets_to_false,
chat_pinned_message_ids_null_resets_to_empty,
chat_receive_typing_indicators_null_resets_to_true,
chat_receipt_sharing_null_removes_override,
contact_blocked_null_resets_to_false,
presence_null_resets_to_online,
presence_receipt_sharing_null_resets_to_true,
message_mentions_null_resets_to_empty,
message_actions_null_resets_to_empty,
message_reactions_null_resets_to_empty,
message_broadcast_mentions_null_resets_to_empty,
chat_query_filters_kind_and_muted,
chat_query_applies_filter_operators,
contact_query_filters_blocked_and_presence,
message_query_filters_topic_id,
message_query_filters_has_attachment_both_ways,
message_query_has_mention_false_excludes_mentions,
message_query_changes_refuses_text_filter,
message_query_changes_requires_chat_id_or_has_mention,
space_query_filters_name_substring,
emoji_query_filters_space_id,
emoji_query_changes_applies_space_id_filter,
space_query_sort_descending_reverses_order,
space_query_sort_ascending_orders_by_property,
contact_query_sort_last_active_at_absent_sorts_last,
anchor_with_positive_offset_starts_after_anchor,
anchor_with_negative_offset_starts_before_anchor,
anchor_without_offset_starts_at_anchor,
anchor_offset_before_start_clamps_to_zero,
anchor_absent_from_results_is_anchor_not_found,
anchor_overrides_position,
anchor_offset_without_anchor_is_ignored,
anchor_arguments_of_wrong_type_are_invalid_arguments,
emoji_query_wrongly_typed_args_do_not_echo_value,
extreme_position_and_limit_saturate,
largest_position_is_empty_page_not_error,
join_adds_member_and_counts_use_together,
exhausted_invite_is_refused_without_any_write,
concurrent_redemptions_increment_exactly_once,
invalid_read_at_patch_is_rejected_without_burning,
create_message_stores_and_reports_one_new_message,
contact_create_by_identity_assigns_id,
contact_create_existing_identity_already_exists,
contact_create_without_identity_invalid_properties,
contact_create_other_properties_invalid_properties,
contact_query_identity_filter_matches_octet_for_octet,
reply_counts_match_fixture,
unread_reply_count_without_read_position,
counts_absent_without_supports_threads,
reply_create_lists_parent_updated,
reply_destroy_lists_parent_updated,
read_position_update_lists_thread_root_updated,
sender_expires_at_hard_deletes_at_deadline,
message_expiry_seconds_deletes_messages_older_than_policy,
expires_after_read_seconds_counts_from_read_at,
read_burn_on_read_message_is_deleted,
read_rules_spare_the_senders_own_copy,
mute_until_clears_muted_and_mute_until,
presence_expires_at_resets_status,
expiry_records_chat_unread_count_change,
absent_last_read_counts_every_message,
compliance_11_1_unread_count_from_read_position,
compliance_11_1_with_assigned_ids,
unread_count_in_full_get,
read_position_set_updates_last_read_at,
client_last_read_at_is_rejected,
chat_destroy_destroys_its_read_position,
space_join_creates_read_positions_for_its_channels,
remove_channels_destroys_their_read_positions,
space_destroy_destroys_channel_read_positions,
read_position_set_advances_chat_state,
message_destroy_advances_chat_state,
);
};
}
pub use backend_basics::*;
pub use contact_identity::*;
pub use expiry::*;
pub use message_atomic::*;
pub use patch_null::*;
pub use patch_paths::*;
pub use query_anchor::*;
pub use query_filters::*;
pub use query_sort::*;
pub use read_position::*;
pub use space_join::*;
pub use threads::*;
fn owner<B: ConformanceBackend>(backend: &B) -> B::CallerCtx {
backend.caller(&Id::from(ACCOUNT_ID))
}
async fn setup<B: ConformanceBackend>(backend: &B) {
backend
.add_account(&Id::from(ACCOUNT_ID), OWNER_USER_ID)
.await;
}
async fn seed<B: ConformanceBackend>(backend: &B, type_name: &'static str, object: Value) {
backend.seed(&Id::from(ACCOUNT_ID), type_name, object).await;
}
fn supports_threads<B: ConformanceBackend>(backend: &B) -> bool {
let account_id = Id::from(ACCOUNT_ID);
backend
.limits(&owner(backend), &account_id)
.supports_threads
}
fn exact_unread_count<B: ConformanceBackend>(backend: &B) -> bool {
!backend.maintains_unread_count()
}
async fn seed_group_chat<B: ConformanceBackend>(backend: &B, id: &str) {
seed(
backend,
"Chat",
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" }],
}),
)
.await;
}
async fn make_received<B: ConformanceBackend>(backend: &B, id: &str) {
let jmap_server::HandlerOutput { primary: get, .. } = crate::message::handle_message_get(
backend,
&owner(backend),
json!({ "accountId": ACCOUNT_ID, "ids": [id] }),
&[],
)
.await
.expect("Message/get");
let mut msg = get["list"][0].clone();
assert!(msg.is_object(), "message {id} not found: {get}");
msg["senderId"] = json!("bob");
seed(backend, "Message", msg).await;
}
async fn make_chat_group<B: ConformanceBackend>(backend: &B, name: &str) -> String {
let jmap_server::HandlerOutput { primary: resp, .. } = crate::handle_chat_set(
backend,
&owner(backend),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": { "c0": { "kind": "group", "name": name } }
}),
&[],
)
.await
.expect("make_chat_group: handle_chat_set");
resp["created"]["c0"]["id"]
.as_str()
.expect("make_chat_group: server-assigned id")
.to_owned()
}
async fn make_space<B: ConformanceBackend>(backend: &B, name: &str) -> String {
let jmap_server::HandlerOutput { primary: resp, .. } = crate::handle_space_set(
backend,
&owner(backend),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": { "s0": { "name": name } }
}),
&[],
)
.await
.expect("make_space: handle_space_set");
resp["created"]["s0"]["id"]
.as_str()
.expect("make_space: server-assigned id")
.to_owned()
}
mod backend_basics {
use jmap_chat_types::{Chat, ChatKind};
use jmap_types::{Id, UTCDate};
use serde_json::json;
use super::{ACCOUNT_ID, ConformanceBackend, OWNER_USER_ID, seed, setup};
pub async fn state_advances_after_create<B: ConformanceBackend>(backend: B) {
let account_id = Id::from("account1");
backend.add_account(&account_id, OWNER_USER_ID).await;
let caller = backend.caller(&account_id);
let state_before = backend
.get_state::<Chat>(&caller, &account_id)
.await
.expect("get_state");
let chat = |id: &Id| {
Chat::new(
id.clone(),
ChatKind::Group,
UTCDate::from("2026-01-01T00:00:00Z"),
0,
vec![],
false,
true,
)
};
backend
.create_object::<Chat, _>(&caller, &account_id, "c0", chat)
.await
.expect("create_object");
let state_after = backend
.get_state::<Chat>(&caller, &account_id)
.await
.expect("get_state");
assert_ne!(
state_before, state_after,
"state must change after create_object"
);
}
pub async fn create_then_get<B: ConformanceBackend>(backend: B) {
let account_id = Id::from("account1");
backend.add_account(&account_id, OWNER_USER_ID).await;
let caller = backend.caller(&account_id);
let chat = |id: &Id| {
Chat::new(
id.clone(),
ChatKind::Group,
UTCDate::from("2026-01-01T00:00:00Z"),
0,
vec![],
false,
true,
)
};
let (server_id, _) = backend
.create_object::<Chat, _>(&caller, &account_id, "c0", chat)
.await
.expect("create_object");
let (found, not_found) = backend
.get_objects::<Chat>(
&caller,
&account_id,
Some(std::slice::from_ref(&server_id)),
None,
)
.await
.expect("get_objects");
assert_eq!(found.len(), 1);
assert!(not_found.is_empty());
assert_eq!(found[0].id, server_id);
}
pub async fn is_contact_blocked_reads_chat_contact_blocked_field<B: ConformanceBackend>(
backend: B,
) {
setup(&backend).await;
let account_id = Id::from(ACCOUNT_ID);
let caller = backend.caller(&account_id);
let blocked_id = Id::from("blocked-user");
let allowed_id = Id::from("allowed-user");
seed(
&backend,
"ChatContact",
json!({
"id": "blocked-user",
"identity": "b@example.org",
"login": "b@example.org",
"firstSeenAt": "2024-01-01T00:00:00Z",
"lastSeenAt": "2024-01-02T00:00:00Z",
"blocked": true
}),
)
.await;
seed(
&backend,
"ChatContact",
json!({
"id": "allowed-user",
"identity": "a@example.org",
"login": "a@example.org",
"firstSeenAt": "2024-01-01T00:00:00Z",
"lastSeenAt": "2024-01-02T00:00:00Z",
"blocked": false
}),
)
.await;
assert!(
backend
.is_contact_blocked(&caller, &account_id, &blocked_id)
.await
.expect("is_contact_blocked"),
"blocked: true contact must report blocked"
);
assert!(
!backend
.is_contact_blocked(&caller, &account_id, &allowed_id)
.await
.expect("is_contact_blocked"),
"blocked: false contact must report not-blocked"
);
let unknown = Id::from("never-seen");
assert!(
!backend
.is_contact_blocked(&caller, &account_id, &unknown)
.await
.expect("is_contact_blocked"),
"unknown contact id must report not-blocked"
);
}
pub async fn is_contact_blocked_reads_only_the_owner_list<B: ConformanceBackend>(backend: B) {
let recipient = Id::from("acct-recipient");
let sender = Id::from("acct-sender");
backend.add_account(&recipient, OWNER_USER_ID).await;
backend.add_account(&sender, "sender@example.org").await;
backend
.seed(
&recipient,
"ChatContact",
json!({
"id": "c-sender",
"identity": "sender@example.org",
"login": "sender@example.org",
"firstSeenAt": "2024-01-01T00:00:00Z",
"lastSeenAt": "2024-01-02T00:00:00Z",
"blocked": true
}),
)
.await;
backend
.seed(
&sender,
"ChatContact",
json!({
"id": "c-recipient",
"identity": "recipient@example.org",
"login": "recipient@example.org",
"firstSeenAt": "2024-01-01T00:00:00Z",
"lastSeenAt": "2024-01-02T00:00:00Z",
"blocked": false
}),
)
.await;
let blocked = |account: &Id, contact: &str| {
let backend = &backend;
let account = account.clone();
let contact = Id::from(contact);
async move {
backend
.is_contact_blocked(&backend.caller(&account), &account, &contact)
.await
.expect("is_contact_blocked")
}
};
assert!(
blocked(&recipient, "c-sender").await,
"the recipient blocked the sender on the recipient's own list"
);
assert!(
!blocked(&sender, "c-recipient").await,
"the sender's list does not block the recipient"
);
assert!(
!blocked(&sender, "c-sender").await,
"c-sender is held only by the recipient's account"
);
}
}
mod patch_paths {
use jmap_chat_types::Message;
use jmap_server::HandlerOutput;
use jmap_server::{BackendSetError, SetErrorType};
use jmap_types::{Id, PatchObject};
use serde_json::{Value, json};
use super::{ACCOUNT_ID, ConformanceBackend, owner, seed_group_chat, setup};
use crate::message::{handle_message_get, handle_message_set};
async fn create_message<B: ConformanceBackend>(backend: &B) -> String {
seed_group_chat(backend, "c1").await;
let HandlerOutput { primary: resp, .. } = handle_message_set(
backend,
&owner(backend),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": { "m0": { "chatId": "c1", "body": "hi", "sentAt": "2024-01-01T00:00:00Z" } }
}),
&[],
)
.await
.expect("create");
resp["created"]["m0"]["id"]
.as_str()
.expect("created id")
.to_owned()
}
async fn update<B: ConformanceBackend>(
backend: &B,
id: &str,
patch: Value,
) -> Result<(), SetErrorType> {
let patch: PatchObject = serde_json::from_value(patch).expect("patch is a JSON object");
match backend
.update_object::<Message>(&owner(backend), &Id::from(ACCOUNT_ID), &Id::from(id), patch)
.await
{
Ok(_) => Ok(()),
Err(BackendSetError::SetError(e)) => Err(e.error_type),
Err(e) => panic!("backend error: {e:?}"),
}
}
async fn get<B: ConformanceBackend>(backend: &B, id: &str) -> Value {
let HandlerOutput { primary: resp, .. } = handle_message_get(
backend,
&owner(backend),
json!({ "accountId": ACCOUNT_ID, "ids": [id] }),
&[],
)
.await
.expect("get");
resp["list"][0].clone()
}
async fn message_with_receipt<B: ConformanceBackend>(backend: &B) -> String {
let id = create_message(backend).await;
let resp = update(
backend,
&id,
json!({ "deliveryReceipts": { "u1": { "deliveredAt": "2024-01-01T00:00:01Z" } } }),
)
.await;
assert_eq!(resp, Ok(()));
id
}
pub async fn path_key_updates_nested_member<B: ConformanceBackend>(backend: B) {
setup(&backend).await;
let id = message_with_receipt(&backend).await;
let resp = update(
&backend,
&id,
json!({ "deliveryReceipts/u2": { "readAt": "2024-01-01T00:00:02Z" } }),
)
.await;
assert_eq!(resp, Ok(()));
let msg = get(&backend, &id).await;
assert!(msg.get("deliveryReceipts/u2").is_none(), "{msg:?}");
assert_eq!(
msg["deliveryReceipts"],
json!({
"u1": { "deliveredAt": "2024-01-01T00:00:01Z" },
"u2": { "readAt": "2024-01-01T00:00:02Z" },
})
);
}
pub async fn top_level_object_value_replaces_property<B: ConformanceBackend>(backend: B) {
setup(&backend).await;
let id = message_with_receipt(&backend).await;
let resp = update(
&backend,
&id,
json!({ "deliveryReceipts": { "u2": { "readAt": "2024-01-01T00:00:02Z" } } }),
)
.await;
assert_eq!(resp, Ok(()));
let msg = get(&backend, &id).await;
assert_eq!(
msg["deliveryReceipts"],
json!({ "u2": { "readAt": "2024-01-01T00:00:02Z" } })
);
}
pub async fn path_through_absent_parent_is_invalid_patch<B: ConformanceBackend>(backend: B) {
setup(&backend).await;
let id = create_message(&backend).await;
let before = get(&backend, &id).await;
assert!(before.get("deliveryReceipts").is_none(), "{before:?}");
let resp = update(
&backend,
&id,
json!({ "deliveryReceipts/u1": { "readAt": "2024-01-01T00:00:02Z" } }),
)
.await;
assert_eq!(resp, Err(SetErrorType::InvalidPatch));
assert_eq!(get(&backend, &id).await, before);
}
pub async fn prefix_conflict_is_invalid_patch<B: ConformanceBackend>(backend: B) {
setup(&backend).await;
let id = message_with_receipt(&backend).await;
let before = get(&backend, &id).await;
let resp = update(
&backend,
&id,
json!({
"deliveryReceipts": { "u2": { "readAt": "2024-01-01T00:00:02Z" } },
"deliveryReceipts/u1/readAt": "2024-01-01T00:00:03Z",
}),
)
.await;
assert_eq!(resp, Err(SetErrorType::InvalidPatch));
assert_eq!(get(&backend, &id).await, before);
}
fn nested(levels: usize) -> Value {
(1..levels).fold(json!({}), |inner, _| json!({ "k": inner }))
}
pub async fn path_depth_counts_toward_nesting_cap<B: ConformanceBackend>(backend: B) {
setup(&backend).await;
let id = create_message(&backend).await;
let resp = update(
&backend,
&id,
json!({ "deliveryReceipts": { "u1": nested(21) } }),
)
.await;
assert_eq!(resp, Ok(()));
let before = get(&backend, &id).await;
let path = format!("deliveryReceipts/u1{}", "/k".repeat(19));
let resp = update(&backend, &id, json!({ path: nested(21) })).await;
assert_eq!(resp, Err(SetErrorType::InvalidPatch));
assert_eq!(get(&backend, &id).await, before);
}
}
mod patch_null {
use jmap_chat_types::Message;
use jmap_server::HandlerOutput;
use jmap_types::{Id, PatchObject};
use serde_json::{Map, Value, json};
use super::{
ACCOUNT_ID, ConformanceBackend, make_chat_group, owner, seed, seed_group_chat, setup,
};
use crate::message::{handle_message_get, handle_message_set};
use crate::{
handle_chat_get, handle_chat_set, handle_contact_get, handle_contact_set,
handle_presence_get, handle_presence_set,
};
fn assert_updated(resp: &Value, id: &str) {
assert_eq!(resp["notUpdated"], Value::Null, "{resp:?}");
assert!(
resp["updated"]
.as_object()
.is_some_and(|m| m.contains_key(id)),
"{resp:?}"
);
}
async fn chat_update<B: ConformanceBackend>(backend: &B, id: &str, patch: Value) {
let HandlerOutput { primary: resp, .. } = handle_chat_set(
backend,
&owner(backend),
&std::collections::BTreeMap::new(),
json!({ "accountId": ACCOUNT_ID, "update": { id: patch } }),
&[],
)
.await
.expect("Chat/set");
assert_updated(&resp, id);
}
async fn chat_get<B: ConformanceBackend>(backend: &B, id: &str) -> Value {
let HandlerOutput { primary: resp, .. } = handle_chat_get(
backend,
&owner(backend),
json!({ "accountId": ACCOUNT_ID, "ids": [id] }),
&[],
)
.await
.expect("Chat/get");
resp["list"][0].clone()
}
pub async fn chat_muted_null_resets_to_false<B: ConformanceBackend>(backend: B) {
setup(&backend).await;
let id = make_chat_group(&backend, "g").await;
chat_update(&backend, &id, json!({ "muted": true })).await;
chat_update(&backend, &id, json!({ "muted": null })).await;
assert_eq!(chat_get(&backend, &id).await["muted"], json!(false));
}
pub async fn chat_pinned_message_ids_null_resets_to_empty<B: ConformanceBackend>(backend: B) {
setup(&backend).await;
let id = make_chat_group(&backend, "g").await;
chat_update(&backend, &id, json!({ "pinnedMessageIds": null })).await;
assert_eq!(chat_get(&backend, &id).await["pinnedMessageIds"], json!([]));
}
pub async fn chat_receive_typing_indicators_null_resets_to_true<B: ConformanceBackend>(
backend: B,
) {
setup(&backend).await;
let id = make_chat_group(&backend, "g").await;
chat_update(&backend, &id, json!({ "receiveTypingIndicators": false })).await;
chat_update(&backend, &id, json!({ "receiveTypingIndicators": null })).await;
assert_eq!(
chat_get(&backend, &id).await["receiveTypingIndicators"],
json!(true)
);
}
pub async fn chat_receipt_sharing_null_removes_override<B: ConformanceBackend>(backend: B) {
setup(&backend).await;
let id = make_chat_group(&backend, "g").await;
chat_update(&backend, &id, json!({ "receiptSharing": false })).await;
assert_eq!(
chat_get(&backend, &id).await["receiptSharing"],
json!(false)
);
chat_update(&backend, &id, json!({ "receiptSharing": null })).await;
let chat = chat_get(&backend, &id).await;
assert!(
chat.as_object()
.is_some_and(|m| !m.contains_key("receiptSharing")),
"{chat:?}"
);
}
pub async fn contact_blocked_null_resets_to_false<B: ConformanceBackend>(backend: B) {
setup(&backend).await;
seed(
&backend,
"ChatContact",
json!({
"id": "ct1",
"identity": "alice@example.com",
"login": "alice@example.com",
"firstSeenAt": "2024-01-01T00:00:00Z",
"lastSeenAt": "2024-01-01T00:00:00Z",
"blocked": true,
}),
)
.await;
let HandlerOutput { primary: resp, .. } = handle_contact_set(
&backend,
&owner(&backend),
json!({ "accountId": ACCOUNT_ID, "update": { "ct1": { "blocked": null } } }),
)
.await
.expect("ChatContact/set");
assert_updated(&resp, "ct1");
let HandlerOutput { primary: resp, .. } = handle_contact_get(
&backend,
&owner(&backend),
json!({ "accountId": ACCOUNT_ID, "ids": ["ct1"] }),
)
.await
.expect("ChatContact/get");
assert_eq!(resp["list"][0]["blocked"], json!(false), "{resp:?}");
}
async fn seed_presence<B: ConformanceBackend>(backend: &B) {
seed(
backend,
"PresenceStatus",
json!({
"id": "ps1",
"presence": "busy",
"receiptSharing": false,
"updatedAt": "2024-01-01T00:00:00Z",
}),
)
.await;
}
async fn presence_null_then_get<B: ConformanceBackend>(backend: &B, prop: &str) -> Value {
let HandlerOutput { primary: resp, .. } = handle_presence_set(
backend,
&owner(backend),
json!({ "accountId": ACCOUNT_ID, "update": { "ps1": { prop: null } } }),
)
.await
.expect("PresenceStatus/set");
assert_updated(&resp, "ps1");
let HandlerOutput { primary: resp, .. } = handle_presence_get(
backend,
&owner(backend),
json!({ "accountId": ACCOUNT_ID, "ids": ["ps1"] }),
)
.await
.expect("PresenceStatus/get");
resp["list"][0].clone()
}
pub async fn presence_null_resets_to_online<B: ConformanceBackend>(backend: B) {
setup(&backend).await;
seed_presence(&backend).await;
let ps = presence_null_then_get(&backend, "presence").await;
assert_eq!(ps["presence"], json!("online"), "{ps:?}");
}
pub async fn presence_receipt_sharing_null_resets_to_true<B: ConformanceBackend>(backend: B) {
setup(&backend).await;
seed_presence(&backend).await;
let ps = presence_null_then_get(&backend, "receiptSharing").await;
assert_eq!(ps["receiptSharing"], json!(true), "{ps:?}");
}
async fn message_null_then_get<B: ConformanceBackend>(backend: &B, prop: &str) -> Value {
setup(backend).await;
seed_group_chat(backend, "c1").await;
let HandlerOutput { primary: resp, .. } = handle_message_set(
backend,
&owner(backend),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": { "m0": { "chatId": "c1", "body": "hi", "sentAt": "2024-01-01T00:00:00Z" } }
}),
&[],
)
.await
.expect("Message/set create");
let id = resp["created"]["m0"]["id"]
.as_str()
.expect("created id")
.to_owned();
let patch = PatchObject::from(Map::from_iter([(prop.to_owned(), Value::Null)]));
backend
.update_object::<Message>(
&owner(backend),
&Id::from(ACCOUNT_ID),
&Id::from(id.as_str()),
patch,
)
.await
.expect("update_object");
let HandlerOutput { primary: resp, .. } = handle_message_get(
backend,
&owner(backend),
json!({ "accountId": ACCOUNT_ID, "ids": [&id] }),
&[],
)
.await
.expect("Message/get");
resp["list"][0].clone()
}
pub async fn message_mentions_null_resets_to_empty<B: ConformanceBackend>(backend: B) {
let msg = message_null_then_get(&backend, "mentions").await;
assert_eq!(msg["mentions"], json!([]), "{msg:?}");
}
pub async fn message_actions_null_resets_to_empty<B: ConformanceBackend>(backend: B) {
let msg = message_null_then_get(&backend, "actions").await;
assert_eq!(msg["actions"], json!([]), "{msg:?}");
}
pub async fn message_reactions_null_resets_to_empty<B: ConformanceBackend>(backend: B) {
let msg = message_null_then_get(&backend, "reactions").await;
assert_eq!(msg["reactions"], json!({}), "{msg:?}");
}
pub async fn message_broadcast_mentions_null_resets_to_empty<B: ConformanceBackend>(
backend: B,
) {
let msg = message_null_then_get(&backend, "broadcastMentions").await;
assert_eq!(msg["broadcastMentions"], json!([]), "{msg:?}");
}
}
mod query_filters {
use jmap_server::HandlerOutput;
use jmap_types::JmapError;
use serde_json::{Value, json};
use super::{ACCOUNT_ID, ConformanceBackend, owner, seed, setup};
use crate::message::{handle_message_query, handle_message_query_changes};
use crate::{
handle_chat_query, handle_contact_query, handle_emoji_query, handle_emoji_query_changes,
handle_emoji_set, handle_space_query,
};
fn sorted_ids(resp: &Value) -> Vec<String> {
let mut ids: Vec<String> = resp["ids"]
.as_array()
.expect("ids")
.iter()
.map(|id| id.as_str().expect("id").to_owned())
.collect();
ids.sort();
ids
}
async fn seeded<B: ConformanceBackend>(
backend: &B,
type_name: &'static str,
objects: &[(&str, Value)],
) {
setup(backend).await;
for (id, obj) in objects {
let mut obj = obj.clone();
obj["id"] = json!(id);
seed(backend, type_name, obj).await;
}
}
async fn chat_backend<B: ConformanceBackend>(backend: &B) {
seeded(
backend,
"Chat",
&[
("g-muted", json!({ "kind": "group", "muted": true })),
("g-loud", json!({ "kind": "group", "muted": false })),
("d-loud", json!({ "kind": "direct", "muted": false })),
],
)
.await;
}
async fn chat_query<B: ConformanceBackend>(backend: &B, filter: Value) -> Vec<String> {
let HandlerOutput { primary: resp, .. } = handle_chat_query(
backend,
&owner(backend),
json!({ "accountId": ACCOUNT_ID, "filter": filter }),
&[],
)
.await
.expect("Chat/query");
sorted_ids(&resp)
}
pub async fn chat_query_filters_kind_and_muted<B: ConformanceBackend>(backend: B) {
chat_backend(&backend).await;
assert_eq!(
chat_query(&backend, json!({ "kind": "group" })).await,
["g-loud", "g-muted"]
);
assert_eq!(
chat_query(&backend, json!({ "muted": true })).await,
["g-muted"]
);
assert_eq!(
chat_query(&backend, json!({ "kind": "group", "muted": false })).await,
["g-loud"]
);
}
pub async fn chat_query_applies_filter_operators<B: ConformanceBackend>(backend: B) {
chat_backend(&backend).await;
let or = json!({ "operator": "OR", "conditions": [
{ "kind": "direct" }, { "muted": true },
] });
assert_eq!(chat_query(&backend, or).await, ["d-loud", "g-muted"]);
let not = json!({ "operator": "NOT", "conditions": [{ "kind": "direct" }] });
assert_eq!(chat_query(&backend, not).await, ["g-loud", "g-muted"]);
let and = json!({ "operator": "AND", "conditions": [
{ "kind": "group" }, { "muted": false },
] });
assert_eq!(chat_query(&backend, and).await, ["g-loud"]);
}
pub async fn contact_query_filters_blocked_and_presence<B: ConformanceBackend>(backend: B) {
seeded(
&backend,
"ChatContact",
&[
(
"blocked-online",
json!({ "identity": "a", "blocked": true, "presence": "online" }),
),
(
"open-online",
json!({ "identity": "b", "blocked": false, "presence": "online" }),
),
(
"open-away",
json!({ "identity": "c", "blocked": false, "presence": "away" }),
),
],
)
.await;
let query = |filter: Value| {
let backend = &backend;
async move {
let HandlerOutput { primary: resp, .. } = handle_contact_query(
backend,
&owner(backend),
json!({ "accountId": ACCOUNT_ID, "filter": filter }),
)
.await
.expect("ChatContact/query");
sorted_ids(&resp)
}
};
assert_eq!(
query(json!({ "blocked": false })).await,
["open-away", "open-online"]
);
assert_eq!(
query(json!({ "presence": "online" })).await,
["blocked-online", "open-online"]
);
assert_eq!(
query(json!({ "blocked": false, "presence": "online" })).await,
["open-online"]
);
}
async fn message_backend<B: ConformanceBackend>(backend: &B) {
let msg = |extra: Value| {
let mut m = json!({ "chatId": "chat1", "receivedAt": "2026-01-01T00:00:00Z" });
for (k, v) in extra.as_object().expect("object") {
m[k] = v.clone();
}
m
};
seeded(
backend,
"Message",
&[
(
"topic-a",
msg(json!({ "topicId": "a", "subject": "Topic A" })),
),
(
"topic-b",
msg(json!({ "topicId": "b", "subject": "Topic B" })),
),
(
"with-file",
msg(json!({ "attachments": [{ "blobId": "b1", "type": "text/plain" }] })),
),
(
"mentions-me",
msg(json!({ "mentions": [{ "id": ACCOUNT_ID }] })),
),
],
)
.await;
seed(backend, "Chat", json!({ "id": "chat1", "kind": "group" })).await;
}
async fn message_query<B: ConformanceBackend>(backend: &B, extra: Value) -> Vec<String> {
let mut filter = json!({ "chatId": "chat1" });
for (k, v) in extra.as_object().expect("object") {
filter[k] = v.clone();
}
let HandlerOutput { primary: resp, .. } = handle_message_query(
backend,
&owner(backend),
json!({ "accountId": ACCOUNT_ID, "filter": filter }),
&[],
)
.await
.expect("Message/query");
sorted_ids(&resp)
}
pub async fn message_query_filters_topic_id<B: ConformanceBackend>(backend: B) {
message_backend(&backend).await;
assert_eq!(
message_query(&backend, json!({ "topicId": "a" })).await,
["topic-a"]
);
}
pub async fn message_query_filters_has_attachment_both_ways<B: ConformanceBackend>(backend: B) {
message_backend(&backend).await;
assert_eq!(
message_query(&backend, json!({ "hasAttachment": true })).await,
["with-file"]
);
assert_eq!(
message_query(&backend, json!({ "hasAttachment": false })).await,
["mentions-me", "topic-a", "topic-b"]
);
}
pub async fn message_query_has_mention_false_excludes_mentions<B: ConformanceBackend>(
backend: B,
) {
message_backend(&backend).await;
assert_eq!(
message_query(&backend, json!({ "hasMention": false })).await,
["topic-a", "topic-b", "with-file"]
);
}
pub async fn message_query_changes_refuses_text_filter<B: ConformanceBackend>(backend: B) {
message_backend(&backend).await;
let err = handle_message_query_changes(
&backend,
&owner(&backend),
json!({
"accountId": ACCOUNT_ID,
"filter": { "chatId": "chat1", "text": "hello" },
"sinceQueryState": "0",
}),
&[],
)
.await
.expect_err("text filter");
assert_eq!(err.error_type, JmapError::unsupported_filter().error_type);
assert!(err.description.is_some(), "the refusal names its rule");
}
pub async fn message_query_changes_requires_chat_id_or_has_mention<B: ConformanceBackend>(
backend: B,
) {
message_backend(&backend).await;
let err = handle_message_query_changes(
&backend,
&owner(&backend),
json!({
"accountId": ACCOUNT_ID,
"filter": { "topicId": "a" },
"sinceQueryState": "0",
}),
&[],
)
.await
.expect_err("no chatId");
assert_eq!(err.error_type, JmapError::unsupported_filter().error_type);
assert!(err.description.is_some(), "the refusal names its rule");
}
pub async fn space_query_filters_name_substring<B: ConformanceBackend>(backend: B) {
let member = json!([{ "id": ACCOUNT_ID }]);
seeded(
&backend,
"Space",
&[
("rust", json!({ "name": "rustaceans", "members": member })),
("go", json!({ "name": "gophers", "members": member })),
],
)
.await;
let HandlerOutput { primary: resp, .. } = handle_space_query(
&backend,
&owner(&backend),
json!({ "accountId": ACCOUNT_ID, "filter": { "name": "stace" } }),
&[],
)
.await
.expect("Space/query");
assert_eq!(sorted_ids(&resp), ["rust"]);
}
async fn emoji_set<B: ConformanceBackend>(backend: &B, create: Value) -> Value {
handle_emoji_set(
backend,
&owner(backend),
&std::collections::BTreeMap::new(),
json!({ "accountId": ACCOUNT_ID, "create": create }),
)
.await
.expect("CustomEmoji/set")
.primary
}
pub async fn emoji_query_filters_space_id<B: ConformanceBackend>(backend: B) {
setup(&backend).await;
let resp = emoji_set(
&backend,
json!({
"global": { "name": "wave", "blobId": "b1" },
"local": { "name": "crab", "blobId": "b2", "spaceId": "space1" },
}),
)
.await;
let local = resp["created"]["local"]["id"].as_str().expect("id");
let global = resp["created"]["global"]["id"].as_str().expect("id");
let query = |filter: Value| {
let backend = &backend;
async move {
let HandlerOutput { primary: resp, .. } = handle_emoji_query(
backend,
&owner(backend),
json!({ "accountId": ACCOUNT_ID, "filter": filter }),
)
.await
.expect("CustomEmoji/query");
sorted_ids(&resp)
}
};
assert_eq!(query(json!({ "spaceId": "space1" })).await, [local]);
let mut all = vec![local.to_owned(), global.to_owned()];
all.sort();
assert_eq!(query(json!({})).await, all);
}
pub async fn emoji_query_changes_applies_space_id_filter<B: ConformanceBackend>(backend: B) {
setup(&backend).await;
let filter = json!({ "spaceId": "space1" });
let HandlerOutput {
primary: before, ..
} = handle_emoji_query(
&backend,
&owner(&backend),
json!({ "accountId": ACCOUNT_ID, "filter": filter }),
)
.await
.expect("CustomEmoji/query");
let resp = emoji_set(
&backend,
json!({
"global": { "name": "wave", "blobId": "b1" },
"local": { "name": "crab", "blobId": "b2", "spaceId": "space1" },
}),
)
.await;
let local = resp["created"]["local"]["id"].as_str().expect("id");
let HandlerOutput {
primary: changes, ..
} = handle_emoji_query_changes(
&backend,
&owner(&backend),
json!({
"accountId": ACCOUNT_ID,
"filter": filter,
"sinceQueryState": before["queryState"],
}),
)
.await
.expect("CustomEmoji/queryChanges");
assert_eq!(changes["added"], json!([{ "id": local, "index": 0 }]));
}
}
mod query_sort {
use jmap_server::HandlerOutput;
use serde_json::{Value, json};
use super::{ACCOUNT_ID, ConformanceBackend, make_space, owner, seed, setup};
use crate::{handle_contact_query, handle_space_get, handle_space_query};
fn ids(resp: &Value) -> Vec<String> {
resp["ids"]
.as_array()
.expect("ids")
.iter()
.map(|id| id.as_str().expect("id").to_owned())
.collect()
}
async fn space_names<B: ConformanceBackend>(backend: &B, space_ids: &[String]) -> Vec<String> {
let HandlerOutput { primary: resp, .. } = handle_space_get(
backend,
&owner(backend),
json!({ "accountId": ACCOUNT_ID, "ids": space_ids }),
&[],
)
.await
.expect("Space/get");
space_ids
.iter()
.map(|id| {
resp["list"]
.as_array()
.expect("list")
.iter()
.find(|s| s["id"] == id.as_str())
.and_then(|s| s["name"].as_str())
.expect("space name")
.to_owned()
})
.collect()
}
async fn query_spaces_by_name<B: ConformanceBackend>(
backend: &B,
is_ascending: bool,
) -> Vec<String> {
let HandlerOutput { primary: resp, .. } = handle_space_query(
backend,
&owner(backend),
json!({
"accountId": ACCOUNT_ID,
"sort": [{ "property": "name", "isAscending": is_ascending }],
}),
&[],
)
.await
.expect("Space/query");
space_names(backend, &ids(&resp)).await
}
pub async fn space_query_sort_descending_reverses_order<B: ConformanceBackend>(backend: B) {
setup(&backend).await;
for name in ["Alpha", "Bravo", "Charlie"] {
make_space(&backend, name).await;
}
assert_eq!(
query_spaces_by_name(&backend, false).await,
["Charlie", "Bravo", "Alpha"]
);
}
pub async fn space_query_sort_ascending_orders_by_property<B: ConformanceBackend>(backend: B) {
setup(&backend).await;
for name in ["Charlie", "Alpha", "Bravo"] {
make_space(&backend, name).await;
}
assert_eq!(
query_spaces_by_name(&backend, true).await,
["Alpha", "Bravo", "Charlie"]
);
}
pub async fn contact_query_sort_last_active_at_absent_sorts_last<B: ConformanceBackend>(
backend: B,
) {
setup(&backend).await;
for (id, last_active_at) in [
("c1", None),
("c2", Some("2026-01-01T00:00:00Z")),
("c3", Some("2026-03-01T00:00:00Z")),
] {
let mut contact = json!({ "id": id, "login": id });
if let Some(at) = last_active_at {
contact["lastActiveAt"] = json!(at);
}
seed(&backend, "ChatContact", contact).await;
}
for (is_ascending, expected) in [(true, ["c2", "c3", "c1"]), (false, ["c3", "c2", "c1"])] {
let HandlerOutput { primary: resp, .. } = handle_contact_query(
&backend,
&owner(&backend),
json!({
"accountId": ACCOUNT_ID,
"sort": [{ "property": "lastActiveAt", "isAscending": is_ascending }],
}),
)
.await
.expect("ChatContact/query");
assert_eq!(ids(&resp), expected, "isAscending: {is_ascending}");
}
}
}
mod query_anchor {
use jmap_server::HandlerOutput;
use serde_json::{Value, json};
use super::{ACCOUNT_ID, ConformanceBackend, owner, seed, setup};
use crate::{handle_chat_query, handle_emoji_query};
async fn seeded_backend<B: ConformanceBackend>(backend: &B) {
setup(backend).await;
for id in ["c1", "c2", "c3", "c4", "c5"] {
seed(backend, "Chat", json!({ "id": id })).await;
}
}
async fn query<B: ConformanceBackend>(backend: &B, extra: Value) -> Result<Value, Value> {
let mut args = json!({ "accountId": ACCOUNT_ID });
for (k, v) in extra.as_object().expect("extra must be an object") {
args[k] = v.clone();
}
handle_chat_query(backend, &owner(backend), args, &[])
.await
.map(|HandlerOutput { primary: resp, .. }| resp)
.map_err(|e| serde_json::to_value(&e).expect("JmapError must serialize"))
}
fn ids(resp: &Value) -> Vec<&str> {
resp["ids"]
.as_array()
.expect("ids")
.iter()
.map(|id| id.as_str().expect("id"))
.collect()
}
pub async fn anchor_with_positive_offset_starts_after_anchor<B: ConformanceBackend>(
backend: B,
) {
seeded_backend(&backend).await;
let resp = query(
&backend,
json!({ "anchor": "c3", "anchorOffset": 1, "limit": 2 }),
)
.await
.expect("Chat/query");
assert_eq!(ids(&resp), ["c4", "c5"]);
assert_eq!(resp["position"], 3);
}
pub async fn anchor_with_negative_offset_starts_before_anchor<B: ConformanceBackend>(
backend: B,
) {
seeded_backend(&backend).await;
let resp = query(
&backend,
json!({ "anchor": "c3", "anchorOffset": -1, "limit": 2 }),
)
.await
.expect("Chat/query");
assert_eq!(ids(&resp), ["c2", "c3"]);
assert_eq!(resp["position"], 1);
}
pub async fn anchor_without_offset_starts_at_anchor<B: ConformanceBackend>(backend: B) {
seeded_backend(&backend).await;
let resp = query(&backend, json!({ "anchor": "c4" }))
.await
.expect("Chat/query");
assert_eq!(ids(&resp), ["c4", "c5"]);
assert_eq!(resp["position"], 3);
}
pub async fn anchor_offset_before_start_clamps_to_zero<B: ConformanceBackend>(backend: B) {
seeded_backend(&backend).await;
let resp = query(
&backend,
json!({ "position": 3, "anchor": "c2", "anchorOffset": -3, "limit": 2 }),
)
.await
.expect("Chat/query");
assert_eq!(ids(&resp), ["c1", "c2"]);
assert_eq!(resp["position"], 0);
}
pub async fn anchor_absent_from_results_is_anchor_not_found<B: ConformanceBackend>(backend: B) {
seeded_backend(&backend).await;
let err = query(&backend, json!({ "anchor": "nope" }))
.await
.expect_err("an anchor absent from the results must be rejected");
assert_eq!(err["type"], "anchorNotFound");
}
pub async fn anchor_overrides_position<B: ConformanceBackend>(backend: B) {
seeded_backend(&backend).await;
let resp = query(
&backend,
json!({ "position": 4, "anchor": "c2", "limit": 2 }),
)
.await
.expect("Chat/query");
assert_eq!(ids(&resp), ["c2", "c3"]);
assert_eq!(resp["position"], 1);
}
pub async fn anchor_offset_without_anchor_is_ignored<B: ConformanceBackend>(backend: B) {
seeded_backend(&backend).await;
let resp = query(
&backend,
json!({ "position": 1, "anchorOffset": 2, "limit": 2 }),
)
.await
.expect("Chat/query");
assert_eq!(ids(&resp), ["c2", "c3"]);
assert_eq!(resp["position"], 1);
}
pub async fn anchor_arguments_of_wrong_type_are_invalid_arguments<B: ConformanceBackend>(
backend: B,
) {
seeded_backend(&backend).await;
for extra in [
json!({ "anchor": 7 }),
json!({ "anchor": "c2", "anchorOffset": "1" }),
] {
let err = query(&backend, extra.clone())
.await
.expect_err("wrongly typed anchor arguments must be rejected");
assert_eq!(err["type"], "invalidArguments", "args: {extra}");
}
}
pub async fn emoji_query_wrongly_typed_args_do_not_echo_value<B: ConformanceBackend>(
backend: B,
) {
seeded_backend(&backend).await;
for name in ["limit", "position"] {
let mut args = json!({ "accountId": ACCOUNT_ID });
args[name] = json!({ "note": "CANARY-zegc" });
let err = handle_emoji_query(&backend, &owner(&backend), args)
.await
.expect_err("wrongly typed argument must be rejected");
assert_eq!(err.error_type.to_string(), "invalidArguments", "{name}");
let desc = err.description.as_deref().unwrap_or_default();
assert!(desc.starts_with(name), "{desc}");
assert!(desc.contains("got object"), "{desc}");
assert!(!desc.contains("CANARY"), "{desc}");
}
}
pub async fn extreme_position_and_limit_saturate<B: ConformanceBackend>(backend: B) {
seeded_backend(&backend).await;
let resp = query(
&backend,
json!({ "position": -9_007_199_254_740_991_i64, "limit": 9_007_199_254_740_991_u64 }),
)
.await
.expect("Chat/query");
assert_eq!(ids(&resp), ["c1", "c2", "c3", "c4", "c5"]);
assert_eq!(resp["position"], 0);
}
pub async fn largest_position_is_empty_page_not_error<B: ConformanceBackend>(backend: B) {
seeded_backend(&backend).await;
let resp = query(&backend, json!({ "position": 9_007_199_254_740_991_i64 }))
.await
.expect("Chat/query");
assert!(ids(&resp).is_empty());
}
}
mod space_join {
use std::sync::Arc;
use jmap_chat_types::{Space, SpaceInvite};
use jmap_types::{Id, UTCDate};
use serde_json::json;
use super::{ACCOUNT_ID, ConformanceBackend, owner, seed, setup};
use crate::{InviteJoinRefusal, handle_space_join};
const SPACE_ID: &str = "s1";
const INVITE_ID: &str = "inv1";
const CODE: &str = "0123456789abcdef0123456789abcdef";
async fn seeded<B: ConformanceBackend>(backend: &B, uses: u64, max_uses: u64) {
setup(backend).await;
seed(
backend,
"Space",
json!({
"id": SPACE_ID,
"name": "Test Space",
"createdAt": "2026-01-01T00:00:00Z",
"memberCount": 0,
"categories": [],
"uncategorizedChannelIds": [],
"isPublic": false,
"isPubliclyPreviewable": false,
"roles": [],
"members": [],
}),
)
.await;
seed(
backend,
"SpaceInvite",
json!({
"id": INVITE_ID,
"code": CODE,
"spaceId": SPACE_ID,
"createdBy": ACCOUNT_ID,
"uses": uses,
"maxUses": max_uses,
"createdAt": "2026-01-01T00:00:00Z",
}),
)
.await;
}
async fn snapshot<B: ConformanceBackend>(backend: &B) -> (Vec<String>, u64, String, String) {
let acct = Id::from(ACCOUNT_ID);
let (spaces, _) = backend
.get_objects::<Space>(&owner(backend), &acct, Some(&[Id::from(SPACE_ID)]), None)
.await
.unwrap();
let (invites, _) = backend
.get_objects::<SpaceInvite>(&owner(backend), &acct, Some(&[Id::from(INVITE_ID)]), None)
.await
.unwrap();
let members = spaces[0]
.members
.iter()
.map(|m| m.id.as_ref().to_owned())
.collect();
let space_state = backend
.get_state::<Space>(&owner(backend), &acct)
.await
.unwrap();
let invite_state = backend
.get_state::<SpaceInvite>(&owner(backend), &acct)
.await
.unwrap();
(
members,
invites[0].uses,
space_state.as_ref().to_owned(),
invite_state.as_ref().to_owned(),
)
}
pub async fn join_adds_member_and_counts_use_together<B: ConformanceBackend>(backend: B) {
seeded(&backend, 0, 2).await;
let (_, _, space_before, invite_before) = snapshot(&backend).await;
handle_space_join(
&backend,
&owner(&backend),
json!({ "accountId": ACCOUNT_ID, "inviteCode": CODE }),
)
.await
.expect("Space/join");
let (members, uses, space_after, invite_after) = snapshot(&backend).await;
assert_eq!(members, vec![ACCOUNT_ID.to_owned()]);
assert_eq!(uses, 1);
assert_ne!(space_after, space_before, "Space change not recorded");
assert_ne!(
invite_after, invite_before,
"SpaceInvite change not recorded"
);
}
pub async fn exhausted_invite_is_refused_without_any_write<B: ConformanceBackend>(backend: B) {
seeded(&backend, 1, 1).await;
let before = snapshot(&backend).await;
let refusal = backend
.join_space_with_invite(
&owner(&backend),
&Id::from(ACCOUNT_ID),
&Id::from(INVITE_ID),
&UTCDate::from("2026-01-02T00:00:00Z"),
)
.await
.unwrap();
assert_eq!(refusal, Err(InviteJoinRefusal::Exhausted));
assert_eq!(snapshot(&backend).await, before);
}
pub async fn concurrent_redemptions_increment_exactly_once<B: ConformanceBackend>(backend: B) {
const RACERS: usize = 32;
seeded(&backend, 0, 100).await;
let backend = Arc::new(backend);
let tasks: Vec<_> = (0..RACERS)
.map(|_| {
let backend = Arc::clone(&backend);
tokio::spawn(async move {
backend
.join_space_with_invite(
&owner(&*backend),
&Id::from(ACCOUNT_ID),
&Id::from(INVITE_ID),
&UTCDate::from("2026-01-02T00:00:00Z"),
)
.await
.unwrap()
})
})
.collect();
let mut outcomes = Vec::with_capacity(RACERS);
for t in tasks {
outcomes.push(t.await.unwrap());
}
assert_eq!(outcomes.iter().filter(|o| o.is_ok()).count(), 1);
assert!(
outcomes
.iter()
.all(|o| *o == Ok(()) || *o == Err(InviteJoinRefusal::AlreadyMember))
);
let (members, uses, _, _) = snapshot(&*backend).await;
assert_eq!(members, vec![ACCOUNT_ID.to_owned()]);
assert_eq!(uses, 1);
}
}
mod message_atomic {
use jmap_server::HandlerOutput;
use jmap_types::{Id, State};
use serde_json::{Value, json};
use super::{ACCOUNT_ID, ConformanceBackend, make_received, owner, seed_group_chat, setup};
use crate::OutboundEvent;
use crate::message::{handle_message_changes, handle_message_get, handle_message_set};
async fn seeded_burn<B: ConformanceBackend>(backend: &B) -> String {
setup(backend).await;
seed_group_chat(backend, "c1").await;
let HandlerOutput { primary: resp, .. } = handle_message_set(
backend,
&owner(backend),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": {
"m0": {
"chatId": "c1",
"body": "burn me",
"sentAt": "2024-01-01T00:00:00Z",
"burnOnRead": true
}
}
}),
&[],
)
.await
.expect("create");
let id = resp["created"]["m0"]["id"]
.as_str()
.expect("created id")
.to_owned();
make_received(backend, &id).await;
id
}
async fn set_update<B: ConformanceBackend>(backend: &B, id: &str, patch: Value) -> Value {
handle_message_set(
backend,
&owner(backend),
&std::collections::BTreeMap::new(),
json!({ "accountId": ACCOUNT_ID, "update": { id: patch } }),
&[],
)
.await
.expect("Message/set")
.primary
}
async fn get<B: ConformanceBackend>(backend: &B, id: &str) -> Value {
handle_message_get(
backend,
&owner(backend),
json!({ "accountId": ACCOUNT_ID, "ids": [id] }),
&[],
)
.await
.expect("Message/get")
.primary
}
async fn burn_state<B: ConformanceBackend>(backend: &B, id: &str) -> String {
get(backend, id).await["state"]
.as_str()
.expect("state")
.to_owned()
}
pub async fn invalid_read_at_patch_is_rejected_without_burning<B: ConformanceBackend>(
backend: B,
) {
let id = seeded_burn(&backend).await;
let before = burn_state(&backend, &id).await;
let resp = set_update(&backend, &id, json!({ "readAt": 42 })).await;
assert_eq!(
resp["notUpdated"][&id]["type"], "invalidProperties",
"resp: {resp}"
);
let still = get(&backend, &id).await;
assert_eq!(still["list"][0]["id"], json!(id), "{still}");
assert_eq!(still["list"][0]["readAt"], Value::Null, "{still}");
assert_eq!(still["state"], json!(before), "no state change");
}
async fn state<B: ConformanceBackend>(backend: &B) -> State {
backend
.get_state::<jmap_chat_types::Message>(&owner(backend), &Id::from(ACCOUNT_ID))
.await
.expect("Message state")
}
async fn create<B: ConformanceBackend>(backend: &B) -> Value {
let HandlerOutput { primary, .. } = handle_message_set(
backend,
&owner(backend),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"create": { "c": {
"chatId": "g1",
"body": "hi",
"bodyType": "text/plain",
"sentAt": "2026-01-02T00:00:00Z",
} },
}),
&[],
)
.await
.expect("Message/set");
primary
}
async fn stored_ids<B: ConformanceBackend>(backend: &B) -> Vec<Value> {
let HandlerOutput { primary, .. } = handle_message_get(
backend,
&owner(backend),
json!({ "accountId": ACCOUNT_ID, "ids": null, "properties": ["id"] }),
&[],
)
.await
.expect("Message/get");
primary["list"]
.as_array()
.expect("list")
.iter()
.map(|m| m["id"].clone())
.collect()
}
pub async fn create_message_stores_and_reports_one_new_message<B: ConformanceBackend>(
backend: B,
) {
setup(&backend).await;
seed_group_chat(&backend, "g1").await;
if backend.take_outbound_events().is_none() {
return;
}
let take_events = || {
backend
.take_outbound_events()
.expect("take_outbound_events returned Some before")
};
let before = state(&backend).await;
let resp = create(&backend).await;
let created = &resp["created"]["c"];
let id = created["id"].as_str().expect("created id").to_owned();
assert_eq!(created["senderMsgId"], json!(id), "{resp}");
assert_eq!(resp["notCreated"], Value::Null, "{resp}");
assert_eq!(stored_ids(&backend).await, vec![json!(id)]);
let HandlerOutput {
primary: changes, ..
} = handle_message_changes(
&backend,
&owner(&backend),
json!({ "accountId": ACCOUNT_ID, "sinceState": before }),
&[],
)
.await
.expect("Message/changes");
assert_eq!(changes["created"], json!([id]), "{changes}");
assert_eq!(changes["updated"], json!([]), "{changes}");
assert_eq!(changes["destroyed"], json!([]), "{changes}");
assert_eq!(
take_events(),
vec![OutboundEvent::NewMessage {
chat_id: Id::from("g1"),
message_id: Id::from(id.as_str()),
sender_msg_id: Id::from(id.as_str()),
}]
);
}
}
mod contact_identity {
use jmap_server::HandlerOutput;
use serde_json::{Value, json};
use super::{ACCOUNT_ID, ConformanceBackend, owner, seed, setup};
use crate::{handle_contact_get, handle_contact_query, handle_contact_set};
async fn insert_contact<B: ConformanceBackend>(backend: &B, id: &str, identity: &str) {
seed(
backend,
"ChatContact",
json!({
"id": id,
"identity": identity,
"login": identity,
"firstSeenAt": "2026-01-01T00:00:00Z",
"lastSeenAt": "2026-01-01T00:00:00Z",
"blocked": false
}),
)
.await;
}
async fn create<B: ConformanceBackend>(backend: &B, create: Value) -> Value {
let HandlerOutput { primary: resp, .. } = handle_contact_set(
backend,
&owner(backend),
json!({ "accountId": ACCOUNT_ID, "create": create }),
)
.await
.expect("ChatContact/set");
resp
}
fn error_properties(err: &Value) -> Vec<String> {
let mut props: Vec<String> = err["properties"]
.as_array()
.unwrap_or_else(|| panic!("properties missing from {err}"))
.iter()
.map(|p| p.as_str().expect("property name").to_owned())
.collect();
props.sort();
props
}
pub async fn contact_create_by_identity_assigns_id<B: ConformanceBackend>(backend: B) {
setup(&backend).await;
let resp = create(
&backend,
json!({ "k1": { "identity": "alice@example.com" } }),
)
.await;
assert!(
resp["notCreated"].is_null(),
"create with identity must succeed: {}",
resp["notCreated"]
);
let id = resp["created"]["k1"]["id"]
.as_str()
.unwrap_or_else(|| panic!("created.k1.id missing: {resp}"))
.to_owned();
let HandlerOutput { primary: get, .. } = handle_contact_get(
&backend,
&owner(&backend),
json!({ "accountId": ACCOUNT_ID, "ids": [&id] }),
)
.await
.expect("ChatContact/get");
assert_eq!(get["list"][0]["id"], json!(id));
assert_eq!(get["list"][0]["identity"], json!("alice@example.com"));
}
pub async fn contact_create_existing_identity_already_exists<B: ConformanceBackend>(
backend: B,
) {
setup(&backend).await;
insert_contact(&backend, "ct1", "alice@example.com").await;
let resp = create(
&backend,
json!({ "k1": { "identity": "alice@example.com" } }),
)
.await;
assert!(resp["created"]["k1"].is_null(), "duplicate created: {resp}");
assert_eq!(resp["notCreated"]["k1"]["type"], json!("alreadyExists"));
assert_eq!(resp["notCreated"]["k1"]["existingId"], json!("ct1"));
}
pub async fn contact_create_without_identity_invalid_properties<B: ConformanceBackend>(
backend: B,
) {
setup(&backend).await;
let resp = create(&backend, json!({ "k1": {} })).await;
assert!(
resp["created"]["k1"].is_null(),
"created without identity: {resp}"
);
assert_eq!(resp["notCreated"]["k1"]["type"], json!("invalidProperties"));
assert_eq!(error_properties(&resp["notCreated"]["k1"]), ["identity"]);
}
pub async fn contact_create_other_properties_invalid_properties<B: ConformanceBackend>(
backend: B,
) {
setup(&backend).await;
let resp = create(
&backend,
json!({
"k1": {
"identity": "alice@example.com",
"login": "alice",
"blocked": true,
"displayName": "Alice"
}
}),
)
.await;
assert!(
resp["created"]["k1"].is_null(),
"created with extras: {resp}"
);
assert_eq!(resp["notCreated"]["k1"]["type"], json!("invalidProperties"));
assert_eq!(
error_properties(&resp["notCreated"]["k1"]),
["blocked", "displayName", "login"]
);
let retry = create(
&backend,
json!({ "k2": { "identity": "alice@example.com" } }),
)
.await;
assert!(
retry["created"]["k2"]["id"].is_string(),
"identity must still be creatable: {retry}"
);
}
pub async fn contact_query_identity_filter_matches_octet_for_octet<B: ConformanceBackend>(
backend: B,
) {
setup(&backend).await;
insert_contact(&backend, "ct1", "alice@example.com").await;
insert_contact(&backend, "ct2", "Alice@example.com").await;
insert_contact(&backend, "ct3", "bob@example.com").await;
let HandlerOutput { primary: resp, .. } = handle_contact_query(
&backend,
&owner(&backend),
json!({
"accountId": ACCOUNT_ID,
"filter": { "identity": "alice@example.com" }
}),
)
.await
.expect("ChatContact/query");
assert_eq!(resp["ids"], json!(["ct1"]));
}
}
mod threads {
use jmap_server::HandlerOutput;
use serde_json::{Value, json};
use super::{ACCOUNT_ID, ConformanceBackend, owner, seed, setup, supports_threads};
use crate::handle_chat_set;
use crate::handle_position_set;
use crate::message::{handle_message_changes, handle_message_get, handle_message_set};
const ROOT: &str = "01J0000000000000000000000A";
const A: &str = "01J0000000000000000000000B";
const B: &str = "01J0000000000000000000000C";
const C: &str = "01J0000000000000000000000D";
const OTHER_CHAT_MSG: &str = "01J0000000000000000000000E";
const OTHER_SENDER: &str = "contact-bob";
async fn create_group<K: ConformanceBackend>(backend: &K) -> String {
let HandlerOutput { primary: resp, .. } = handle_chat_set(
backend,
&owner(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()
}
async fn seed_message<K: ConformanceBackend>(
backend: &K,
id: &str,
chat_id: &str,
reply_to: Option<&str>,
root: Option<&str>,
) {
let mut msg = json!({
"id": id,
"senderMsgId": id,
"senderId": OTHER_SENDER,
"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);
}
seed(backend, "Message", msg).await;
}
async fn fixture<K: ConformanceBackend>(backend: &K) -> (String, String) {
setup(backend).await;
let chat = create_group(backend).await;
let other = create_group(backend).await;
seed_message(backend, ROOT, &chat, None, None).await;
seed_message(backend, A, &chat, Some(ROOT), Some(ROOT)).await;
seed_message(backend, B, &chat, Some(A), Some(ROOT)).await;
seed_message(backend, C, &chat, Some(ROOT), Some(ROOT)).await;
seed_message(backend, OTHER_CHAT_MSG, &other, None, None).await;
seed(
backend,
"ReadPosition",
json!({
"id": "rp1",
"chatId": chat,
"lastReadMessageId": A,
"lastReadAt": "2024-01-01T00:00:00Z",
}),
)
.await;
(chat, other)
}
async fn create<K: ConformanceBackend>(backend: &K, obj: Value) -> Value {
let HandlerOutput { primary: resp, .. } = handle_message_set(
backend,
&owner(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<K: ConformanceBackend>(backend: &K, ids: &[&str]) -> Vec<Value> {
let HandlerOutput { primary: resp, .. } = handle_message_get(
backend,
&owner(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:?}"))
}
pub async fn reply_counts_match_fixture<K: ConformanceBackend>(backend: K) {
if !supports_threads(&backend) {
return;
}
let _ = fixture(&backend).await;
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}");
}
}
pub async fn unread_reply_count_without_read_position<K: ConformanceBackend>(backend: K) {
if !supports_threads(&backend) {
return;
}
let (chat, _) = fixture(&backend).await;
seed(
&backend,
"ReadPosition",
json!({ "id": "rp1", "chatId": chat }),
)
.await;
let list = get(&backend, &[ROOT]).await;
assert_eq!(list[0]["unreadReplyCount"], 2, "{list:?}");
}
pub async fn counts_absent_without_supports_threads<K: ConformanceBackend>(backend: K) {
if supports_threads(&backend) {
return;
}
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}");
}
}
async fn message_state<K: ConformanceBackend>(backend: &K) -> String {
let HandlerOutput { primary: resp, .. } = handle_message_get(
backend,
&owner(backend),
json!({ "accountId": ACCOUNT_ID, "ids": [] }),
&[],
)
.await
.expect("Message/get");
resp["state"].as_str().expect("state").to_owned()
}
async fn message_changes<K: ConformanceBackend>(backend: &K, since: &str) -> Value {
let HandlerOutput { primary: resp, .. } = handle_message_changes(
backend,
&owner(backend),
json!({ "accountId": ACCOUNT_ID, "sinceState": since }),
&[],
)
.await
.expect("Message/changes");
resp
}
pub async fn reply_create_lists_parent_updated<K: ConformanceBackend>(backend: K) {
if !supports_threads(&backend) {
return;
}
let (chat, _) = fixture(&backend).await;
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}");
}
pub async fn reply_destroy_lists_parent_updated<K: ConformanceBackend>(backend: K) {
if !supports_threads(&backend) {
return;
}
let _ = fixture(&backend).await;
let since = message_state(&backend).await;
let HandlerOutput { primary: resp, .. } = handle_message_set(
&backend,
&owner(&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}");
}
pub async fn read_position_update_lists_thread_root_updated<K: ConformanceBackend>(backend: K) {
if !supports_threads(&backend) {
return;
}
let _ = fixture(&backend).await;
let since = message_state(&backend).await;
let HandlerOutput { primary: resp, .. } = handle_position_set(
&backend,
&owner(&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}");
}
}
mod expiry {
use std::time::{Duration, SystemTime, UNIX_EPOCH};
use jmap_types::Id;
use serde_json::{Value, json};
use super::{ACCOUNT_ID, ConformanceBackend, exact_unread_count, owner, seed, setup};
use crate::message::{handle_message_changes, handle_message_get};
use crate::{handle_chat_changes, handle_chat_get, handle_presence_get, sweep_expired};
const T0: u64 = 1_704_067_200;
const T0_STR: &str = "2024-01-01T00:00:00Z";
fn at(offset_secs: u64) -> SystemTime {
UNIX_EPOCH + Duration::from_secs(T0 + offset_secs)
}
async fn seed_chat<B: ConformanceBackend>(b: &B, id: &str, extra: Value) {
let mut chat = json!({
"id": id,
"kind": "direct",
"contactId": "contact1",
"createdAt": T0_STR,
"unreadCount": 0,
"pinnedMessageIds": [],
});
chat.as_object_mut()
.expect("object literal")
.extend(extra.as_object().expect("object literal").clone());
seed(b, "Chat", chat).await;
}
async fn seed_message<B: ConformanceBackend>(b: &B, id: &str, chat_id: &str, extra: Value) {
let mut msg = json!({
"id": id,
"senderMsgId": id,
"senderId": "other",
"chatId": chat_id,
"body": "x",
"bodyType": "text/plain",
"attachments": [],
"sentAt": T0_STR,
"receivedAt": T0_STR,
"deliveryState": "delivered",
});
msg.as_object_mut()
.expect("object literal")
.extend(extra.as_object().expect("object literal").clone());
seed(b, "Message", msg).await;
}
async fn sweep<B: ConformanceBackend>(b: &B, now: SystemTime) {
sweep_expired(b, &owner(b), &Id::from(ACCOUNT_ID), now)
.await
.expect("sweep");
}
async fn message_exists<B: ConformanceBackend>(b: &B, id: &str) -> bool {
let resp = handle_message_get(
b,
&owner(b),
json!({ "accountId": ACCOUNT_ID, "ids": [id] }),
&[],
)
.await
.expect("Message/get")
.primary;
resp["list"].as_array().expect("list").len() == 1
}
async fn chat<B: ConformanceBackend>(b: &B, id: &str) -> Value {
let resp = handle_chat_get(
b,
&owner(b),
json!({ "accountId": ACCOUNT_ID, "ids": [id] }),
&[],
)
.await
.expect("Chat/get")
.primary;
resp["list"][0].clone()
}
pub async fn sender_expires_at_hard_deletes_at_deadline<B: ConformanceBackend>(b: B) {
setup(&b).await;
seed_chat(&b, "c1", json!({})).await;
seed_message(
&b,
"m1",
"c1",
json!({ "senderExpiresAt": "2024-01-01T00:00:10Z" }),
)
.await;
let state = handle_message_get(
&b,
&owner(&b),
json!({ "accountId": ACCOUNT_ID, "ids": [] }),
&[],
)
.await
.expect("Message/get")
.primary["state"]
.clone();
sweep(&b, at(9)).await;
assert!(
message_exists(&b, "m1").await,
"deadline not reached at T+9"
);
sweep(&b, at(10)).await;
assert!(!message_exists(&b, "m1").await, "deleted at the deadline");
let changes = handle_message_changes(
&b,
&owner(&b),
json!({ "accountId": ACCOUNT_ID, "sinceState": state }),
&[],
)
.await
.expect("Message/changes")
.primary;
assert_eq!(changes["destroyed"], json!(["m1"]));
assert_eq!(changes["updated"], json!([]));
}
pub async fn message_expiry_seconds_deletes_messages_older_than_policy<
B: ConformanceBackend,
>(
b: B,
) {
setup(&b).await;
seed_chat(&b, "c1", json!({ "messageExpirySeconds": 60 })).await;
seed_chat(&b, "c0", json!({ "messageExpirySeconds": 0 })).await;
seed_message(&b, "m1", "c1", json!({})).await;
seed_message(&b, "m0", "c0", json!({})).await;
sweep(&b, at(60)).await;
assert!(
message_exists(&b, "m1").await,
"exactly 60s old is not older than 60s"
);
sweep(&b, at(61)).await;
assert!(!message_exists(&b, "m1").await, "61s old is older than 60s");
assert!(
message_exists(&b, "m0").await,
"zero policy deletes nothing"
);
}
pub async fn expires_after_read_seconds_counts_from_read_at<B: ConformanceBackend>(b: B) {
setup(&b).await;
seed_chat(&b, "c1", json!({})).await;
seed_message(
&b,
"read",
"c1",
json!({ "expiresAfterReadSeconds": 30, "readAt": "2024-01-01T00:01:40Z" }),
)
.await;
seed_message(&b, "unread", "c1", json!({ "expiresAfterReadSeconds": 30 })).await;
sweep(&b, at(129)).await;
assert!(message_exists(&b, "read").await, "29s after readAt");
sweep(&b, at(130)).await;
assert!(!message_exists(&b, "read").await, "30s after readAt");
assert!(
message_exists(&b, "unread").await,
"never read, never expires"
);
}
pub async fn read_burn_on_read_message_is_deleted<B: ConformanceBackend>(b: B) {
setup(&b).await;
seed_chat(&b, "c1", json!({})).await;
seed_message(
&b,
"burn",
"c1",
json!({ "burnOnRead": true, "readAt": T0_STR }),
)
.await;
seed_message(&b, "unread", "c1", json!({ "burnOnRead": true })).await;
sweep(&b, at(0)).await;
assert!(!message_exists(&b, "burn").await);
assert!(message_exists(&b, "unread").await, "not yet read");
}
pub async fn read_rules_spare_the_senders_own_copy<B: ConformanceBackend>(b: B) {
setup(&b).await;
seed_chat(&b, "c1", json!({})).await;
seed_message(
&b,
"own-timed",
"c1",
json!({
"senderId": ACCOUNT_ID,
"expiresAfterReadSeconds": 30,
"readAt": T0_STR,
}),
)
.await;
seed_message(
&b,
"own-burn",
"c1",
json!({ "senderId": ACCOUNT_ID, "burnOnRead": true, "readAt": T0_STR }),
)
.await;
sweep(&b, at(3600)).await;
assert!(message_exists(&b, "own-timed").await, "own copy kept");
assert!(message_exists(&b, "own-burn").await, "own copy kept");
}
pub async fn mute_until_clears_muted_and_mute_until<B: ConformanceBackend>(b: B) {
setup(&b).await;
seed_chat(
&b,
"c1",
json!({ "muted": true, "muteUntil": "2024-01-01T00:00:05Z" }),
)
.await;
sweep(&b, at(4)).await;
let before = chat(&b, "c1").await;
assert_eq!(before["muted"], json!(true));
assert_eq!(before["muteUntil"], json!("2024-01-01T00:00:05Z"));
sweep(&b, at(5)).await;
let after = chat(&b, "c1").await;
assert_eq!(after["muted"], json!(false));
assert!(
after.get("muteUntil").is_none_or(Value::is_null),
"muteUntil cleared: {after}"
);
}
pub async fn presence_expires_at_resets_status<B: ConformanceBackend>(b: B) {
setup(&b).await;
seed(
&b,
"PresenceStatus",
json!({
"id": "p1",
"presence": "busy",
"receiptSharing": true,
"updatedAt": T0_STR,
"statusText": "In a meeting",
"statusEmoji": ":calendar:",
"expiresAt": "2024-01-01T01:00:00Z",
}),
)
.await;
let get = || async {
handle_presence_get(
&b,
&owner(&b),
json!({ "accountId": ACCOUNT_ID, "ids": ["p1"] }),
)
.await
.expect("PresenceStatus/get")
.primary["list"][0]
.clone()
};
sweep(&b, at(3599)).await;
let before = get().await;
assert_eq!(before["presence"], json!("busy"));
assert_eq!(before["statusText"], json!("In a meeting"));
sweep(&b, at(3600)).await;
let after = get().await;
assert_eq!(after["presence"], json!("online"));
assert!(
after.get("statusText").is_none_or(Value::is_null),
"{after}"
);
assert!(
after.get("statusEmoji").is_none_or(Value::is_null),
"{after}"
);
}
async fn chat_state<B: ConformanceBackend>(b: &B) -> Value {
handle_chat_get(
b,
&owner(b),
json!({ "accountId": ACCOUNT_ID, "ids": [] }),
&[],
)
.await
.expect("Chat/get")
.primary["state"]
.clone()
}
pub async fn expiry_records_chat_unread_count_change<B: ConformanceBackend>(b: B) {
if !exact_unread_count(&b) {
return;
}
setup(&b).await;
seed_chat(&b, "c1", json!({})).await;
seed_chat(&b, "c2", json!({})).await;
seed_message(
&b,
"m1",
"c1",
json!({ "senderExpiresAt": "2024-01-01T00:00:10Z" }),
)
.await;
seed_message(&b, "m2", "c2", json!({})).await;
let since = chat_state(&b).await;
sweep(&b, at(10)).await;
assert_eq!(chat(&b, "c1").await["unreadCount"], json!(0));
assert_eq!(chat(&b, "c2").await["unreadCount"], json!(1));
let changes = handle_chat_changes(
&b,
&owner(&b),
json!({ "accountId": ACCOUNT_ID, "sinceState": since }),
&[],
)
.await
.expect("Chat/changes")
.primary;
assert_eq!(changes["updated"], json!(["c1"]), "{changes}");
let after = chat_state(&b).await;
sweep(&b, at(10)).await;
assert_eq!(chat_state(&b).await, after, "re-run changes no state");
}
}
mod read_position {
use jmap_chat_types::{DeliveryState, Message};
use jmap_server::HandlerOutput;
use jmap_types::{Id, UTCDate};
use serde_json::{Value, json};
use super::{ACCOUNT_ID, ConformanceBackend, exact_unread_count, owner, seed, setup};
use crate::message::{StoreOutcome, handle_message_set, store_server_message};
use crate::{
handle_chat_changes, handle_chat_get, handle_chat_set, handle_position_changes,
handle_position_get, handle_position_set, handle_space_join, handle_space_set,
};
const M1: &str = "01J0000000000000000000000A";
const M2: &str = "01J0000000000000000000000B";
const M3: &str = "01J0000000000000000000000C";
const M4: &str = "01J0000000000000000000000D";
const M5: &str = "01J0000000000000000000000E";
const OTHER_MSG: &str = "01J0000000000000000000000F";
const OTHER_SENDER: &str = "contact-bob";
const SEEDED_READ_AT: &str = "2000-01-01T00:00:00Z";
const SPACE_ID: &str = "s1";
const OTHER_SPACE_ID: &str = "space2";
async fn seed_chat<B: ConformanceBackend>(backend: &B, id: &str, extra: Value) {
let mut chat = json!({
"id": id,
"createdAt": "2026-01-01T00:00:00Z",
"unreadCount": 0,
"pinnedMessageIds": [],
});
let (Value::Object(chat_map), Value::Object(extra_map)) = (&mut chat, extra) else {
unreachable!("both are object literals");
};
chat_map.extend(extra_map);
seed(backend, "Chat", chat).await;
}
async fn seed_group<B: ConformanceBackend>(backend: &B, id: &str) {
seed_chat(
backend,
id,
json!({
"kind": "group",
"name": "G",
"members": [{ "id": ACCOUNT_ID, "role": "admin", "joinedAt": "2026-01-01T00:00:00Z" }],
}),
)
.await;
}
async fn seed_message<B: ConformanceBackend>(backend: &B, id: &str, chat_id: &str) {
seed(
backend,
"Message",
json!({
"id": id,
"senderMsgId": id,
"senderId": OTHER_SENDER,
"chatId": chat_id,
"body": "x",
"bodyType": "text/plain",
"attachments": [],
"sentAt": "2026-01-01T00:00:00Z",
"receivedAt": "2026-01-01T00:00:00Z",
"deliveryState": "delivered",
}),
)
.await;
}
async fn seed_position<B: ConformanceBackend>(backend: &B, id: &str, chat_id: &str) {
seed(
backend,
"ReadPosition",
json!({ "id": id, "chatId": chat_id, "lastReadAt": SEEDED_READ_AT }),
)
.await;
}
async fn seed_five<B: ConformanceBackend>(backend: &B) {
setup(backend).await;
seed_group(backend, "g").await;
seed_group(backend, "h").await;
for m in [M1, M2, M3, M4, M5] {
seed_message(backend, m, "g").await;
}
seed_message(backend, OTHER_MSG, "h").await;
seed_position(backend, "rp-g", "g").await;
}
async fn unread_counts<B: ConformanceBackend>(backend: &B, args: Value) -> Vec<Value> {
let HandlerOutput { primary: resp, .. } =
handle_chat_get(backend, &owner(backend), args, &[])
.await
.expect("Chat/get");
resp["list"].as_array().expect("list").clone()
}
async fn unread_of<B: ConformanceBackend>(backend: &B, chat_id: &str) -> Value {
let list = unread_counts(
backend,
json!({ "accountId": ACCOUNT_ID, "ids": [chat_id] }),
)
.await;
assert_eq!(list.len(), 1, "{list:?}");
list[0]["unreadCount"].clone()
}
async fn set_last_read<B: ConformanceBackend>(backend: &B, rp: &str, patch: Value) -> Value {
let HandlerOutput { primary: resp, .. } = handle_position_set(
backend,
&owner(backend),
&std::collections::BTreeMap::new(),
json!({ "accountId": ACCOUNT_ID, "update": { rp: patch } }),
)
.await
.expect("ReadPosition/set");
resp
}
async fn positions<B: ConformanceBackend>(backend: &B) -> Vec<Value> {
let HandlerOutput { primary: resp, .. } =
handle_position_get(backend, &owner(backend), json!({ "accountId": ACCOUNT_ID }))
.await
.expect("ReadPosition/get");
resp["list"].as_array().expect("list").clone()
}
async fn position_chat_ids<B: ConformanceBackend>(backend: &B) -> Vec<String> {
let mut ids: Vec<String> = positions(backend)
.await
.iter()
.map(|p| p["chatId"].as_str().expect("chatId").to_owned())
.collect();
ids.sort();
ids
}
async fn position_state<B: ConformanceBackend>(backend: &B) -> String {
let HandlerOutput { primary: resp, .. } = handle_position_get(
backend,
&owner(backend),
json!({ "accountId": ACCOUNT_ID, "ids": [] }),
)
.await
.expect("ReadPosition/get");
resp["state"].as_str().expect("state").to_owned()
}
async fn destroyed_positions_since<B: ConformanceBackend>(
backend: &B,
since: &str,
) -> Vec<Value> {
let HandlerOutput { primary: resp, .. } = handle_position_changes(
backend,
&owner(backend),
json!({ "accountId": ACCOUNT_ID, "sinceState": since }),
)
.await
.expect("ReadPosition/changes");
resp["destroyed"].as_array().expect("destroyed").clone()
}
pub async fn absent_last_read_counts_every_message<B: ConformanceBackend>(backend: B) {
if !exact_unread_count(&backend) {
return;
}
seed_five(&backend).await;
assert_eq!(unread_of(&backend, "g").await, 5);
assert_eq!(unread_of(&backend, "h").await, 1);
}
pub async fn compliance_11_1_unread_count_from_read_position<B: ConformanceBackend>(
backend: B,
) {
if !exact_unread_count(&backend) {
return;
}
seed_five(&backend).await;
let resp = set_last_read(&backend, "rp-g", json!({ "lastReadMessageId": M3 })).await;
assert!(resp["updated"].get("rp-g").is_some(), "{resp}");
assert_eq!(unread_of(&backend, "g").await, 2);
assert_eq!(unread_of(&backend, "h").await, 1, "other Chat unaffected");
set_last_read(&backend, "rp-g", json!({ "lastReadMessageId": M5 })).await;
assert_eq!(unread_of(&backend, "g").await, 0);
}
pub async fn compliance_11_1_with_assigned_ids<B: ConformanceBackend>(backend: B) {
const CROCKFORD: &str = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
if !exact_unread_count(&backend) {
return;
}
setup(&backend).await;
seed_group(&backend, "s").await;
seed_position(&backend, "rp-s", "s").await;
let mut sent = Vec::new();
for n in 0..5 {
let smid = Id::from(format!("smid-{n}"));
let outcome = store_server_message(
&backend,
&owner(&backend),
&Id::from(ACCOUNT_ID),
&Id::from("s"),
&smid,
|id: &Id| {
Message::new(
id.clone(),
Id::from("unused"),
Id::from(OTHER_SENDER),
Id::from("unused"),
"hi",
"text/plain",
UTCDate::from("2026-01-01T00:00:00Z"),
UTCDate::from("2026-01-01T00:00:00Z"),
DeliveryState::Delivered,
)
},
)
.await
.expect("store_server_message");
let StoreOutcome::Stored(id) = outcome else {
panic!("message {n} reported as a duplicate");
};
let id = id.as_ref();
assert_eq!(id.len(), 26, "{id}");
assert!(id.chars().all(|c| CROCKFORD.contains(c)), "{id}");
sent.push(id.to_owned());
}
set_last_read(&backend, "rp-s", json!({ "lastReadMessageId": sent[2] })).await;
assert_eq!(unread_of(&backend, "s").await, 2, "{sent:?}");
}
pub async fn unread_count_in_full_get<B: ConformanceBackend>(backend: B) {
if !exact_unread_count(&backend) {
return;
}
seed_five(&backend).await;
set_last_read(&backend, "rp-g", json!({ "lastReadMessageId": M4 })).await;
let list = unread_counts(&backend, json!({ "accountId": ACCOUNT_ID })).await;
let count = |id: &str| {
list.iter()
.find(|c| c["id"] == id)
.unwrap_or_else(|| panic!("{id} missing: {list:?}"))["unreadCount"]
.clone()
};
assert_eq!(count("g"), 1);
assert_eq!(count("h"), 1);
}
pub async fn read_position_set_updates_last_read_at<B: ConformanceBackend>(backend: B) {
seed_five(&backend).await;
set_last_read(&backend, "rp-g", json!({ "lastReadMessageId": M2 })).await;
let list = positions(&backend).await;
let rp = list.iter().find(|p| p["id"] == "rp-g").expect("rp-g");
assert_eq!(rp["lastReadMessageId"], M2, "{rp}");
let read_at = rp["lastReadAt"].as_str().expect("lastReadAt is a UTCDate");
assert_ne!(read_at, SEEDED_READ_AT, "{rp}");
assert!(
read_at > "2026-01-01T00:00:00Z",
"{read_at} is not the current time"
);
}
pub async fn client_last_read_at_is_rejected<B: ConformanceBackend>(backend: B) {
seed_five(&backend).await;
let resp = set_last_read(
&backend,
"rp-g",
json!({ "lastReadMessageId": M2, "lastReadAt": "2030-01-01T00:00:00Z" }),
)
.await;
assert_eq!(
resp["notUpdated"]["rp-g"]["type"], "invalidProperties",
"{resp}"
);
assert_eq!(
resp["notUpdated"]["rp-g"]["properties"],
json!(["lastReadAt"]),
"{resp}"
);
let list = positions(&backend).await;
assert_eq!(list[0]["lastReadAt"], SEEDED_READ_AT, "{list:?}");
assert!(list[0].get("lastReadMessageId").is_none(), "{list:?}");
}
pub async fn chat_destroy_destroys_its_read_position<B: ConformanceBackend>(backend: B) {
seed_five(&backend).await;
seed_position(&backend, "rp-h", "h").await;
let since = position_state(&backend).await;
let HandlerOutput { primary: resp, .. } = handle_chat_set(
&backend,
&owner(&backend),
&std::collections::BTreeMap::new(),
json!({ "accountId": ACCOUNT_ID, "destroy": ["g"] }),
&[],
)
.await
.expect("Chat/set");
assert_eq!(resp["destroyed"], json!(["g"]), "{resp}");
assert_eq!(position_chat_ids(&backend).await, vec!["h"]);
assert_eq!(
destroyed_positions_since(&backend, &since).await,
vec![json!("rp-g")]
);
}
async fn seed_space_with_channels<B: ConformanceBackend>(
backend: &B,
is_public: bool,
owner_member: bool,
) {
setup(backend).await;
let mut members = vec![json!({
"id": "preseeded-admin", "roleIds": ["r-admin"], "joinedAt": "2026-01-01T00:00:00Z"
})];
if owner_member {
members.push(json!({
"id": ACCOUNT_ID, "roleIds": ["r-admin"], "joinedAt": "2026-01-01T00:00:00Z"
}));
}
for space_id in [SPACE_ID, OTHER_SPACE_ID] {
seed(
backend,
"Space",
json!({
"id": space_id,
"name": "S",
"createdAt": "2026-01-01T00:00:00Z",
"memberCount": members.len(),
"categories": [],
"uncategorizedChannelIds": [],
"isPublic": is_public,
"isPubliclyPreviewable": false,
"roles": [{
"id": "r-admin",
"name": "Admin",
"permissions": ["manage_space", "manage_channels", "view"],
"position": 1
}],
"members": members,
}),
)
.await;
}
seed_chat(
backend,
"ch1",
json!({ "kind": "channel", "name": "a", "spaceId": SPACE_ID }),
)
.await;
seed_chat(
backend,
"ch2",
json!({ "kind": "channel", "name": "b", "spaceId": SPACE_ID }),
)
.await;
seed_chat(
backend,
"other",
json!({ "kind": "channel", "name": "c", "spaceId": OTHER_SPACE_ID }),
)
.await;
}
pub async fn space_join_creates_read_positions_for_its_channels<B: ConformanceBackend>(
backend: B,
) {
seed_space_with_channels(&backend, true, false).await;
assert!(positions(&backend).await.is_empty());
handle_space_join(
&backend,
&owner(&backend),
json!({ "accountId": ACCOUNT_ID, "spaceId": SPACE_ID }),
)
.await
.expect("Space/join");
assert_eq!(position_chat_ids(&backend).await, vec!["ch1", "ch2"]);
for p in positions(&backend).await {
assert!(p.get("lastReadMessageId").is_none(), "{p}");
}
}
pub async fn remove_channels_destroys_their_read_positions<B: ConformanceBackend>(backend: B) {
seed_space_with_channels(&backend, false, true).await;
seed_position(&backend, "rp1", "ch1").await;
seed_position(&backend, "rp2", "ch2").await;
seed_position(&backend, "rp3", "other").await;
let since = position_state(&backend).await;
let HandlerOutput { primary: resp, .. } = handle_space_set(
&backend,
&owner(&backend),
&std::collections::BTreeMap::new(),
json!({
"accountId": ACCOUNT_ID,
"update": { SPACE_ID: { "removeChannels": ["ch1"] } }
}),
&[],
)
.await
.expect("Space/set");
assert!(resp["updated"].get(SPACE_ID).is_some(), "{resp}");
assert_eq!(position_chat_ids(&backend).await, vec!["ch2", "other"]);
assert_eq!(
destroyed_positions_since(&backend, &since).await,
vec![json!("rp1")]
);
}
pub async fn space_destroy_destroys_channel_read_positions<B: ConformanceBackend>(backend: B) {
seed_space_with_channels(&backend, false, true).await;
seed_position(&backend, "rp1", "ch1").await;
seed_position(&backend, "rp2", "ch2").await;
seed_position(&backend, "rp3", "other").await;
let since = position_state(&backend).await;
let HandlerOutput { primary: resp, .. } = handle_space_set(
&backend,
&owner(&backend),
&std::collections::BTreeMap::new(),
json!({ "accountId": ACCOUNT_ID, "destroy": [SPACE_ID] }),
&[],
)
.await
.expect("Space/set");
assert_eq!(resp["destroyed"], json!([SPACE_ID]), "{resp}");
assert_eq!(position_chat_ids(&backend).await, vec!["other"]);
let mut destroyed = destroyed_positions_since(&backend, &since).await;
destroyed.sort_by(|a, b| a.as_str().cmp(&b.as_str()));
assert_eq!(destroyed, vec![json!("rp1"), json!("rp2")]);
}
async fn chat_state<B: ConformanceBackend>(backend: &B) -> String {
let HandlerOutput { primary: resp, .. } = handle_chat_get(
backend,
&owner(backend),
json!({ "accountId": ACCOUNT_ID, "ids": [] }),
&[],
)
.await
.expect("Chat/get");
resp["state"].as_str().expect("state").to_owned()
}
async fn chats_updated_since<B: ConformanceBackend>(backend: &B, since: &str) -> Vec<Value> {
let HandlerOutput { primary: resp, .. } = handle_chat_changes(
backend,
&owner(backend),
json!({ "accountId": ACCOUNT_ID, "sinceState": since }),
&[],
)
.await
.expect("Chat/changes");
resp["updated"].as_array().expect("updated").clone()
}
async fn message_set<B: ConformanceBackend>(backend: &B, args: Value) -> Value {
let mut args = args;
args["accountId"] = json!(ACCOUNT_ID);
let HandlerOutput { primary: resp, .. } = handle_message_set(
backend,
&owner(backend),
&std::collections::BTreeMap::new(),
args,
&[],
)
.await
.expect("Message/set");
resp
}
pub async fn read_position_set_advances_chat_state<B: ConformanceBackend>(backend: B) {
if !exact_unread_count(&backend) {
return;
}
seed_five(&backend).await;
assert_eq!(unread_of(&backend, "g").await, 5);
let since = chat_state(&backend).await;
set_last_read(&backend, "rp-g", json!({ "lastReadMessageId": M3 })).await;
assert_eq!(unread_of(&backend, "g").await, 2);
assert_ne!(chat_state(&backend).await, since);
assert_eq!(
chats_updated_since(&backend, &since).await,
vec![json!("g")]
);
}
pub async fn message_destroy_advances_chat_state<B: ConformanceBackend>(backend: B) {
if !exact_unread_count(&backend) {
return;
}
seed_five(&backend).await;
let since = chat_state(&backend).await;
let resp = message_set(&backend, json!({ "destroy": [M5] })).await;
assert_eq!(resp["destroyed"], json!([M5]), "{resp}");
assert_eq!(unread_of(&backend, "g").await, 4);
assert_eq!(
chats_updated_since(&backend, &since).await,
vec![json!("g")]
);
}
}