π End-to-end encrypted cloud for everything.
Dart 2faandroidauthye2eeencryptionend-to-end-encryptionfluttergolanggoogle-photosgoogle-photos-alternativeiosopensourcephotosprivacyprivacy-toolstypescriptzero-knowledge
use super::test_support::*;
use super::*;
use crate::crypto::{encrypt_asset_payload, seal_with_public_key};
use crate::transport::{
ConversationChatSummaryResponse, EntityKeyPayload, MessageConversationActivity,
MessagePageResponse, MessageResponse, ProfileAvatarPayload, ProfileCoverPayload,
SpaceActorResponse, SpaceFriendResponse,
};
use mockito::{Matcher, Server};
use serde_json::json;
#[tokio::test]
async fn account_api_sends_space_session_token_header() {
let mut server = Server::new_async().await;
let request = server
.mock("GET", "/account/space")
.match_header("x-space-session-token", "space-session-token")
.with_status(200)
.with_body("{}")
.create_async()
.await;
let api = build_api(
&server.url(),
Some("space-session-token".to_owned()),
None,
None,
None,
)
.expect("API client");
let _: serde_json::Value = api
.get("/account/space")
.send()
.await
.unwrap()
.error_for_status()
.unwrap()
.json()
.await
.unwrap();
request.assert_async().await;
}
#[tokio::test]
async fn message_thread_keeps_content_failures_local_to_each_message() {
fn content(message: &crate::Message) -> &crate::MessageContent {
message.content.as_ref().unwrap().as_ref().unwrap()
}
let mut server = Server::new_async().await;
let ctx = test_account_ctx(&server.url());
let key = generate_key();
let encrypted_key =
b64::encode(&seal_with_public_key(&key, &test_public_key(&ctx)).expect("message key seal"));
let message = |id: &str, kind: &str, plaintext: &[u8]| MessageResponse {
message_id: id.into(),
kind: kind.into(),
sender_space_id: "space_friend".into(),
recipient_space_id: "space_owner_main".into(),
message_cipher: b64::encode(&encrypt_secretbox_payload(&key, plaintext).unwrap()),
encrypted_reaction: String::new(),
encrypted_message_key: encrypted_key.clone(),
text: String::new(),
reply_post_id: None,
reply_message_id: None,
liked: false,
viewer_liked: false,
is_deleted: false,
created_at: "2026-09-23T00:00:00Z".into(),
updated_at: "2026-09-23T00:00:00Z".into(),
};
let mut readable = message(
"readable",
"regular",
br#"{"version":1,"kind":"regular","text":"hello","replyObjectKey":"photo"}"#,
);
readable.encrypted_reaction = "invalid".into();
let poke = message(
"poke",
"regular",
br#"{"version":1,"kind":"poke","text":"Poked"}"#,
);
let mut event = message("event", "friend_added", b"");
event.text = "You are now friends".into();
let mut deleted = message("deleted", "regular", b"");
deleted.is_deleted = true;
let corrupt = message("corrupt", "regular", b"not-json");
let page = MessagePageResponse {
items: vec![readable.clone(), poke, event, deleted, corrupt, readable],
next_cursor: "next".into(),
};
let request = server
.mock(
"GET",
"/spaces/space_owner_main/friends/space_friend/messages",
)
.with_body(serde_json::to_string(&page).unwrap())
.create_async()
.await;
let opened = ctx
.list_message_thread("space_owner_main", "space_friend", None, None)
.await
.unwrap();
assert_eq!(opened.next_cursor, "next");
assert_eq!(opened.items.len(), 5);
assert_eq!(content(&opened.items[0]).text, "hello");
assert!(opened.items[0].reaction.is_err());
assert_eq!(
content(&opened.items[0]).reply_object_key.as_deref(),
Some("photo")
);
assert!(opened.items.iter().all(|item| item.kind != "poke"));
assert_eq!(opened.items[1].kind, "friend_added");
assert_eq!(content(&opened.items[1]).text, "You are now friends");
assert!(opened.items[2].content.as_ref().unwrap().is_none());
assert!(matches!(
&opened.items[3].content,
Err(Error::InvalidInput(_))
));
assert_eq!(content(&opened.items[4]).text, "hello");
request.assert_async().await;
}
#[tokio::test]
async fn unread_poke_is_hidden_after_identifying_its_kind() {
let server = Server::new_async().await;
let ctx = test_account_ctx(&server.url());
let activity = MessageConversationActivity {
id: "activity-1".into(),
activity_type: "message".into(),
kind: "poke".into(),
created_at: "2026-08-01T00:00:00Z".into(),
outgoing: false,
message_id: Some("message-1".into()),
sender_space_id: "space_friend".into(),
recipient_space_id: "space_owner_main".into(),
message_cipher: String::new(),
encrypted_reaction: String::new(),
encrypted_message_key: String::new(),
reply_message_id: None,
post_id: None,
post_space_id: None,
};
let mut unread = activity.clone();
unread.kind = "regular".into();
let summary = ctx
.open_conversation_summary(
"space_owner_main",
ConversationChatSummaryResponse {
latest_activity: activity,
unread_activities: vec![unread],
},
)
.await
.unwrap();
assert!(summary.unread_activities.is_empty());
}
#[tokio::test]
async fn conversation_activities_open_content_and_preserve_server_kind() {
let server = Server::new_async().await;
let ctx = test_account_ctx(&server.url());
let key = generate_key();
let encrypted_key = b64::encode(&seal_with_public_key(&key, &test_public_key(&ctx)).unwrap());
for (server_kind, payload_kind, expected_kind) in [
("regular", "poke", "poke"),
("regular", "post_like", "regular"),
("post_reply", "poke", "post_reply"),
] {
let plaintext = serde_json::to_vec(&json!({
"version": 1,
"kind": payload_kind,
"text": "hello",
"replyObjectKey": "photo",
}))
.unwrap();
let activity = MessageConversationActivity {
id: "activity-1".into(),
activity_type: "message".into(),
kind: server_kind.into(),
created_at: "2026-08-01T00:00:00Z".into(),
outgoing: false,
message_id: Some("message-1".into()),
sender_space_id: "space_friend".into(),
recipient_space_id: "space_owner_main".into(),
message_cipher: b64::encode(&encrypt_secretbox_payload(&key, &plaintext).unwrap()),
encrypted_reaction: String::new(),
encrypted_message_key: encrypted_key.clone(),
reply_message_id: None,
post_id: None,
post_space_id: None,
};
let summary = ctx
.open_conversation_summary(
"space_owner_main",
ConversationChatSummaryResponse {
latest_activity: activity,
unread_activities: vec![],
},
)
.await
.unwrap();
assert_eq!(summary.latest_activity.kind, expected_kind);
let content = summary.latest_activity.content.unwrap().unwrap();
assert_eq!(content.text, "hello");
assert_eq!(content.reply_object_key.as_deref(), Some("photo"));
}
let activity = MessageConversationActivity {
id: "corrupt".into(),
activity_type: "message".into(),
kind: "regular".into(),
created_at: "2026-08-01T00:00:00Z".into(),
outgoing: false,
message_id: Some("message-2".into()),
sender_space_id: "space_friend".into(),
recipient_space_id: "space_owner_main".into(),
message_cipher: b64::encode(&encrypt_secretbox_payload(&key, b"not-json").unwrap()),
encrypted_reaction: String::new(),
encrypted_message_key: encrypted_key,
reply_message_id: None,
post_id: None,
post_space_id: None,
};
let summary = ctx
.open_conversation_summary(
"space_owner_main",
ConversationChatSummaryResponse {
latest_activity: activity,
unread_activities: vec![],
},
)
.await
.unwrap();
assert!(matches!(
summary.latest_activity.content,
Err(Error::InvalidInput(_))
));
}
#[tokio::test]
async fn get_space_root_key_returns_context_space_root_key() {
let server = Server::new_async().await;
let expected_space_root = generate_key();
let ctx = test_account_ctx_with_space_root_key(&server.url(), expected_space_root.clone());
let space_root = ctx
.get_space_root_key()
.expect("space root key should load")
.expect("space root key should exist");
assert_eq!(space_root, expected_space_root);
}
#[tokio::test]
async fn get_or_create_space_root_key_returns_context_space_root_key() {
let server = Server::new_async().await;
let expected_space_root = generate_key();
let ctx = test_account_ctx_with_space_root_key(&server.url(), expected_space_root.clone());
let space_root = ctx
.get_or_create_space_root_key()
.expect("space root key should load");
assert_eq!(space_root, expected_space_root);
}
#[tokio::test]
async fn ensure_entity_key_uses_generic_split_key_endpoint() {
let mut server = Server::new_async().await;
let ctx = test_account_ctx(&server.url());
let header = vec![1u8; 24];
let encrypted_key = vec![2u8; 48];
let mut combined = header.clone();
combined.extend_from_slice(&encrypted_key);
let ensure = server
.mock("POST", "/user-entity/key/ensure")
.match_body(Matcher::JsonString(
json!({
"type": "space",
"encryptedKey": b64::encode(&encrypted_key),
"header": b64::encode(&header),
})
.to_string(),
))
.with_status(200)
.with_body(
json!({
"userID": 1,
"type": "space",
"encryptedKey": b64::encode(&encrypted_key),
"header": b64::encode(&header),
"createdAt": 123,
})
.to_string(),
)
.create_async()
.await;
let payload = ctx
.ensure_entity_key(
"space",
&EntityKeyPayload {
encrypted_key: b64::encode(&combined),
},
)
.await
.expect("entity key");
assert_eq!(payload.encrypted_key, b64::encode(&combined));
ensure.assert_async().await;
}
#[tokio::test]
async fn account_space_key_resolution_is_cached_within_context() {
let mut server = Server::new_async().await;
let space_root_key = generate_key();
let ctx = test_account_ctx_with_space_root_key(&server.url(), space_root_key.clone());
let friend_space_key = generate_key();
let encrypted_profile = b64::encode(
&encrypt_secretbox_payload(&friend_space_key, br#"{"fullName":"Friend"}"#)
.expect("profile wrap"),
);
let sealed_share =
seal_with_public_key(&friend_space_key, &test_public_key(&ctx)).expect("friend share seal");
let friend_sealed_space_key = b64::encode(&sealed_share);
let spaces = server
.mock("GET", "/account/space")
.match_header("x-space-session-token", "space-session-token")
.with_status(200)
.with_body(owned_space_response(
&space_root_key,
&generate_key(),
"space_owner_main",
"owner",
1,
))
.expect(1)
.create_async()
.await;
let shares = server
.mock("GET", "/spaces/space_owner_main/friends/shares")
.match_header("x-space-session-token", "space-session-token")
.with_status(200)
.with_body(
json!([
{
"friend": "corrupt",
"spaceId": "space_corrupt",
"spaceSlug": "corrupt",
"friendSealedSpaceKey": "not-base64",
"keyVersion": 1
},
{
"friend": "friend",
"spaceId": "space_friend",
"spaceSlug": "friend",
"friendSealedSpaceKey": friend_sealed_space_key,
"keyVersion": 1
}
])
.to_string(),
)
.expect(1)
.create_async()
.await;
let actor = SpaceActorResponse {
space_id: "space_friend".to_owned(),
space_slug: "friend".to_owned(),
key_version: 1,
encrypted_profile,
..Default::default()
};
let first = ctx
.decrypt_actor_profile(&actor)
.await
.expect("first profile decrypt");
let second = ctx
.decrypt_actor_profile(&actor)
.await
.expect("second profile decrypt");
assert_eq!(first.unwrap().full_name.as_deref(), Some("Friend"));
assert_eq!(second.unwrap().full_name.as_deref(), Some("Friend"));
let opened = ctx
.open_friend(SpaceFriendResponse {
friend: actor.clone(),
share_key_version: 1,
created_at: "2026-04-16T00:00:00Z".into(),
})
.await
.unwrap();
assert_eq!(
opened
.friend
.profile
.as_ref()
.unwrap()
.as_ref()
.unwrap()
.full_name
.as_deref(),
Some("Friend")
);
let mut corrupt_actor = actor;
corrupt_actor.encrypted_profile = "not-base64".into();
let opened = ctx
.open_friend(SpaceFriendResponse {
friend: corrupt_actor,
share_key_version: 1,
created_at: "2026-04-16T00:00:00Z".into(),
})
.await
.unwrap();
assert!(matches!(
&opened.friend.profile,
Err(Error::Base64Decode(_))
));
spaces.assert_async().await;
shares.assert_async().await;
}
#[tokio::test]
async fn upload_post_asset_uses_presign_and_object_store() {
let mut server = Server::new_async().await;
let ctx = test_account_ctx(&server.url());
let presign = server
.mock("POST", "/spaces/space_owner_main/uploads/presign")
.match_header("x-space-session-token", "space-session-token")
.match_body(Matcher::AllOf(vec![
Matcher::Regex("\"size\"".into()),
Matcher::Regex("\"contentMD5\":\"[^\"]+\"".into()),
]))
.with_status(200)
.with_body(
json!({
"url": format!("{}/upload/object-1", server.url()),
"method": "PUT",
"headers": {
"content-type": "application/octet-stream",
"Content-MD5": "test-digest"
},
"objectKey": "object-1",
"expiresIn": 300
})
.to_string(),
)
.create_async()
.await;
let upload = server
.mock("PUT", "/upload/object-1")
.match_header("content-type", "application/octet-stream")
.match_header("content-md5", "test-digest")
.with_status(200)
.create_async()
.await;
let payload = ctx
.upload_post_asset("space_owner_main", &generate_key(), b"tiny-image", Some(0))
.await
.expect("upload should succeed");
assert_eq!(payload.object_key, "object-1");
assert_eq!(payload.position, Some(0));
assert!(payload.size.unwrap_or_default() > 0);
presign.assert_async().await;
upload.assert_async().await;
}
#[tokio::test]
async fn upload_post_photo_asset_attaches_photo_metadata() {
let mut server = Server::new_async().await;
let ctx = test_account_ctx(&server.url());
let presign = server
.mock("POST", "/spaces/space_owner_main/uploads/presign")
.match_header("x-space-session-token", "space-session-token")
.match_body(Matcher::AllOf(vec![Matcher::Regex(
"\"contentMD5\":\"[^\"]+\"".into(),
)]))
.with_status(200)
.with_body(
json!({
"url": format!("{}/upload/photo-object", server.url()),
"method": "PUT",
"headers": {
"content-type": "application/octet-stream",
"Content-MD5": "test-digest"
},
"objectKey": "photo-object",
"expiresIn": 300
})
.to_string(),
)
.create_async()
.await;
let upload = server
.mock("PUT", "/upload/photo-object")
.match_header("content-type", "application/octet-stream")
.match_header("content-md5", "test-digest")
.with_status(200)
.create_async()
.await;
let post_key = generate_key();
let payload = ctx
.upload_post_photo_asset(
"space_owner_main",
&post_key,
TEST_WEBP_BYTES,
PostPhotoAssetOptions {
width: Some(4032),
height: Some(3024),
media_type: Some("image/webp".to_owned()),
thumb_hash: Some("thumbhash-test".to_owned()),
},
)
.await
.expect("photo upload should succeed");
assert_eq!(payload.object_key, "photo-object");
assert_eq!(payload.position, Some(0));
let metadata = decrypt_post_object_metadata(&post_key, &payload)
.expect("metadata should decrypt")
.expect("metadata should exist");
assert_eq!(metadata.width, Some(4032));
assert_eq!(metadata.height, Some(3024));
assert_eq!(metadata.media_type.as_deref(), Some("image/webp"));
assert_eq!(metadata.thumb_hash.as_deref(), Some("thumbhash-test"));
presign.assert_async().await;
upload.assert_async().await;
}
#[tokio::test]
async fn upload_post_photo_asset_rejects_video_media_type() {
let server = Server::new_async().await;
let ctx = test_account_ctx(&server.url());
let err = ctx
.upload_post_photo_asset(
"space_owner_main",
&generate_key(),
TEST_WEBP_BYTES,
PostPhotoAssetOptions {
width: Some(4032),
height: Some(3024),
media_type: Some("video/mp4".to_owned()),
thumb_hash: None,
},
)
.await
.expect_err("video media type should fail before upload");
assert!(err.to_string().contains(ONLY_PHOTOS_UPLOAD_MESSAGE));
}
#[tokio::test]
async fn upload_post_photo_asset_rejects_video_bytes() {
let server = Server::new_async().await;
let ctx = test_account_ctx(&server.url());
let err = ctx
.upload_post_photo_asset(
"space_owner_main",
&generate_key(),
TEST_MP4_BYTES,
PostPhotoAssetOptions {
width: Some(1920),
height: Some(1080),
media_type: Some("image/webp".to_owned()),
thumb_hash: None,
},
)
.await
.expect_err("video bytes should fail before upload");
assert!(err.to_string().contains(ONLY_PHOTOS_UPLOAD_MESSAGE));
}
#[tokio::test]
async fn presign_uploads_reject_oversized_space_assets() {
let server = Server::new_async().await;
let ctx = test_account_ctx(&server.url());
let post_error = ctx
.presign_post_upload(
"space_owner_main",
MAX_SPACE_POST_UPLOAD_BYTES + 1,
"XUFAKrxLKna5cZ2REBfFkg==",
)
.await
.expect_err("oversized post upload should fail before presign");
assert!(post_error.to_string().contains("post upload size"));
assert!(
post_error
.to_string()
.contains(&MAX_SPACE_POST_UPLOAD_BYTES.to_string())
);
let avatar_error = ctx
.presign_avatar_upload(
"space_owner_main",
MAX_SPACE_AVATAR_UPLOAD_BYTES + 1,
"XUFAKrxLKna5cZ2REBfFkg==",
)
.await
.expect_err("oversized avatar upload should fail before presign");
assert!(avatar_error.to_string().contains("avatar upload size"));
assert!(
avatar_error
.to_string()
.contains(&MAX_SPACE_AVATAR_UPLOAD_BYTES.to_string())
);
let cover_error = ctx
.presign_cover_upload(
"space_owner_main",
MAX_SPACE_COVER_UPLOAD_BYTES + 1,
"XUFAKrxLKna5cZ2REBfFkg==",
)
.await
.expect_err("oversized cover upload should fail before presign");
assert!(cover_error.to_string().contains("cover upload size"));
assert!(
cover_error
.to_string()
.contains(&MAX_SPACE_COVER_UPLOAD_BYTES.to_string())
);
}
#[tokio::test]
async fn upload_avatar_uses_avatar_presign_and_object_store() {
let mut server = Server::new_async().await;
let ctx = test_account_ctx(&server.url());
let presign = server
.mock("POST", "/spaces/space_owner_main/uploads/presign")
.match_header("x-space-session-token", "space-session-token")
.match_body(Matcher::AllOf(vec![
Matcher::Regex("\"purpose\":\"avatar\"".into()),
Matcher::Regex("\"contentMD5\":\"[^\"]+\"".into()),
Matcher::Regex("\"size\"".into()),
]))
.with_status(200)
.with_body(
json!({
"url": format!("{}/upload/avatar-object", server.url()),
"method": "PUT",
"headers": {
"content-type": "application/octet-stream",
"Content-MD5": "test-digest"
},
"objectKey": "avatar-object",
"expiresIn": 300
})
.to_string(),
)
.create_async()
.await;
let upload = server
.mock("PUT", "/upload/avatar-object")
.match_header("content-type", "application/octet-stream")
.match_header("content-md5", "test-digest")
.with_status(200)
.create_async()
.await;
let payload = ctx
.upload_avatar("space_owner_main", &generate_key(), TEST_WEBP_BYTES)
.await
.expect("avatar upload should succeed");
assert_eq!(payload.object_id, "avatar-object");
assert!(payload.size.unwrap_or_default() > 0);
presign.assert_async().await;
upload.assert_async().await;
}
#[tokio::test]
async fn upload_avatar_rejects_video_bytes() {
let server = Server::new_async().await;
let ctx = test_account_ctx(&server.url());
let err = ctx
.upload_avatar("space_owner_main", &generate_key(), TEST_MP4_BYTES)
.await
.expect_err("video avatar bytes should fail before upload");
assert!(err.to_string().contains(ONLY_PHOTOS_UPLOAD_MESSAGE));
}
#[tokio::test]
async fn upload_cover_uses_cover_presign_and_object_store() {
let mut server = Server::new_async().await;
let ctx = test_account_ctx(&server.url());
let presign = server
.mock("POST", "/spaces/space_owner_main/uploads/presign")
.match_header("x-space-session-token", "space-session-token")
.match_body(Matcher::AllOf(vec![
Matcher::Regex("\"purpose\":\"cover\"".into()),
Matcher::Regex("\"contentMD5\":\"[^\"]+\"".into()),
Matcher::Regex("\"size\"".into()),
]))
.with_status(200)
.with_body(
json!({
"url": format!("{}/upload/cover-object", server.url()),
"method": "PUT",
"headers": {
"content-type": "application/octet-stream",
"Content-MD5": "test-digest"
},
"objectKey": "cover-object",
"expiresIn": 300
})
.to_string(),
)
.create_async()
.await;
let upload = server
.mock("PUT", "/upload/cover-object")
.match_header("content-type", "application/octet-stream")
.match_header("content-md5", "test-digest")
.with_status(200)
.create_async()
.await;
let payload = ctx
.upload_cover("space_owner_main", &generate_key(), TEST_WEBP_BYTES)
.await
.expect("cover upload should succeed");
assert_eq!(payload.object_id, "cover-object");
assert!(payload.size.unwrap_or_default() > 0);
presign.assert_async().await;
upload.assert_async().await;
}
#[tokio::test]
async fn account_download_profile_avatar_uses_asset_key_version() {
let mut server = Server::new_async().await;
let space_root_key = generate_key();
let ctx = test_account_ctx_with_space_root_key(&server.url(), space_root_key.clone());
let space_key_v1 = generate_key();
let space_key_v2 = generate_key();
let encrypted_asset =
encrypt_asset_payload(&space_key_v1, b"avatar-image").expect("asset encryption");
let spaces = server
.mock("GET", "/account/space")
.match_header("x-space-session-token", "space-session-token")
.with_status(200)
.with_body(owned_space_response(
&space_root_key,
&space_key_v2,
"space_owner_main",
"owner-main",
2,
))
.create_async()
.await;
let versions = server
.mock("GET", "/spaces/space_owner_main/versions")
.match_header("x-space-session-token", "space-session-token")
.with_status(200)
.with_body(
json!([{
"version": 2,
"wrappedPrevKey": b64::encode(
&encrypt_secretbox_payload(&space_key_v2, &space_key_v1)
.expect("previous key wrap")
),
"createdAt": "2026-04-16T00:00:00Z"
}])
.to_string(),
)
.create_async()
.await;
let redirect = server
.mock("GET", "/spaces/space_owner_main/assets/redirect")
.match_header("x-space-session-token", "space-session-token")
.match_query(Matcher::AllOf(vec![
Matcher::UrlEncoded("assetType".into(), "avatar".into()),
Matcher::UrlEncoded("objectID".into(), "avatar-object".into()),
]))
.with_status(200)
.with_body(
json!({
"url": format!("{}/objects/avatar-object", server.url()),
"expiresIn": 900
})
.to_string(),
)
.create_async()
.await;
let object = server
.mock("GET", "/objects/avatar-object")
.with_status(200)
.with_body(encrypted_asset)
.create_async()
.await;
let bytes = ctx
.download_profile_asset("space_owner_main", None, "avatar", "avatar-object", 1)
.await
.expect("avatar asset should download and decrypt");
assert_eq!(bytes, b"avatar-image");
spaces.assert_async().await;
versions.assert_async().await;
redirect.assert_async().await;
object.assert_async().await;
}
#[tokio::test]
async fn create_space_with_key_sends_encrypted_space_and_profile_payloads() {
let mut server = Server::new_async().await;
let space_root_key = generate_key();
let ctx = test_account_ctx_with_space_root_key(&server.url(), space_root_key);
let space_key = generate_key();
let create_space = server
.mock("POST", "/account/space")
.match_header("x-space-session-token", "space-session-token")
.match_body(Matcher::AllOf(vec![
Matcher::Regex("\"spaceSlug\":\"owner-main\"".into()),
Matcher::Regex("\"rootWrappedSpaceKey\":\"[^\"]+\"".into()),
Matcher::Regex("\"publicKey\":\"[^\"]+\"".into()),
Matcher::Regex("\"encryptedSecretKey\":\"[^\"]+\"".into()),
Matcher::Regex("\"encryptedProfile\":\"[^\"]+\"".into()),
Matcher::Regex("\"referredBySpaceId\":\"space_source_owner\"".into()),
]))
.with_status(200)
.with_body(
json!({
"spaceId": "space_owner_main",
"spaceSlug": "owner-main",
"rootWrappedSpaceKey": "",
"encryptedProfile": "",
"keyVersion": 1
})
.to_string(),
)
.create_async()
.await;
let created = ctx
.create_space_with_key_and_referrer(
"owner-main",
&space_key,
b"profile-json",
Some("space_source_owner"),
)
.await
.expect("space should be created");
assert_eq!(created.space_id, "space_owner_main");
assert_eq!(created.space_slug, "owner-main");
assert_eq!(created.key_version, 1);
let profile_plaintext = decrypt_secretbox_payload(
&space_key,
&b64::decode(&created.encrypted_profile).unwrap(),
)
.expect("created profile should decrypt");
assert_eq!(profile_plaintext, b"profile-json");
create_space.assert_async().await;
}
#[tokio::test]
async fn create_space_maps_owner_limit_error() {
let mut server = Server::new_async().await;
let ctx = test_account_ctx(&server.url());
let create_space = server
.mock("POST", "/account/space")
.with_status(409)
.with_body(json!({ "code": "CONFLICT" }).to_string())
.create_async()
.await;
let Err(error) = ctx
.create_space_with_key("owner-main", &generate_key(), b"profile-json")
.await
else {
panic!("space creation should fail")
};
assert!(matches!(error, Error::SpaceLimitReached));
create_space.assert_async().await;
}
#[tokio::test]
async fn update_space_slug_maps_duplicate_error() {
let mut server = Server::new_async().await;
let ctx = test_account_ctx(&server.url());
let update_slug = server
.mock("PUT", "/spaces/space_owner_main/slug")
.with_status(409)
.with_body(json!({ "code": "ALREADY_EXISTS" }).to_string())
.create_async()
.await;
let error = ctx
.update_space_slug("space_owner_main", "taken")
.await
.expect_err("slug update should fail");
assert!(matches!(error, Error::SpaceSlugAlreadyExists));
update_slug.assert_async().await;
}
#[tokio::test]
async fn update_space_slug_maps_reserved_error() {
let mut server = Server::new_async().await;
let ctx = test_account_ctx(&server.url());
let update_slug = server
.mock("PUT", "/spaces/space_owner_main/slug")
.with_status(400)
.with_body(json!({ "code": "SPACE_SLUG_RESERVED" }).to_string())
.create_async()
.await;
let error = ctx
.update_space_slug("space_owner_main", "support")
.await
.expect_err("slug update should fail");
assert!(matches!(error, Error::SpaceSlugReserved));
update_slug.assert_async().await;
}
#[tokio::test]
async fn create_space_updates_loaded_owned_space_cache() {
let mut server = Server::new_async().await;
let space_root_key = generate_key();
let ctx = test_account_ctx_with_space_root_key(&server.url(), space_root_key);
let space_key = generate_key();
let list_spaces = server
.mock("GET", "/account/space")
.match_header("x-space-session-token", "space-session-token")
.with_status(200)
.with_body("[]")
.expect(1)
.create_async()
.await;
let create_space = server
.mock("POST", "/account/space")
.match_header("x-space-session-token", "space-session-token")
.with_status(200)
.with_body(
json!({
"spaceId": "space_owner_main",
"spaceSlug": "owner-main",
"rootWrappedSpaceKey": "",
"encryptedProfile": "",
"keyVersion": 1
})
.to_string(),
)
.create_async()
.await;
let update_profile = server
.mock("POST", "/spaces/space_owner_main/profile")
.match_header("x-space-session-token", "space-session-token")
.match_body(Matcher::AllOf(vec![Matcher::Regex(
"\"encryptedProfile\":\"[^\"]+\"".into(),
)]))
.with_status(200)
.with_body(json!({ "status": "ok" }).to_string())
.create_async()
.await;
let spaces = ctx
.list_owned_spaces()
.await
.expect("space list should load");
assert!(spaces.is_empty());
let created = ctx
.create_space_with_key("owner-main", &space_key, b"profile-json")
.await
.expect("space should be created");
ctx.update_space_profile(&created.space_id, b"profile-json-2", None, false)
.await
.expect("created space should be available from cache");
let cached = ctx
.list_owned_spaces()
.await
.expect("owned space cache should remain usable");
let cached_profile = decrypt_secretbox_payload(
&space_key,
&b64::decode(&cached[0].encrypted_profile).unwrap(),
)
.expect("cached profile should decrypt");
assert_eq!(cached_profile.as_slice(), b"profile-json-2");
list_spaces.assert_async().await;
create_space.assert_async().await;
update_profile.assert_async().await;
}
#[tokio::test]
async fn list_owned_spaces_uses_initial_cache() {
let server = Server::new_async().await;
let expected = SpaceKeyResponse {
space_id: "space_owner_main".to_owned(),
space_slug: "owner-main".to_owned(),
root_wrapped_space_key: "wrapped-key".to_owned(),
public_key: "public-key".to_owned(),
encrypted_secret_key: "encrypted-secret-key".to_owned(),
encrypted_profile: "encrypted-profile".to_owned(),
key_version: 3,
};
let ctx = AccountSpaceCtx::open(OpenAccountSpaceCtxInput {
base_url: server.url(),
space_session_token: Some("space-session-token".to_owned()),
space_root_key: generate_key(),
initial_owned_spaces: Some(vec![expected.clone()]),
user_agent: None,
client_package: None,
client_version: None,
})
.expect("account space ctx should open");
let spaces = ctx
.list_owned_spaces()
.await
.expect("seeded space list should load");
assert_eq!(spaces.len(), 1);
assert_eq!(spaces[0].space_id, expected.space_id);
assert_eq!(
spaces[0].root_wrapped_space_key,
expected.root_wrapped_space_key
);
}
#[tokio::test]
async fn newer_key_version_refreshes_initial_owned_cache() {
let mut server = Server::new_async().await;
let space_root_key = generate_key();
let old_space_key = generate_key();
let current_space_key = generate_key();
let list_spaces = server
.mock("GET", "/account/space")
.match_header("x-space-session-token", "space-session-token")
.with_status(200)
.with_body(owned_space_response(
&space_root_key,
¤t_space_key,
"space_owner_main",
"owner-main",
3,
))
.expect(1)
.create_async()
.await;
let cached = SpaceKeyResponse {
space_id: "space_owner_main".to_owned(),
space_slug: "owner-main".to_owned(),
root_wrapped_space_key: b64::encode(
&encrypt_secretbox_payload(&space_root_key, &old_space_key)
.expect("old space key wrap"),
),
public_key: String::new(),
encrypted_secret_key: String::new(),
encrypted_profile: String::new(),
key_version: 2,
};
let ctx = AccountSpaceCtx::open(OpenAccountSpaceCtxInput {
base_url: server.url(),
space_session_token: Some("space-session-token".to_owned()),
space_root_key,
initial_owned_spaces: Some(vec![cached]),
user_agent: None,
client_package: None,
client_version: None,
})
.expect("account space ctx should open");
let resolved = ctx
.resolve_space_key_for_version("space_owner_main", Some(3))
.await
.expect("current space key should resolve")
.expect("current space key should exist");
assert_eq!(resolved, current_space_key);
assert_eq!(
ctx.list_owned_spaces()
.await
.expect("refreshed owned spaces")[0]
.key_version,
3
);
list_spaces.assert_async().await;
}
#[tokio::test]
async fn list_owned_spaces_reuses_loaded_cache() {
let mut server = Server::new_async().await;
let ctx = test_account_ctx(&server.url());
let space_root_key = generate_key();
let space_key = generate_key();
let list_spaces = server
.mock("GET", "/account/space")
.match_header("x-space-session-token", "space-session-token")
.with_status(200)
.with_body(owned_space_response(
&space_root_key,
&space_key,
"space_owner_main",
"owner-main",
3,
))
.expect(1)
.create_async()
.await;
let first = ctx
.list_owned_spaces()
.await
.expect("space list should load");
let second = ctx
.list_owned_spaces()
.await
.expect("space list should reuse cache");
assert_eq!(first.len(), 1);
assert_eq!(second.len(), 1);
assert_eq!(second[0].space_id, first[0].space_id);
assert_eq!(second[0].space_slug, first[0].space_slug);
assert_eq!(
second[0].root_wrapped_space_key,
first[0].root_wrapped_space_key
);
assert_eq!(second[0].key_version, first[0].key_version);
list_spaces.assert_async().await;
}
#[tokio::test]
async fn create_post_includes_space_key_version() {
let mut server = Server::new_async().await;
let space_root_key = generate_key();
let ctx = test_account_ctx_with_space_root_key(&server.url(), space_root_key.clone());
let space_key = generate_key();
let spaces = server
.mock("GET", "/account/space")
.match_header("x-space-session-token", "space-session-token")
.with_status(200)
.with_body(
json!([{
"spaceId": "space_owner_main",
"spaceSlug": "owner-main",
"rootWrappedSpaceKey": b64::encode(&encrypt_secretbox_payload(&space_root_key, &space_key).expect("space key wrap")),
"encryptedProfile": "",
"keyVersion": 3
}])
.to_string(),
)
.create_async()
.await;
let create = server
.mock("POST", "/spaces/space_owner_main/posts")
.match_header("x-space-session-token", "space-session-token")
.match_body(Matcher::Regex("\"keyVersion\":3".into()))
.with_status(200)
.with_body(json!({"postId": 42}).to_string())
.create_async()
.await;
let (post_id, _) = ctx
.create_post("space_owner_main", &[], None, None)
.await
.expect("post creation should send key version");
assert_eq!(post_id, 42);
spaces.assert_async().await;
create.assert_async().await;
}
#[tokio::test]
async fn create_post_maps_limit_error() {
let mut server = Server::new_async().await;
let space_root_key = generate_key();
let space_key = generate_key();
let ctx = test_account_ctx_with_space_root_key(&server.url(), space_root_key.clone());
let spaces = server
.mock("GET", "/account/space")
.with_status(200)
.with_body(owned_space_response(
&space_root_key,
&space_key,
"space_owner_main",
"owner-main",
3,
))
.create_async()
.await;
let create = server
.mock("POST", "/spaces/space_owner_main/posts")
.with_status(409)
.with_body(json!({ "code": "CONFLICT" }).to_string())
.create_async()
.await;
let error = ctx
.create_post("space_owner_main", &[], None, None)
.await
.expect_err("post creation should fail");
assert!(matches!(error, Error::PostLimitReached));
spaces.assert_async().await;
create.assert_async().await;
}
#[tokio::test]
async fn create_post_rejects_video_object_media_type() {
let server = Server::new_async().await;
let ctx = test_account_ctx(&server.url());
let post_key = generate_key();
let metadata_cipher = encrypt_post_object_metadata(
&post_key,
&PostObjectMetadata {
width: Some(1920),
height: Some(1080),
media_type: Some("video/mp4".to_owned()),
..Default::default()
},
)
.expect("metadata should encrypt");
let err = ctx
.create_post(
"space_owner_main",
&[PostObjectPayload {
video: None,
object_key: "object-1".to_owned(),
size: None,
position: Some(0),
metadata_cipher: Some(metadata_cipher),
}],
None,
Some(&post_key),
)
.await
.expect_err("video post object should fail before network");
assert!(err.to_string().contains(ONLY_PHOTOS_UPLOAD_MESSAGE));
}
#[tokio::test]
async fn update_space_profile_sends_encrypted_profile_and_profile_assets() {
let mut server = Server::new_async().await;
let space_root_key = generate_key();
let ctx = test_account_ctx_with_space_root_key(&server.url(), space_root_key.clone());
let space_key = generate_key();
let spaces = server
.mock("GET", "/account/space")
.match_header("x-space-session-token", "space-session-token")
.with_status(200)
.with_body(owned_space_response(
&space_root_key,
&space_key,
"space_owner_main",
"owner-main",
3,
))
.create_async()
.await;
let update = server
.mock("POST", "/spaces/space_owner_main/profile")
.match_header("x-space-session-token", "space-session-token")
.match_body(Matcher::AllOf(vec![
Matcher::Regex("\"keyVersion\":3".into()),
Matcher::Regex("\"encryptedProfile\":\"[^\"]+\"".into()),
Matcher::Regex("\"avatar\"".into()),
Matcher::Regex("\"objectID\":\"avatar-object\"".into()),
Matcher::Regex("\"size\":123".into()),
Matcher::Regex("\"cover\"".into()),
Matcher::Regex("\"objectID\":\"cover-object\"".into()),
Matcher::Regex("\"size\":456".into()),
]))
.with_status(200)
.with_body(
json!({
"status": "ok",
"avatar": {
"objectID": "avatar-object",
"keyVersion": 3,
"size": 123,
"updatedAt": "2026-04-16T00:00:00Z"
},
"cover": {
"objectID": "cover-object",
"keyVersion": 3,
"size": 456,
"updatedAt": "2026-04-16T00:00:00Z"
}
})
.to_string(),
)
.create_async()
.await;
let response = ctx
.update_space_profile_assets(
"space_owner_main",
b"profile-v2",
Some(ProfileAvatarPayload {
object_id: "avatar-object".to_owned(),
size: Some(123),
}),
Some(ProfileCoverPayload {
object_id: "cover-object".to_owned(),
size: Some(456),
}),
false,
false,
)
.await
.expect("profile update should succeed");
assert_eq!(response.status, "ok");
assert_eq!(
response
.avatar
.as_ref()
.map(|avatar| avatar.object_id.as_str()),
Some("avatar-object")
);
assert_eq!(
response
.cover
.as_ref()
.map(|cover| cover.object_id.as_str()),
Some("cover-object")
);
assert_eq!(
response.avatar.as_ref().map(|avatar| avatar.key_version),
Some(3)
);
assert_eq!(
response.cover.as_ref().map(|cover| cover.key_version),
Some(3)
);
spaces.assert_async().await;
update.assert_async().await;
}
#[tokio::test]
async fn removing_profile_images_sets_only_the_requested_asset_flag() {
let mut server = Server::new_async().await;
let space_root_key = generate_key();
let ctx = test_account_ctx_with_space_root_key(&server.url(), space_root_key.clone());
let space_key = generate_key();
let spaces = server
.mock("GET", "/account/space")
.with_status(200)
.with_body(owned_space_response(
&space_root_key,
&space_key,
"space_owner_main",
"owner-main",
3,
))
.create_async()
.await;
let cover = server
.mock("POST", "/spaces/space_owner_main/profile")
.match_body(Matcher::Regex(
r#"^\{"keyVersion":3,"encryptedProfile":"[^"]+","removeCover":true\}$"#.into(),
))
.with_status(200)
.with_body(r#"{"status":"updated"}"#)
.create_async()
.await;
let avatar = server
.mock("POST", "/spaces/space_owner_main/profile")
.match_body(Matcher::Regex(
r#"^\{"keyVersion":3,"encryptedProfile":"[^"]+","removeAvatar":true\}$"#.into(),
))
.with_status(200)
.with_body(r#"{"status":"updated"}"#)
.create_async()
.await;
ctx.remove_space_profile_cover("space_owner_main", b"profile-v2")
.await
.expect("cover removal should succeed");
ctx.remove_space_profile_avatar("space_owner_main", b"profile-v2")
.await
.expect("avatar removal should succeed");
spaces.assert_async().await;
cover.assert_async().await;
avatar.assert_async().await;
}
#[tokio::test]
async fn get_space_profile_decrypted_loads_and_decrypts_profile() {
let mut server = Server::new_async().await;
let space_root_key = generate_key();
let ctx = test_account_ctx_with_space_root_key(&server.url(), space_root_key.clone());
let space_key = generate_key();
let encrypted_profile = b64::encode(
&encrypt_secretbox_payload(&space_key, br#"{"fullName":"Owner"}"#).expect("profile wrap"),
);
let profile = server
.mock("GET", "/spaces/space_owner_main/profile")
.match_header("x-space-session-token", "space-session-token")
.with_status(200)
.with_body(
json!({
"spaceId": "space_owner_main",
"spaceSlug": "owner-main",
"version": 3,
"friends": 2,
"encryptedProfile": encrypted_profile,
"updatedAt": "2026-04-16T00:00:00Z"
})
.to_string(),
)
.create_async()
.await;
let spaces = server
.mock("GET", "/account/space")
.match_header("x-space-session-token", "space-session-token")
.with_status(200)
.with_body(owned_space_response(
&space_root_key,
&space_key,
"space_owner_main",
"owner-main",
3,
))
.create_async()
.await;
let decrypted = ctx
.get_space_profile_decrypted("space_owner_main", None, None)
.await
.expect("profile should decrypt");
assert_eq!(decrypted.space_id, "space_owner_main");
assert_eq!(decrypted.space_slug, "owner-main");
assert_eq!(decrypted.version, 3);
assert_eq!(decrypted.friends, 2);
assert_eq!(
decrypted.profile.unwrap().full_name.as_deref(),
Some("Owner")
);
profile.assert_async().await;
spaces.assert_async().await;
}
#[tokio::test]
async fn get_space_profile_decrypted_returns_decryption_error() {
let mut server = Server::new_async().await;
let space_root_key = generate_key();
let ctx = test_account_ctx_with_space_root_key(&server.url(), space_root_key.clone());
let space_key = generate_key();
let encrypted_profile = b64::encode(
&encrypt_secretbox_payload(&generate_key(), b"profile-json").expect("profile wrap"),
);
let profile = server
.mock("GET", "/spaces/space_owner_main/profile")
.match_header("x-space-session-token", "space-session-token")
.with_status(200)
.with_body(
json!({
"spaceId": "space_owner_main",
"spaceSlug": "owner-main",
"version": 3,
"friends": 2,
"encryptedProfile": encrypted_profile,
"updatedAt": "2026-04-16T00:00:00Z"
})
.to_string(),
)
.create_async()
.await;
let spaces = server
.mock("GET", "/account/space")
.match_header("x-space-session-token", "space-session-token")
.with_status(200)
.with_body(owned_space_response(
&space_root_key,
&space_key,
"space_owner_main",
"owner-main",
3,
))
.create_async()
.await;
let error = ctx
.get_space_profile_decrypted("space_owner_main", None, None)
.await
.expect_err("profile decryption should fail");
assert!(matches!(error, Error::Crypto(_)));
profile.assert_async().await;
spaces.assert_async().await;
}
#[tokio::test]
async fn get_space_profile_for_display_keeps_envelope_on_decryption_error() {
let mut server = Server::new_async().await;
let space_root_key = generate_key();
let ctx = test_account_ctx_with_space_root_key(&server.url(), space_root_key.clone());
let space_key = generate_key();
let encrypted_profile = b64::encode(
&encrypt_secretbox_payload(&generate_key(), b"profile-json").expect("profile wrap"),
);
let profile = server
.mock("GET", "/spaces/space_owner_main/profile")
.match_header("x-space-session-token", "space-session-token")
.with_status(200)
.with_body(
json!({
"spaceId": "space_owner_main",
"spaceSlug": "owner-main",
"version": 3,
"friends": 2,
"encryptedProfile": encrypted_profile,
"updatedAt": "2026-04-16T00:00:00Z"
})
.to_string(),
)
.create_async()
.await;
let spaces = server
.mock("GET", "/account/space")
.match_header("x-space-session-token", "space-session-token")
.with_status(200)
.with_body(owned_space_response(
&space_root_key,
&space_key,
"space_owner_main",
"owner-main",
3,
))
.create_async()
.await;
let decrypted = ctx
.get_space_profile_for_display("space_owner_main", None, None)
.await
.expect("profile envelope should remain available");
assert_eq!(decrypted.space_id, "space_owner_main");
assert_eq!(decrypted.space_slug, "owner-main");
assert_eq!(decrypted.version, 3);
assert_eq!(decrypted.friends, 2);
assert!(decrypted.profile.is_none());
profile.assert_async().await;
spaces.assert_async().await;
}
#[tokio::test]
async fn space_status_mutations_accept_empty_server_responses() {
let mut server = Server::new_async().await;
let ctx = test_account_ctx(&server.url());
let delete_post = server
.mock("DELETE", "/spaces/space_viewer_main/posts/42")
.match_header("x-space-session-token", "space-session-token")
.with_status(200)
.create_async()
.await;
let unfriend_space = server
.mock("POST", "/spaces/space_viewer_main/friends/unfriend")
.match_header("x-space-session-token", "space-session-token")
.match_body(Matcher::JsonString(
json!({"targetSpaceId": "space_owner_main"}).to_string(),
))
.with_status(200)
.create_async()
.await;
let unfriend_username = server
.mock("POST", "/spaces/space_viewer_main/friends/unfriend")
.match_header("x-space-session-token", "space-session-token")
.match_body(Matcher::JsonString(
json!({"targetUsername": "owner"}).to_string(),
))
.with_status(200)
.create_async()
.await;
ctx.delete_post("space_viewer_main", 42)
.await
.expect("delete post should accept empty response");
ctx.unfriend_by_space("space_viewer_main", "space_owner_main")
.await
.expect("unfriend by space should accept empty response");
ctx.unfriend_by_username("space_viewer_main", "owner")
.await
.expect("unfriend by username should accept empty response");
delete_post.assert_async().await;
unfriend_space.assert_async().await;
unfriend_username.assert_async().await;
}
#[tokio::test]
async fn update_post_caption_uses_caption_endpoint() {
let mut server = Server::new_async().await;
let root_key = generate_key();
let space_key = generate_key();
let post_key = generate_key();
let ctx = test_account_ctx_with_space_root_key(&server.url(), root_key.clone());
let spaces = server
.mock("GET", "/account/space")
.with_body(owned_space_response(
&root_key,
&space_key,
"space_owner_main",
"owner",
1,
))
.create_async()
.await;
let mut post = json!({
"postId": 42,
"spaceId": "space_owner_main",
"spaceSlug": "owner",
"author": { "spaceSlug": "owner" },
"encryptedPostKey": b64::encode(&encrypt_secretbox_payload(&space_key, &post_key).unwrap()),
"captionCipher": b64::encode(&encrypt_secretbox_payload(&post_key, b"old caption").unwrap()),
"keyVersion": 1,
"objects": [],
"createdAt": "2026-04-16T00:00:00Z",
"viewerLiked": false,
});
let read = server
.mock("GET", "/spaces/space_owner_main/posts/42")
.match_query(Matcher::UrlEncoded(
"viewerSpaceId".into(),
"space_owner_main".into(),
))
.with_body(post.to_string())
.create_async()
.await;
let update = server
.mock("POST", "/spaces/space_owner_main/posts/42/caption")
.match_header("x-space-session-token", "space-session-token")
.match_body(Matcher::AllOf(vec![Matcher::Regex(
"\"captionCipher\":\"[^\"]+\"".into(),
)]))
.with_status(200)
.create_async()
.await;
ctx.update_post_caption("space_owner_main", 42, Some(b"updated caption".as_slice()))
.await
.expect("caption update should succeed");
spaces.assert_async().await;
read.assert_async().await;
read.remove_async().await;
post["captionCipher"] = "not-base64".into();
let corrupt = server
.mock("GET", "/spaces/space_owner_main/posts/42")
.match_query(Matcher::Any)
.with_body(post.to_string())
.create_async()
.await;
assert!(matches!(
ctx.update_post_caption("space_owner_main", 42, Some(b"updated caption"))
.await,
Err(Error::Base64Decode(_))
));
corrupt.assert_async().await;
update.assert_async().await;
}
#[tokio::test]
async fn like_post_uses_post_like_endpoint() {
let mut server = Server::new_async().await;
let ctx = test_account_ctx(&server.url());
let like = server
.mock("PUT", "/spaces/space_owner_main/posts/42/like")
.match_header("x-space-session-token", "space-session-token")
.with_status(200)
.with_body(json!({"liked": true}).to_string())
.create_async()
.await;
let response = ctx
.like_post("space_owner_main", 42, true)
.await
.expect("post like should succeed");
assert!(response.liked);
like.assert_async().await;
}
#[tokio::test]
async fn list_post_likes_skips_key_loading_when_empty() {
let mut server = Server::new_async().await;
let ctx = test_account_ctx(&server.url());
let likes = server
.mock("GET", "/spaces/space_owner_main/posts/42/likes")
.with_body("[]")
.create_async()
.await;
let shares = server
.mock("GET", "/spaces/space_owner_main/friends/shares")
.expect(0)
.create_async()
.await;
assert!(
ctx.list_post_likes("space_owner_main", 42)
.await
.unwrap()
.is_empty()
);
likes.assert_async().await;
shares.assert_async().await;
}
#[tokio::test]
async fn list_post_likes_returns_all_actors() {
let mut server = Server::new_async().await;
let ctx = test_account_ctx(&server.url());
let likes = server
.mock("GET", "/spaces/space_owner_main/posts/42/likes")
.match_header("x-space-session-token", "space-session-token")
.with_body(
json!([
{"spaceId":"friend1", "spaceSlug":"maya"},
{"spaceId":"friend2", "spaceSlug":"bob"},
{"spaceId":"friend3", "spaceSlug":"alex"}
])
.to_string(),
)
.create_async()
.await;
let shares = server
.mock("GET", "/spaces/space_owner_main/friends/shares")
.with_body("[]")
.create_async()
.await;
let actors = ctx.list_post_likes("space_owner_main", 42).await.unwrap();
assert_eq!(actors.len(), 3);
assert_eq!(actors[0].space_slug, "maya");
assert_eq!(actors[2].space_id, "friend3");
likes.assert_async().await;
shares.assert_async().await;
}
#[tokio::test]
async fn unread_badge_stops_without_loading_conversations() {
for kind in ["regular", "post_reply"] {
let mut server = Server::new_async().await;
let ctx = test_account_ctx(&server.url());
let key = generate_key();
let encrypted_key =
b64::encode(&seal_with_public_key(&key, &test_public_key(&ctx)).unwrap());
let cipher = b64::encode(
&encrypt_secretbox_payload(
&key,
&serde_json::to_vec(&json!({"version":1,"kind":kind,"text":"Hello"})).unwrap(),
)
.unwrap(),
);
let status = server
.mock("GET", "/spaces/space_owner_main/unread")
.with_body(json!({"notificationsUnread":true}).to_string())
.create_async()
.await;
let activities = server
.mock("GET", "/spaces/space_owner_main/unread/activities")
.match_query(Matcher::UrlEncoded("cursor".into(), String::new()))
.with_body(json!({"items":[{"kind":kind,"messageCipher":cipher,"encryptedMessageKey":encrypted_key}],"nextCursor":"older"}).to_string())
.create_async()
.await;
let older = server
.mock("GET", "/spaces/space_owner_main/unread/activities")
.match_query(Matcher::UrlEncoded("cursor".into(), "older".into()))
.expect(0)
.create_async()
.await;
let conversations = server
.mock("GET", "/spaces/space_owner_main/conversations")
.with_status(500)
.expect(0)
.create_async()
.await;
assert!(
ctx.unread_status("space_owner_main")
.await
.unwrap()
.notifications_unread
);
status.assert_async().await;
activities.assert_async().await;
older.assert_async().await;
conversations.assert_async().await;
}
}
#[tokio::test]
async fn unread_methods_use_read_marker_endpoints() {
let mut server = Server::new_async().await;
let ctx = test_account_ctx(&server.url());
let status = server
.mock("GET", "/spaces/space_owner_main/unread")
.match_header("x-space-session-token", "space-session-token")
.with_status(200)
.with_body(json!({"notificationsUnread": false}).to_string())
.create_async()
.await;
let notifications_read = server
.mock("POST", "/spaces/space_owner_main/friends/space_friend/read")
.match_header("x-space-session-token", "space-session-token")
.with_status(200)
.with_body(json!({"notificationsUnread": false}).to_string())
.create_async()
.await;
let unread = ctx
.unread_status("space_owner_main")
.await
.expect("unread status should load");
assert!(!unread.notifications_unread);
assert!(
!ctx.mark_notifications_read("space_owner_main", "space_friend")
.await
.expect("notifications read")
.notifications_unread
);
status.assert_async().await;
notifications_read.assert_async().await;
}
#[tokio::test]
async fn message_actions_use_message_endpoints() {
let mut server = Server::new_async().await;
let space_root_key = generate_key();
let ctx = test_account_ctx_with_space_root_key(&server.url(), space_root_key.clone());
let (friend_public_key, _) = generate_keypair().expect("valid friend keypair");
let friends = server
.mock("GET", "/spaces/space_owner_main/friends")
.match_header("x-space-session-token", "space-session-token")
.with_status(200)
.with_body(
json!([{
"friend": {
"spaceId": "space_friend",
"spaceSlug": "friend",
"publicKey": b64::encode(&friend_public_key),
"keyVersion": 2
},
"shareKeyVersion": 2,
"createdAt": "2026-04-16T00:00:00Z"
}])
.to_string(),
)
.create_async()
.await;
let reply = server
.mock(
"POST",
"/spaces/space_owner_main/friends/space_friend/messages",
)
.match_header("x-space-session-token", "space-session-token")
.match_body(Matcher::AllOf(vec![
Matcher::Regex("\"replyMessageId\":\"wmsg_parent\"".into()),
Matcher::Regex("\"messageCipher\":\"[^\"]+\"".into()),
Matcher::Regex("\"senderEncryptedMessageKey\":\"[^\"]+\"".into()),
Matcher::Regex("\"recipientEncryptedMessageKey\":\"[^\"]+\"".into()),
]))
.with_status(200)
.with_body_from_request(|request| {
let body: serde_json::Value = serde_json::from_slice(request.body().unwrap()).unwrap();
json!({
"messageId": "wmsg_reply",
"kind": "regular",
"senderSpaceId": "space_owner_main",
"recipientSpaceId": "space_friend",
"messageCipher": body["messageCipher"],
"encryptedMessageKey": body["senderEncryptedMessageKey"],
"replyMessageId": "wmsg_parent",
"liked": false,
"viewerLiked": false,
"isDeleted": false,
"createdAt": "2026-04-16T00:00:00Z",
"updatedAt": "2026-04-16T00:00:00Z"
})
.to_string()
.into_bytes()
})
.create_async()
.await;
let like = server
.mock("PUT", "/spaces/space_owner_main/messages/wmsg_reply/like")
.match_header("x-space-session-token", "space-session-token")
.with_status(200)
.with_body(json!({"liked": true}).to_string())
.create_async()
.await;
let delete = server
.mock("DELETE", "/spaces/space_owner_main/messages/wmsg_reply")
.match_header("x-space-session-token", "space-session-token")
.with_status(200)
.create_async()
.await;
let created = ctx
.reply_to_message("space_owner_main", "space_friend", "wmsg_parent", "hello")
.await
.expect("message reply should be sent");
let liked = ctx
.like_message("space_owner_main", "wmsg_reply", true)
.await
.expect("message like should be sent");
ctx.delete_message("space_owner_main", "wmsg_reply")
.await
.expect("message delete should be sent");
assert_eq!(created.reply_message_id.as_deref(), Some("wmsg_parent"));
assert!(liked.liked);
friends.assert_async().await;
reply.assert_async().await;
like.assert_async().await;
delete.assert_async().await;
}
#[tokio::test]
async fn pokes_use_their_own_endpoint_and_retry_id() {
let mut server = Server::new_async().await;
let ctx = test_account_ctx(&server.url());
let poke = server
.mock(
"POST",
"/spaces/space_owner_main/friends/space_friend/pokes",
)
.match_header("x-space-session-token", "space-session-token")
.match_body(Matcher::Json(json!({"clientRequestId":"poke-request-1"})))
.with_status(200)
.create_async()
.await;
ctx.send_poke("space_owner_main", "space_friend", "poke-request-1")
.await
.unwrap();
poke.assert_async().await;
}
#[test]
fn message_payload_limits_reject_oversized_text_and_payload() {
let valid = MessagePayload {
version: 1,
kind: MESSAGE_KIND_REGULAR.to_owned(),
text: "hello".to_owned(),
reply_object_key: None,
};
let valid_plaintext = serde_json::to_vec(&valid).expect("valid payload json");
validate_message_payload(&valid, valid_plaintext.len())
.expect("short message should be accepted");
let too_many_chars = MessagePayload {
text: "a".repeat(MAX_SPACE_MESSAGE_TEXT_CHARS + 1),
..valid.clone()
};
let plaintext = serde_json::to_vec(&too_many_chars).expect("long text json");
let err = validate_message_payload(&too_many_chars, plaintext.len())
.expect_err("long message text should be rejected");
assert!(err.to_string().contains("characters or fewer"));
let err = validate_message_payload(&valid, MAX_SPACE_MESSAGE_PAYLOAD_BYTES + 1)
.expect_err("large serialized payload should be rejected");
assert!(err.to_string().contains("payload must be"));
}
#[tokio::test]
async fn post_replies_encrypt_photo_references_and_reject_other_photos() {
let mut server = Server::new_async().await;
let ctx = test_account_ctx(&server.url());
let (public_key, _) = generate_keypair().unwrap();
let owned = server
.mock("GET", "/account/space")
.with_body("[]")
.create_async()
.await;
let post = server.mock("GET", "/spaces/space_friend/posts/42")
.match_query(Matcher::UrlEncoded("viewerSpaceId".into(), "space_owner_main".into()))
.with_body(json!({
"postId": 42,
"spaceId": "space_friend",
"spaceSlug": "friend",
"author": { "spaceId": "space_friend", "spaceSlug": "friend", "publicKey": b64::encode(&public_key) },
"encryptedPostKey": "unused",
"keyVersion": 1,
"viewerLiked": false,
"createdAt": "2026-09-19T00:00:00Z",
"objects": [
{ "objectKey": "first", "metadataCipher": "unused" },
{ "objectKey": "second", "metadataCipher": "unused" }
]
}).to_string())
.expect(4).create_async().await;
let reply = server
.mock("POST", "/spaces/space_owner_main/posts/42/reply")
.with_body_from_request(|request| {
let body: serde_json::Value = serde_json::from_slice(request.body().unwrap()).unwrap();
assert!(body.get("replyObjectKey").is_none());
json!({
"messageId": "reply",
"kind": "post_reply",
"senderSpaceId": "space_owner_main",
"recipientSpaceId": "space_friend",
"replyPostId": 42,
"messageCipher": body["messageCipher"],
"encryptedMessageKey": body["senderEncryptedMessageKey"],
"createdAt": "2026-09-19T00:00:00Z",
"updatedAt": "2026-09-19T00:00:00Z"
})
.to_string()
.into_bytes()
})
.expect(3)
.create_async()
.await;
for object_key in [None, Some("first"), Some("second")] {
let response = ctx
.reply_to_post("space_owner_main", "space_friend", 42, "Coo", object_key)
.await
.unwrap();
let content = response.content.unwrap().unwrap();
assert_eq!(content.text, "Coo");
assert_eq!(content.reply_object_key.as_deref(), object_key);
}
let error = ctx
.reply_to_post(
"space_owner_main",
"space_friend",
42,
"Coo",
Some("unrelated"),
)
.await
.err()
.unwrap();
assert!(matches!(error, Error::InvalidInput(_)));
owned.assert_async().await;
post.assert_async().await;
reply.assert_async().await;
}
#[tokio::test]
async fn list_space_friends_uses_space_friends_endpoint() {
let mut server = Server::new_async().await;
let ctx = test_account_ctx(&server.url());
let friends = server
.mock("GET", "/spaces/space_owner_main/friends")
.match_header("x-space-session-token", "space-session-token")
.with_status(200)
.with_body(
json!([{
"friend": {
"spaceId": "space_friend",
"spaceSlug": "friend",
"publicKey": "friend-public-key",
"keyVersion": 2
},
"shareKeyVersion": 2,
"createdAt": "2026-04-16T00:00:00Z"
}])
.to_string(),
)
.create_async()
.await;
let response = ctx
.list_space_friends("space_owner_main")
.await
.expect("friends should load");
assert_eq!(response.len(), 1);
assert_eq!(response[0].friend.space_id, "space_friend");
assert!(response[0].friend.profile.as_ref().unwrap().is_none());
assert_eq!(response[0].share_key_version, 2);
friends.assert_async().await;
}
#[tokio::test]
async fn sent_friend_request_actions_use_request_endpoints() {
let mut server = Server::new_async().await;
let ctx = test_account_ctx(&server.url());
let list = server
.mock("GET", "/spaces/space_owner_main/friends/requests/sent")
.match_header("x-space-session-token", "space-session-token")
.with_status(200)
.with_body(
json!([{
"requestId": 42,
"target": {
"spaceId": "space_target",
"spaceSlug": "target",
"publicKey": "target-public-key",
"keyVersion": 1
},
"createdAt": "2026-04-16T00:00:00Z"
}])
.to_string(),
)
.create_async()
.await;
let cancel = server
.mock("DELETE", "/spaces/space_owner_main/friends/requests/42")
.match_header("x-space-session-token", "space-session-token")
.with_status(200)
.create_async()
.await;
let response = ctx
.list_sent_friend_requests("space_owner_main")
.await
.expect("sent friend requests should load");
ctx.delete_friend_request("space_owner_main", 42)
.await
.expect("sent friend request should cancel");
assert_eq!(response.len(), 1);
assert_eq!(response[0].request_id, 42);
assert_eq!(response[0].target.space_id, "space_target");
list.assert_async().await;
cancel.assert_async().await;
}
#[tokio::test]
async fn get_relationship_uses_relationship_endpoint() {
let mut server = Server::new_async().await;
let ctx = test_account_ctx(&server.url());
let relationship = server
.mock("GET", "/spaces/space_owner_main/friends/relationship")
.match_header("x-space-session-token", "space-session-token")
.match_query(Matcher::AllOf(vec![Matcher::UrlEncoded(
"targetSpaceId".into(),
"space_friend".into(),
)]))
.with_status(200)
.with_body(json!({"relationship": "friend"}).to_string())
.create_async()
.await;
let response = ctx
.get_relationship("space_owner_main", "space_friend")
.await
.expect("relationship should load");
assert_eq!(response.relationship, "friend");
relationship.assert_async().await;
}
#[tokio::test]
async fn refresh_friend_shares_accepts_empty_server_response() {
let mut server = Server::new_async().await;
let space_root_key = generate_key();
let ctx = test_account_ctx_with_space_root_key(&server.url(), space_root_key.clone());
let space_key = generate_key();
let (friend_public_key, _) = generate_keypair().expect("valid friend keypair");
let spaces = server
.mock("GET", "/account/space")
.match_header("x-space-session-token", "space-session-token")
.with_status(200)
.with_body(
json!([{
"spaceId": "space_owner_main",
"spaceSlug": "owner-main",
"rootWrappedSpaceKey": b64::encode(&encrypt_secretbox_payload(&space_root_key, &space_key).expect("space key wrap")),
"encryptedProfile": "",
"keyVersion": 3
}])
.to_string(),
)
.create_async()
.await;
let friends = server
.mock("GET", "/spaces/space_owner_main/friends")
.match_header("x-space-session-token", "space-session-token")
.with_status(200)
.with_body(
json!([{
"friend": {
"spaceId": "space_viewer",
"spaceSlug": "viewer",
"publicKey": b64::encode(&friend_public_key),
"keyVersion": 2
},
"shareKeyVersion": 2,
"createdAt": "2026-04-16T00:00:00Z"
}])
.to_string(),
)
.create_async()
.await;
let refresh = server
.mock("POST", "/spaces/space_owner_main/friends/shares/refresh")
.match_header("x-space-session-token", "space-session-token")
.match_body(Matcher::AllOf(vec![
Matcher::Regex("\"friendSpaceId\":\"space_viewer\"".into()),
Matcher::Regex("\"keyVersion\":3".into()),
]))
.with_status(200)
.create_async()
.await;
let updated = ctx
.refresh_friend_shares("space_owner_main")
.await
.expect("refresh should accept empty response");
assert_eq!(updated, 1);
spaces.assert_async().await;
friends.assert_async().await;
refresh.assert_async().await;
}
#[tokio::test]
async fn list_feed_uses_feed_endpoint() {
let mut server = Server::new_async().await;
let root_key = generate_key();
let space_key = generate_key();
let ctx = test_account_ctx_with_space_root_key(&server.url(), root_key.clone());
let spaces = server
.mock("GET", "/account/space")
.with_status(200)
.with_body(owned_space_response(
&root_key,
&space_key,
"space_friend_gallery",
"gallery",
3,
))
.create_async()
.await;
let shares = server
.mock("GET", "/spaces/space_owner_main/friends/shares")
.match_header("x-space-session-token", "space-session-token")
.with_status(200)
.with_body("[]")
.create_async()
.await;
let feed = server
.mock("GET", "/spaces/space_owner_main/feed")
.match_header("x-space-session-token", "space-session-token")
.match_query(Matcher::AllOf(vec![
Matcher::UrlEncoded("cursor".into(), "cursor-1".into()),
Matcher::UrlEncoded("limit".into(), "5".into()),
]))
.with_status(200)
.with_body(
json!({
"items": [{
"postId": 42,
"spaceId": "space_friend_gallery",
"spaceSlug": "friend-gallery",
"author": {
"spaceId": "space_owner_gallery",
"spaceSlug": "owner-gallery"
},
"encryptedPostKey": b64::encode(&encrypt_secretbox_payload(&space_key, &generate_key()).unwrap()),
"captionCipher": "",
"keyVersion": 3,
"objects": [{"objectKey": "photo"}],
"createdAt": "2026-04-16T00:00:00Z",
"viewerLiked": true
}],
"nextCursor": "cursor-2"
})
.to_string(),
)
.create_async()
.await;
let page = ctx
.list_feed("space_owner_main", Some("cursor-1".to_owned()), Some(5))
.await
.expect("feed should load");
assert_eq!(page.items.len(), 1);
assert!(page.items[0].content.is_ok());
spaces.assert_async().await;
assert_eq!(page.items[0].post_id, 42);
assert_eq!(page.next_cursor, "cursor-2");
shares.assert_async().await;
feed.assert_async().await;
}
#[tokio::test]
async fn list_posts_uses_space_posts_page_endpoint() {
let mut server = Server::new_async().await;
let root_key = generate_key();
let space_key = generate_key();
let ctx = test_account_ctx_with_space_root_key(&server.url(), root_key.clone());
let spaces = server
.mock("GET", "/account/space")
.with_status(200)
.with_body(owned_space_response(
&root_key,
&space_key,
"space_owner_main",
"gallery",
3,
))
.create_async()
.await;
let posts = server
.mock("GET", "/spaces/space_owner_gallery/posts")
.match_header("x-space-session-token", "space-session-token")
.match_query(Matcher::AllOf(vec![
Matcher::UrlEncoded("viewerSpaceId".into(), "space_owner_main".into()),
Matcher::UrlEncoded("cursor".into(), "42".into()),
Matcher::UrlEncoded("limit".into(), "5".into()),
]))
.with_status(200)
.with_body(
json!({
"items": [{
"postId": 41,
"spaceId": "space_owner_main",
"spaceSlug": "owner-main",
"author": {
"spaceId": "space_owner_gallery",
"spaceSlug": "owner-gallery"
},
"encryptedPostKey": b64::encode(&encrypt_secretbox_payload(&space_key, &generate_key()).unwrap()),
"captionCipher": "",
"keyVersion": 3,
"objects": [{"objectKey": "photo"}],
"createdAt": "2026-04-16T00:00:00Z",
"viewerLiked": true
}],
"nextCursor": "41"
})
.to_string(),
)
.create_async()
.await;
let page = ctx
.list_posts(
"space_owner_gallery",
Some("space_owner_main"),
Some("42".to_owned()),
Some(5),
)
.await
.expect("post page should load");
assert_eq!(page.items.len(), 1);
assert!(page.items[0].content.is_ok());
spaces.assert_async().await;
assert_eq!(page.items[0].post_id, 41);
assert_eq!(page.next_cursor, "41");
posts.assert_async().await;
}
#[tokio::test]
async fn get_post_returns_decrypted_content() {
let mut server = Server::new_async().await;
let space_root_key = generate_key();
let ctx = test_account_ctx_with_space_root_key(&server.url(), space_root_key.clone());
let space_key = generate_key();
let post_key = generate_key();
let caption = b"hello from post";
let spaces = server
.mock("GET", "/account/space")
.match_header("x-space-session-token", "space-session-token")
.with_status(200)
.with_body(
json!([{
"spaceId": "space_owner_gallery",
"spaceSlug": "owner-gallery",
"rootWrappedSpaceKey": b64::encode(&encrypt_secretbox_payload(&space_root_key, &space_key).expect("space key wrap")),
"encryptedProfile": "",
"keyVersion": 3
}])
.to_string(),
)
.create_async()
.await;
let post = server
.mock("GET", "/spaces/space_owner_gallery/posts/42")
.match_header("x-space-session-token", "space-session-token")
.with_status(200)
.with_body(
json!({
"postId": 42,
"spaceId": "space_owner_gallery",
"spaceSlug": "owner-gallery",
"author": {
"spaceId": "space_owner_gallery",
"spaceSlug": "owner-gallery"
},
"encryptedPostKey": b64::encode(&encrypt_secretbox_payload(&space_key, &post_key).expect("post key wrap")),
"captionCipher": b64::encode(&encrypt_secretbox_payload(&post_key, caption).expect("caption wrap")),
"keyVersion": 3,
"objects": [{"objectKey": "photo"}],
"createdAt": "2026-04-16T00:00:00Z",
"viewerLiked": false
})
.to_string(),
)
.create_async()
.await;
let decrypted = ctx
.get_post("space_owner_gallery", 42, None)
.await
.expect("post should decrypt");
assert_eq!(decrypted.post_id, 42);
assert_eq!(
decrypted.content.unwrap().caption.as_deref(),
Some("hello from post")
);
spaces.assert_async().await;
post.assert_async().await;
}
#[tokio::test]
async fn hydrate_space_keys_loads_owned_and_friends_spaces() {
let mut server = Server::new_async().await;
let space_root_key = generate_key();
let ctx = test_account_ctx_with_space_root_key(&server.url(), space_root_key.clone());
let owned_space_key = generate_key();
let shared_space_key = generate_key();
let sealed_share = seal_with_public_key(&shared_space_key, &test_public_key(&ctx))
.expect("sealed space share");
let owned = server
.mock("GET", "/account/space")
.match_header("x-space-session-token", "space-session-token")
.with_status(200)
.with_body(
json!([{
"spaceId": "space_owner_main",
"spaceSlug": "owner-main",
"rootWrappedSpaceKey": b64::encode(&encrypt_secretbox_payload(&space_root_key, &owned_space_key).expect("owned wrap")),
"encryptedProfile": "",
"keyVersion": 1
}])
.to_string(),
)
.create_async()
.await;
let shares = server
.mock("GET", "/spaces/space_owner_main/friends/shares")
.match_header("x-space-session-token", "space-session-token")
.with_status(200)
.with_body(
json!([{
"friend": "owner",
"spaceId": "space_shared_gallery",
"spaceSlug": "shared-gallery",
"friendSealedSpaceKey": b64::encode(&sealed_share),
"encryptedProfile": "",
"keyVersion": 4
}])
.to_string(),
)
.create_async()
.await;
let hydrated = ctx
.hydrate_space_keys()
.await
.expect("space keys should hydrate");
assert_eq!(hydrated.owned.len(), 1);
assert_eq!(hydrated.owned[0].0, "space_owner_main");
assert_eq!(hydrated.owned[0].1, owned_space_key);
assert_eq!(hydrated.friends.len(), 1);
assert_eq!(hydrated.friends[0].space_id, "space_shared_gallery");
assert_eq!(hydrated.friends[0].space_key, shared_space_key);
owned.assert_async().await;
shares.assert_async().await;
}
#[test]
fn build_history_walks_back_versions() {
let v3 = generate_key();
let v2 = generate_key();
let v1 = generate_key();
let versions = vec![
SpaceKeyVersionResponse {
version: 3,
wrapped_prev_key: b64::encode(&encrypt_secretbox_payload(&v3, &v2).expect("wrap v2")),
created_at: "2026-01-03T00:00:00Z".to_owned(),
},
SpaceKeyVersionResponse {
version: 2,
wrapped_prev_key: b64::encode(&encrypt_secretbox_payload(&v2, &v1).expect("wrap v1")),
created_at: "2026-01-02T00:00:00Z".to_owned(),
},
];
let history = build_space_key_history_map(3, &v3, &versions).expect("history");
assert_eq!(history.get(&3), Some(&v3));
assert_eq!(history.get(&2), Some(&v2));
assert_eq!(history.get(&1), Some(&v1));
}
#[tokio::test]
async fn legacy_pokes_are_hidden_from_threads_previews_and_unread_status() {
for has_message in [true, false] {
let mut server = Server::new_async().await;
let ctx = test_account_ctx(&server.url());
let key = generate_key();
let encrypted_key =
b64::encode(&seal_with_public_key(&key, &test_public_key(&ctx)).unwrap());
let make_message = |id: &str, kind: &str, created_at: &str| {
let cipher = b64::encode(&encrypt_secretbox_payload(&key, &serde_json::to_vec(&json!({"version":1,"kind":kind,"text":if kind == "poke" {"Poked"} else {"Hello"}})).unwrap()).unwrap());
json!({"messageId":id,"kind":"regular","senderSpaceId":"space_friend","recipientSpaceId":"space_owner_main","messageCipher":cipher,"encryptedMessageKey":encrypted_key,"liked":false,"viewerLiked":false,"isDeleted":false,"createdAt":created_at,"updatedAt":created_at})
};
let poke = make_message("poke", "poke", "2026-10-07T12:00:00Z");
let message = make_message("message", "regular", "2026-10-06T12:00:00Z");
let make_activity = |message: &serde_json::Value| {
let mut activity = message.clone();
activity["id"] = json!(format!(
"message:{}",
message["messageId"].as_str().unwrap()
));
activity["type"] = json!("message");
activity
};
let mut unread = vec![make_activity(&poke)];
if has_message {
unread.push(make_activity(&message));
}
let conversations = server.mock("GET", "/spaces/space_owner_main/conversations")
.with_body(json!({"friends":[],"chatSummaries":{"space_friend":{"latestActivity":make_activity(&poke),"unreadActivities":unread}}}).to_string())
.expect(1).create_async().await;
let unread_first = server
.mock("GET", "/spaces/space_owner_main/unread/activities")
.match_query(Matcher::UrlEncoded("cursor".into(), String::new()))
.with_body(json!({"items":[poke],"nextCursor":"older"}).to_string())
.create_async()
.await;
let unread_second = server
.mock("GET", "/spaces/space_owner_main/unread/activities")
.match_query(Matcher::UrlEncoded("cursor".into(), "older".into()))
.with_body(
json!({"items":if has_message {vec![message.clone()]} else {vec![]}}).to_string(),
)
.create_async()
.await;
let first = server
.mock(
"GET",
"/spaces/space_owner_main/friends/space_friend/messages",
)
.match_query(Matcher::Exact("limit=100".into()))
.with_body(json!({"items":[poke],"nextCursor":"older"}).to_string())
.expect(1)
.create_async()
.await;
let second = server
.mock(
"GET",
"/spaces/space_owner_main/friends/space_friend/messages",
)
.match_query(Matcher::AllOf(vec![
Matcher::UrlEncoded("cursor".into(), "older".into()),
Matcher::UrlEncoded("limit".into(), "100".into()),
]))
.with_body(json!({"items":if has_message {vec![message]} else {vec![]}}).to_string())
.expect(1)
.create_async()
.await;
let status = server
.mock("GET", "/spaces/space_owner_main/unread")
.with_body(json!({"notificationsUnread":true}).to_string())
.create_async()
.await;
let result = ctx.list_conversations("space_owner_main").await.unwrap();
if has_message {
let summary = &result.chat_summaries["space_friend"];
assert_eq!(summary.latest_activity.kind, "regular");
assert_eq!(
summary
.latest_activity
.content
.as_ref()
.unwrap()
.as_ref()
.unwrap()
.text,
"Hello"
);
assert_eq!(summary.unread_activities.len(), 1);
assert_eq!(summary.unread_activities[0].kind, "regular");
} else {
assert!(result.chat_summaries.is_empty());
}
assert_eq!(
ctx.unread_status("space_owner_main")
.await
.unwrap()
.notifications_unread,
has_message
);
conversations.assert_async().await;
unread_first.assert_async().await;
unread_second.assert_async().await;
first.assert_async().await;
second.assert_async().await;
status.assert_async().await;
}
}