mod common;
use common::{ACCOUNT_ID, INJECTABLE_BACKEND_CANARY, InjectableBackend, account_backend};
use jmap_chat_server::ChatBackend;
use jmap_chat_server::memory::MemoryBackend;
use jmap_chat_server::{
handle_contact_changes, handle_contact_get, handle_contact_query, handle_contact_set,
};
use jmap_server::HandlerOutput;
use jmap_types::JmapError;
use serde_json::{Value, json};
const CONTACT_ID: &str = "ct1";
fn seed_contact(backend: &MemoryBackend, id: &str, identity: &str) {
backend.insert_object_for_test(
"ChatContact",
ACCOUNT_ID,
id,
json!({
"id": id,
"identity": identity,
"login": identity,
"firstSeenAt": "2026-01-01T00:00:00Z",
"lastSeenAt": "2026-01-01T00:00:00Z",
"blocked": false,
}),
);
}
fn with_account(body: Value) -> Value {
let mut args = json!({ "accountId": ACCOUNT_ID });
let (Value::Object(args_map), Value::Object(body_map)) = (&mut args, body) else {
unreachable!("both are object literals");
};
args_map.extend(body_map);
args
}
async fn set<B: ChatBackend<CallerCtx = ()>>(backend: &B, body: Value) -> Result<Value, JmapError> {
handle_contact_set(backend, &(), with_account(body))
.await
.map(|HandlerOutput { primary, .. }| primary)
}
async fn query(body: Value) -> Result<Value, JmapError> {
handle_contact_query(&account_backend(), &(), with_account(body))
.await
.map(|HandlerOutput { primary, .. }| primary)
}
fn assert_error_type(result: Result<Value, JmapError>, expected: &str) {
let err = result.expect_err(expected);
assert_eq!(err.error_type.to_string(), expected, "{err:?}");
}
#[tokio::test]
async fn get_without_account_id_is_invalid_arguments() {
let result = handle_contact_get(&account_backend(), &(), json!({}))
.await
.map(|HandlerOutput { primary, .. }| primary);
assert_error_type(result, "invalidArguments");
}
#[tokio::test]
async fn get_unknown_id_is_reported_not_found() {
let backend = account_backend();
seed_contact(&backend, CONTACT_ID, "alice@example.com");
let HandlerOutput { primary: resp, .. } = handle_contact_get(
&backend,
&(),
with_account(json!({ "ids": [CONTACT_ID, "missing"] })),
)
.await
.expect("ChatContact/get");
assert_eq!(resp["notFound"], json!(["missing"]), "{resp:?}");
assert_eq!(resp["list"][0]["id"], CONTACT_ID, "{resp:?}");
assert_eq!(resp["list"].as_array().map(Vec::len), Some(1), "{resp:?}");
}
#[tokio::test]
async fn get_with_non_array_ids_is_invalid_arguments() {
let result = handle_contact_get(
&account_backend(),
&(),
with_account(json!({ "ids": "ct1" })),
)
.await
.map(|HandlerOutput { primary, .. }| primary);
assert_error_type(result, "invalidArguments");
}
#[tokio::test]
async fn get_backend_failure_is_server_fail_without_backend_text() {
let backend = InjectableBackend::new();
backend.inject("ChatContact", "get");
let err = handle_contact_get(&backend, &(), with_account(json!({})))
.await
.expect_err("injected get failure");
assert_eq!(err.error_type.to_string(), "serverFail", "{err:?}");
assert!(
!format!("{err:?}").contains(INJECTABLE_BACKEND_CANARY),
"leaked backend text: {err:?}"
);
}
#[tokio::test]
async fn changes_without_since_state_is_invalid_arguments() {
let result = handle_contact_changes(&account_backend(), &(), with_account(json!({})))
.await
.map(|HandlerOutput { primary, .. }| primary);
assert_error_type(result, "invalidArguments");
}
#[tokio::test]
async fn set_with_stale_if_in_state_is_state_mismatch() {
let result = set(
&account_backend(),
json!({ "ifInState": "not-the-state", "destroy": [CONTACT_ID] }),
)
.await;
assert_error_type(result, "stateMismatch");
}
#[tokio::test]
async fn set_with_empty_create_map_creates_nothing() {
let resp = set(&account_backend(), json!({ "create": {} }))
.await
.expect("ChatContact/set");
assert_eq!(resp["created"], Value::Null, "{resp:?}");
assert_eq!(resp["notCreated"], Value::Null, "{resp:?}");
assert_eq!(resp["oldState"], resp["newState"], "{resp:?}");
}
#[tokio::test]
async fn update_with_malformed_id_is_invalid_properties() {
let resp = set(
&account_backend(),
json!({ "update": { "bad id!": { "blocked": true } } }),
)
.await
.expect("ChatContact/set");
assert_eq!(resp["updated"], Value::Null, "{resp:?}");
assert_eq!(
resp["notUpdated"]["bad id!"]["type"], "invalidProperties",
"{resp:?}"
);
assert_eq!(
resp["notUpdated"]["bad id!"]["properties"],
json!(["id"]),
"{resp:?}"
);
}
#[tokio::test]
async fn update_with_non_object_patch_is_invalid_patch() {
let backend = account_backend();
seed_contact(&backend, CONTACT_ID, "alice@example.com");
let resp = set(&backend, json!({ "update": { CONTACT_ID: true } }))
.await
.expect("ChatContact/set");
assert_eq!(resp["updated"], Value::Null, "{resp:?}");
assert_eq!(
resp["notUpdated"][CONTACT_ID]["type"], "invalidPatch",
"{resp:?}"
);
}
#[tokio::test]
async fn update_with_no_supported_property_is_invalid_patch() {
let backend = account_backend();
seed_contact(&backend, CONTACT_ID, "alice@example.com");
let resp = set(
&backend,
json!({ "update": { CONTACT_ID: { "nickname": "A" } } }),
)
.await
.expect("ChatContact/set");
assert_eq!(resp["updated"], Value::Null, "{resp:?}");
assert_eq!(
resp["notUpdated"][CONTACT_ID]["type"], "invalidPatch",
"{resp:?}"
);
assert_eq!(resp["oldState"], resp["newState"], "{resp:?}");
}
#[tokio::test]
async fn destroy_with_non_string_element_is_invalid_arguments() {
let result = set(&account_backend(), json!({ "destroy": [CONTACT_ID, 7] })).await;
assert_error_type(result, "invalidArguments");
}
#[tokio::test]
async fn create_backend_failure_is_server_fail_without_backend_text() {
let backend = InjectableBackend::new();
backend.inject("ChatContact", "create");
let resp = set(
&backend,
json!({ "create": { "c0": { "identity": "bob@example.com" } } }),
)
.await
.expect("ChatContact/set");
assert_eq!(resp["created"], Value::Null, "{resp:?}");
assert_eq!(resp["notCreated"]["c0"]["type"], "serverFail", "{resp:?}");
assert!(
!resp.to_string().contains(INJECTABLE_BACKEND_CANARY),
"leaked backend text: {resp:?}"
);
}
#[tokio::test]
async fn update_backend_failure_is_server_fail_without_backend_text() {
let backend = InjectableBackend::new();
seed_contact(&backend.inner, CONTACT_ID, "alice@example.com");
backend.inject("ChatContact", "update");
let resp = set(
&backend,
json!({ "update": { CONTACT_ID: { "blocked": true } } }),
)
.await
.expect("ChatContact/set");
assert_eq!(resp["updated"], Value::Null, "{resp:?}");
assert_eq!(
resp["notUpdated"][CONTACT_ID]["type"], "serverFail",
"{resp:?}"
);
assert!(
!resp.to_string().contains(INJECTABLE_BACKEND_CANARY),
"leaked backend text: {resp:?}"
);
}
#[tokio::test]
async fn query_with_negative_limit_is_invalid_arguments() {
assert_error_type(query(json!({ "limit": -1 })).await, "invalidArguments");
}
#[tokio::test]
async fn query_with_string_position_is_invalid_arguments() {
assert_error_type(query(json!({ "position": "0" })).await, "invalidArguments");
}
#[tokio::test]
async fn query_with_non_array_sort_is_invalid_arguments() {
assert_error_type(
query(json!({ "sort": { "property": "login" } })).await,
"invalidArguments",
);
}
#[tokio::test]
async fn query_total_present_only_when_requested() {
let backend = account_backend();
seed_contact(&backend, "ct1", "alice@example.com");
seed_contact(&backend, "ct2", "bob@example.com");
let HandlerOutput { primary: resp, .. } = handle_contact_query(
&backend,
&(),
with_account(json!({ "calculateTotal": true, "limit": 1 })),
)
.await
.expect("ChatContact/query");
assert_eq!(resp["total"], json!(2), "{resp:?}");
assert_eq!(resp["ids"].as_array().map(Vec::len), Some(1), "{resp:?}");
let HandlerOutput { primary: resp, .. } =
handle_contact_query(&backend, &(), with_account(json!({})))
.await
.expect("ChatContact/query");
assert!(resp.get("total").is_none(), "{resp:?}");
}