mod common;
use common::{make_chat_group, MemoryBackend, ACCOUNT_ID};
use jmap_chat_server::{
handle_ban_get, handle_ban_set, handle_chat_get, handle_chat_set, handle_contact_get,
handle_contact_set, handle_emoji_get, handle_emoji_set, handle_message_get, handle_message_set,
handle_position_get, handle_position_set, handle_presence_get, handle_presence_set,
};
use serde_json::{json, Value};
fn assert_rejected(resp: &Value, id: &str) {
assert_eq!(resp["updated"], Value::Null, "{resp:?}");
assert_eq!(
resp["notUpdated"][id]["type"], "invalidProperties",
"{resp:?}"
);
}
fn assert_rejected_naming(resp: &Value, id: &str, prop: &str) {
assert_rejected(resp, id);
assert_eq!(
resp["notUpdated"][id]["properties"],
json!([prop]),
"{resp:?}"
);
}
fn single(resp: Value) -> Value {
assert_eq!(resp["notFound"], json!([]), "{resp:?}");
let list = resp["list"].as_array().expect("list");
assert_eq!(list.len(), 1, "{resp:?}");
list[0].clone()
}
#[tokio::test]
async fn chat_kind_null_rejected_and_get_succeeds() {
let backend = MemoryBackend::new();
let id = make_chat_group(&backend, "g").await;
let (resp, _) = handle_chat_set(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "update": { &id: { "kind": null } } }),
)
.await
.expect("Chat/set");
assert_rejected_naming(&resp, &id, "kind");
let (resp, _) = handle_chat_get(&backend, &(), json!({ "accountId": ACCOUNT_ID }))
.await
.expect("Chat/get");
assert_eq!(single(resp)["kind"], "group");
}
#[tokio::test]
async fn message_body_null_rejected_and_get_succeeds() {
let backend = MemoryBackend::new();
let (resp, _) = handle_message_set(
&backend,
&(),
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 (resp, _) = handle_message_set(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "update": { &id: { "body": null } } }),
)
.await
.expect("Message/set update");
assert_rejected(&resp, &id);
let (resp, _) = handle_message_get(&backend, &(), json!({ "accountId": ACCOUNT_ID }))
.await
.expect("Message/get");
assert_eq!(single(resp)["body"], "hi");
}
#[tokio::test]
async fn emoji_blob_id_null_rejected_and_get_succeeds() {
let backend = MemoryBackend::new();
backend.insert_object_for_test(
"CustomEmoji",
ACCOUNT_ID,
"e1",
json!({
"id": "e1",
"name": "catjam",
"blobId": "b1",
"createdBy": "u1",
"createdAt": "2024-01-01T00:00:00Z",
}),
);
let (resp, _) = handle_emoji_set(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "update": { "e1": { "blobId": null } } }),
)
.await
.expect("CustomEmoji/set");
assert_rejected_naming(&resp, "e1", "blobId");
let (resp, _) = handle_emoji_get(&backend, &(), json!({ "accountId": ACCOUNT_ID }))
.await
.expect("CustomEmoji/get");
assert_eq!(single(resp)["blobId"], "b1");
}
#[tokio::test]
async fn contact_blocked_wrong_type_rejected_and_get_succeeds() {
let backend = MemoryBackend::new();
backend.insert_object_for_test(
"ChatContact",
ACCOUNT_ID,
"ct1",
json!({
"id": "ct1",
"login": "alice@example.com",
"firstSeenAt": "2024-01-01T00:00:00Z",
"lastSeenAt": "2024-01-01T00:00:00Z",
"blocked": true,
}),
);
let (resp, _) = handle_contact_set(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "update": { "ct1": { "blocked": "yes" } } }),
)
.await
.expect("ChatContact/set");
assert_rejected_naming(&resp, "ct1", "blocked");
let (resp, _) = handle_contact_get(&backend, &(), json!({ "accountId": ACCOUNT_ID }))
.await
.expect("ChatContact/get");
assert_eq!(single(resp)["blocked"], true);
}
#[tokio::test]
async fn presence_wrong_type_rejected_and_get_succeeds() {
let backend = MemoryBackend::new();
backend.insert_object_for_test(
"PresenceStatus",
ACCOUNT_ID,
"ps1",
json!({
"id": "ps1",
"presence": "busy",
"receiptSharing": false,
"updatedAt": "2024-01-01T00:00:00Z",
}),
);
let (resp, _) = handle_presence_set(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "update": { "ps1": { "presence": 5 } } }),
)
.await
.expect("PresenceStatus/set");
assert_rejected(&resp, "ps1");
let (resp, _) = handle_presence_get(&backend, &(), json!({ "accountId": ACCOUNT_ID }))
.await
.expect("PresenceStatus/get");
let ps = single(resp);
assert_eq!(ps["presence"], "busy");
assert_eq!(ps["updatedAt"], "2024-01-01T00:00:00Z");
}
#[tokio::test]
async fn position_wrong_type_rejected_and_get_succeeds() {
let backend = MemoryBackend::new();
backend.insert_object_for_test(
"ReadPosition",
ACCOUNT_ID,
"rp1",
json!({ "id": "rp1", "chatId": "c1", "lastReadMessageId": "m1" }),
);
let (resp, _) = handle_position_set(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "update": { "rp1": { "lastReadMessageId": 5 } } }),
)
.await
.expect("ReadPosition/set");
assert_rejected_naming(&resp, "rp1", "lastReadMessageId");
let (resp, _) = handle_position_get(&backend, &(), json!({ "accountId": ACCOUNT_ID }))
.await
.expect("ReadPosition/get");
assert_eq!(single(resp)["lastReadMessageId"], "m1");
}
#[tokio::test]
async fn ban_reason_wrong_type_rejected_and_get_succeeds() {
let backend = MemoryBackend::new();
backend.insert_object_for_test(
"SpaceBan",
ACCOUNT_ID,
"b1",
json!({
"id": "b1",
"spaceId": "s1",
"userId": "u2",
"bannedBy": "u1",
"createdAt": "2024-01-01T00:00:00Z",
"reason": "spam",
}),
);
let (resp, _) = handle_ban_set(
&backend,
&(),
json!({ "accountId": ACCOUNT_ID, "update": { "b1": { "reason": 5 } } }),
)
.await
.expect("SpaceBan/set");
assert_rejected_naming(&resp, "b1", "reason");
let (resp, _) = handle_ban_get(&backend, &(), json!({ "accountId": ACCOUNT_ID }))
.await
.expect("SpaceBan/get");
assert_eq!(single(resp)["reason"], "spam");
}