mod common;
use common::{ACCOUNT_ID, IdentityBackend, SPACE_ID, seed_space, seed_with_admin};
use jmap_chat_server::{
handle_space_changes, handle_space_get, handle_space_join, handle_space_query,
handle_space_query_changes, handle_space_set,
};
use jmap_server::{HandlerOutput, JmapError};
use jmap_types::Id;
use serde_json::{Value, json};
fn caller() -> Id {
Id::from(ACCOUNT_ID)
}
fn admin_backend() -> IdentityBackend {
let backend = IdentityBackend::new();
seed_with_admin(&backend, ACCOUNT_ID);
backend
}
async fn space_set(backend: &IdentityBackend, args: Value) -> Result<Value, JmapError> {
handle_space_set(
backend,
&caller(),
&std::collections::BTreeMap::new(),
args,
&[],
)
.await
.map(|HandlerOutput { primary, .. }| primary)
}
async fn update(backend: &IdentityBackend, patch: Value) -> Value {
space_set(
backend,
json!({ "accountId": ACCOUNT_ID, "update": { SPACE_ID: patch } }),
)
.await
.expect("Space/set")
}
async fn space_state(backend: &IdentityBackend) -> String {
let HandlerOutput { primary, .. } = handle_space_get(
backend,
&caller(),
json!({ "accountId": ACCOUNT_ID, "ids": [] }),
&[],
)
.await
.expect("Space/get");
primary["state"].as_str().expect("state").to_owned()
}
fn assert_invalid_key(resp: &Value, key: &str) {
let err = &resp["notUpdated"][SPACE_ID];
assert_eq!(err["type"], "invalidProperties", "{resp:?}");
assert_eq!(err["properties"], json!([key]), "{resp:?}");
assert!(resp["updated"].get(SPACE_ID).is_none(), "{resp:?}");
}
#[tokio::test]
async fn remove_members_non_string_entry_is_invalid_properties() {
let backend = admin_backend();
let resp = update(&backend, json!({ "removeMembers": [42] })).await;
assert_invalid_key(&resp, "removeMembers");
}
#[tokio::test]
async fn update_roles_non_object_entry_is_invalid_properties() {
let backend = admin_backend();
let resp = update(&backend, json!({ "updateRoles": ["r-admin"] })).await;
assert_invalid_key(&resp, "updateRoles");
}
#[tokio::test]
async fn update_roles_non_string_id_is_invalid_properties() {
let backend = admin_backend();
let resp = update(
&backend,
json!({ "updateRoles": [{ "id": 7, "name": "X" }] }),
)
.await;
assert_invalid_key(&resp, "updateRoles");
}
#[tokio::test]
async fn add_members_non_object_entry_is_invalid_properties() {
let backend = admin_backend();
let resp = update(&backend, json!({ "addMembers": ["bob"] })).await;
assert_invalid_key(&resp, "addMembers");
}
#[tokio::test]
async fn add_members_non_string_id_is_invalid_properties() {
let backend = admin_backend();
let resp = update(&backend, json!({ "addMembers": [{ "id": ["bob"] }] })).await;
assert_invalid_key(&resp, "addMembers");
}
#[tokio::test]
async fn add_members_unknown_entry_property_is_invalid_properties() {
let backend = admin_backend();
let resp = update(
&backend,
json!({ "addMembers": [{ "id": "bob", "nick": "Bobby" }] }),
)
.await;
assert_invalid_key(&resp, "addMembers");
}
#[tokio::test]
async fn add_members_null_role_ids_adds_member() {
let backend = admin_backend();
let resp = update(
&backend,
json!({ "addMembers": [{ "id": "bob", "roleIds": null }] }),
)
.await;
assert!(resp["notUpdated"].get(SPACE_ID).is_none(), "{resp:?}");
let HandlerOutput { primary, .. } = handle_space_get(
&backend,
&caller(),
json!({ "accountId": ACCOUNT_ID, "ids": [SPACE_ID] }),
&[],
)
.await
.expect("Space/get");
let bob = primary["list"][0]["members"]
.as_array()
.expect("members")
.iter()
.find(|m| m["id"] == "bob")
.cloned()
.expect("bob added");
assert_eq!(bob["roleIds"], json!([]), "{bob:?}");
}
#[tokio::test]
async fn add_members_malformed_role_id_is_invalid_properties() {
let backend = admin_backend();
let resp = update(
&backend,
json!({ "addMembers": [{ "id": "bob", "roleIds": ["bad id"] }] }),
)
.await;
assert_invalid_key(&resp, "addMembers");
}
#[tokio::test]
async fn non_object_patch_is_invalid_patch() {
let backend = admin_backend();
let resp = update(&backend, json!(["name", "X"])).await;
assert_eq!(
resp["notUpdated"][SPACE_ID]["type"], "invalidPatch",
"{resp:?}"
);
}
#[tokio::test]
async fn if_in_state_mismatch_aborts_with_state_mismatch() {
let backend = admin_backend();
let before = space_state(&backend).await;
let err = space_set(
&backend,
json!({
"accountId": ACCOUNT_ID,
"ifInState": format!("{before}-stale"),
"update": { SPACE_ID: { "name": "Renamed" } }
}),
)
.await
.expect_err("stale ifInState");
assert_eq!(err.error_type.to_string(), "stateMismatch");
assert_eq!(space_state(&backend).await, before, "nothing applied");
}
#[tokio::test]
async fn destroy_non_string_element_is_invalid_arguments() {
let backend = admin_backend();
let err = space_set(&backend, json!({ "accountId": ACCOUNT_ID, "destroy": [1] }))
.await
.expect_err("non-string destroy id");
assert_eq!(err.error_type.to_string(), "invalidArguments");
}
async fn space_query(backend: &IdentityBackend, extra: Value) -> Result<Value, JmapError> {
let mut args = json!({ "accountId": ACCOUNT_ID });
args.as_object_mut()
.expect("object")
.extend(extra.as_object().expect("object").clone());
handle_space_query(backend, &caller(), args, &[])
.await
.map(|HandlerOutput { primary, .. }| primary)
}
#[tokio::test]
async fn query_negative_limit_is_invalid_arguments() {
let backend = admin_backend();
let err = space_query(&backend, json!({ "limit": -1 }))
.await
.expect_err("negative limit");
assert_eq!(err.error_type.to_string(), "invalidArguments");
}
#[tokio::test]
async fn query_string_position_is_invalid_arguments() {
let backend = admin_backend();
let err = space_query(&backend, json!({ "position": "0" }))
.await
.expect_err("string position");
assert_eq!(err.error_type.to_string(), "invalidArguments");
}
#[tokio::test]
async fn query_total_present_only_when_requested() {
let backend = admin_backend();
let with = space_query(&backend, json!({ "calculateTotal": true }))
.await
.expect("Space/query");
assert_eq!(with["total"], 1, "{with:?}");
let without = space_query(&backend, json!({})).await.expect("Space/query");
assert!(without.get("total").is_none(), "{without:?}");
}
async fn create_space(backend: &IdentityBackend, name: &str) -> String {
let resp = space_set(
backend,
json!({ "accountId": ACCOUNT_ID, "create": { "c1": { "name": name } } }),
)
.await
.expect("Space/set create");
resp["created"]["c1"]["id"]
.as_str()
.unwrap_or_else(|| panic!("created: {resp:?}"))
.to_owned()
}
#[tokio::test]
async fn changes_reports_created_space() {
let backend = admin_backend();
let since = space_state(&backend).await;
let new_id = create_space(&backend, "Zeta").await;
let HandlerOutput { primary, .. } = handle_space_changes(
&backend,
&caller(),
json!({ "accountId": ACCOUNT_ID, "sinceState": since }),
&[],
)
.await
.expect("Space/changes");
assert_eq!(primary["oldState"], since, "{primary:?}");
assert_eq!(primary["created"], json!([new_id]), "{primary:?}");
assert_eq!(primary["destroyed"], json!([]), "{primary:?}");
}
#[tokio::test]
async fn query_changes_reports_added_space_at_default_sort_index() {
let backend = admin_backend();
let before = space_query(&backend, json!({})).await.expect("Space/query");
let new_id = create_space(&backend, "Zeta").await;
let HandlerOutput { primary, .. } = handle_space_query_changes(
&backend,
&caller(),
json!({ "accountId": ACCOUNT_ID, "sinceQueryState": before["queryState"] }),
&[],
)
.await
.expect("Space/queryChanges");
assert_eq!(
primary["added"],
json!([{ "id": new_id, "index": 1 }]),
"{primary:?}"
);
}
#[tokio::test]
async fn query_changes_unsupported_sort_is_rejected() {
let backend = admin_backend();
let err = handle_space_query_changes(
&backend,
&caller(),
json!({
"accountId": ACCOUNT_ID,
"sinceQueryState": "0",
"sort": [{ "property": "memberCount" }]
}),
&[],
)
.await
.expect_err("unsupported sort");
assert_eq!(err.error_type.to_string(), "unsupportedSort");
}
#[tokio::test]
async fn join_with_expired_invite_is_invalid_arguments() {
let backend = IdentityBackend::new();
seed_space(&backend, json!([]), json!([]));
backend.inner().insert_object_for_test(
"SpaceInvite",
ACCOUNT_ID,
"inv1",
json!({
"id": "inv1",
"code": "0123456789abcdef0123456789abcdef",
"spaceId": SPACE_ID,
"createdBy": "admin-user",
"uses": 0,
"expiresAt": "2020-01-01T00:00:00Z",
"createdAt": "2019-12-01T00:00:00Z",
}),
);
let before = space_state(&backend).await;
let err = handle_space_join(
&backend,
&caller(),
json!({ "accountId": ACCOUNT_ID, "inviteCode": "0123456789abcdef0123456789abcdef" }),
)
.await
.expect_err("expired invite");
assert_eq!(err.error_type.to_string(), "invalidArguments");
assert_eq!(space_state(&backend).await, before, "no member added");
}