Skip to content

armgit / ente

Public Imported from GitHub
0

πŸ’š End-to-end encrypted cloud for everything.

88.5 KB
Raw Blame
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,
            &current_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;
    }
}