mod common;
use common::{MemoryBackend, ACCOUNT_ID};
use jmap_chat_server::{
handle_message_get, handle_message_set, BackendSetError, ChatBackend, SetErrorType,
};
use jmap_chat_types::Message;
use jmap_server::HandlerOutput;
use jmap_types::{Id, PatchObject};
use serde_json::{json, Value};
async fn create_message(backend: &MemoryBackend) -> String {
let HandlerOutput { primary: resp, .. } = handle_message_set(
backend,
&(),
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(backend: &MemoryBackend, 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>(&(), &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(backend: &MemoryBackend, id: &str) -> Value {
let HandlerOutput { primary: resp, .. } = handle_message_get(
backend,
&(),
json!({ "accountId": ACCOUNT_ID, "ids": [id] }),
)
.await
.expect("get");
resp["list"][0].clone()
}
async fn message_with_receipt(backend: &MemoryBackend) -> 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
}
#[tokio::test]
async fn path_key_updates_nested_member() {
let backend = MemoryBackend::new();
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" },
})
);
}
#[tokio::test]
async fn top_level_object_value_replaces_property() {
let backend = MemoryBackend::new();
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" } })
);
}
#[tokio::test]
async fn path_through_absent_parent_is_invalid_patch() {
let backend = MemoryBackend::new();
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);
}
#[tokio::test]
async fn prefix_conflict_is_invalid_patch() {
let backend = MemoryBackend::new();
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 }))
}
#[tokio::test]
async fn path_depth_counts_toward_nesting_cap() {
let backend = MemoryBackend::new();
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);
}