Skip to content

armgit / ente

Public Imported from GitHub
0

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

28.5 KB
Raw Blame
use super::{
    AccountSpaceCtx, MESSAGE_KIND_POKE, MESSAGE_KIND_REGULAR, PostPhotoInput,
    decrypt_post_object_metadata, ensure_post_objects_supported, retain_content_error,
};
use crate::crypto::{decrypt_secretbox_payload, encrypt_secretbox_payload, generate_key};
use crate::error::{Error, Result};
use crate::models::{
    HydratedKeys, Post, PostAsset, PostContent, PostPage, PostPhoto, PostVideo, SpaceActor,
    SpaceProfile,
};
use crate::transport::{
    CreatePostRequest, CreatePostResponse, LikePostResponse, PostObjectPayload, PostPageResponse,
    PostResponse, SpaceActorResponse, SpaceUnreadStatusResponse, UnreadActivityPageResponse,
    UpdatePostCaptionRequest,
};
use ente_core::{b64, http};

impl AccountSpaceCtx {
    pub fn generate_post_key(&self) -> Vec<u8> {
        generate_key()
    }

    pub async fn create_photo_post(
        &self,
        space_id: &str,
        photos: impl ExactSizeIterator<Item = PostPhotoInput>,
        caption: Option<&str>,
    ) -> Result<Post> {
        let photo_count = photos.len();
        if !(1..=10).contains(&photo_count) {
            return Err(Error::InvalidInput("Choose between 1 and 10 photos".into()));
        }
        let post_key = self.generate_post_key();
        let mut objects = Vec::with_capacity(photo_count);
        for (position, photo) in photos.enumerate() {
            let mut object = self
                .upload_post_photo_asset(space_id, &post_key, &photo.bytes, photo.options)
                .await?;
            object.position = Some(position as i32);
            objects.push(object);
        }
        let (post_id, _) = self
            .create_post(
                space_id,
                &objects,
                caption.map(str::as_bytes),
                Some(&post_key),
            )
            .await?;
        self.get_post(space_id, post_id, Some(space_id)).await
    }

    pub async fn create_post(
        &self,
        space_id: &str,
        objects: &[PostObjectPayload],
        caption_plaintext: Option<&[u8]>,
        post_key: Option<&[u8]>,
    ) -> Result<(i64, Vec<u8>)> {
        self.create_post_with_request_id(space_id, objects, caption_plaintext, post_key, None)
            .await
    }

    pub async fn create_post_with_request_id(
        &self,
        space_id: &str,
        objects: &[PostObjectPayload],
        caption_plaintext: Option<&[u8]>,
        post_key: Option<&[u8]>,
        client_request_id: Option<String>,
    ) -> Result<(i64, Vec<u8>)> {
        let post_key_bytes = post_key.map_or_else(generate_key, ToOwned::to_owned);
        ensure_post_objects_supported(objects, &post_key_bytes)?;
        let access = self
            .resolve_owned_space_access(space_id)
            .await?
            .ok_or_else(|| {
                Error::InvalidInput(format!("space {space_id} is not owned by the account"))
            })?;
        let caption_cipher = match caption_plaintext {
            Some(value) => Some(b64::encode(&encrypt_secretbox_payload(
                &post_key_bytes,
                value,
            )?)),
            None => None,
        };
        let request = CreatePostRequest {
            client_request_id,
            encrypted_post_key: b64::encode(&encrypt_secretbox_payload(
                &access.space_key,
                &post_key_bytes,
            )?),
            key_version: access.key_version,
            caption_cipher,
            objects: objects.to_vec(),
        };
        let path = format!("/spaces/{space_id}/posts");
        let response = http::retry_if(
            http::RetryProfile::Interactive,
            || async {
                self.api()
                    .post(&path)
                    .json(&request)
                    .send()
                    .await?
                    .error_for_code()
                    .await?
                    .json::<CreatePostResponse>()
                    .await
            },
            |error| {
                request
                    .client_request_id
                    .as_ref()
                    .is_some_and(|id| !id.is_empty())
                    && error.is_retryable()
            },
        )
        .await
        .map_err(|error| match &error {
            http::Error::Api { code, .. } if code == "CONFLICT" => Error::PostLimitReached,
            _ => error.into(),
        })?;
        Ok((response.post_id, post_key_bytes))
    }

    pub async fn list_posts(
        &self,
        space_id: &str,
        viewer_space_id: Option<&str>,
        cursor: Option<String>,
        limit: Option<i32>,
    ) -> Result<PostPage> {
        let mut query = Vec::new();
        if let Some(value) = viewer_space_id.filter(|value| !value.trim().is_empty()) {
            query.push(("viewerSpaceId", value.to_owned()));
        }
        if let Some(value) = cursor.filter(|value| !value.trim().is_empty()) {
            query.push(("cursor", value));
        }
        if let Some(value) = limit {
            query.push(("limit", value.to_string()));
        }
        let path = format!("/spaces/{space_id}/posts");
        let page = self
            .api()
            .get(&path)
            .query(&query)
            .send()
            .await?
            .error_for_status()?
            .json()
            .await?;
        self.open_post_page(page).await
    }

    pub async fn list_feed(
        &self,
        space_id: &str,
        cursor: Option<String>,
        limit: Option<i32>,
    ) -> Result<PostPage> {
        let mut query = Vec::new();
        if let Some(value) = cursor.filter(|value| !value.trim().is_empty()) {
            query.push(("cursor", value));
        }
        if let Some(value) = limit {
            query.push(("limit", value.to_string()));
        }
        let path = format!("/spaces/{space_id}/feed");
        let fetch_feed = async {
            Ok(self
                .api()
                .get(&path)
                .query(&query)
                .send()
                .await?
                .error_for_status()?
                .json()
                .await?)
        };
        let (page, _) = futures_util::try_join!(
            fetch_feed,
            self.list_decrypted_friend_shares_cached(space_id)
        )?;
        self.open_post_page(page).await
    }

    pub async fn unread_status(&self, space_id: &str) -> Result<SpaceUnreadStatusResponse> {
        let path = format!("/spaces/{space_id}/unread");
        let mut status: SpaceUnreadStatusResponse = self
            .api()
            .get(&path)
            .send()
            .await?
            .error_for_status()?
            .json()
            .await?;
        if status.notifications_unread {
            let path = format!("/spaces/{space_id}/unread/activities");
            let mut cursor = String::new();
            loop {
                let page: UnreadActivityPageResponse = self
                    .api()
                    .get(&path)
                    .query(&[("cursor", &cursor)])
                    .send()
                    .await?
                    .error_for_status()?
                    .json()
                    .await?;
                for activity in page.items {
                    if activity.kind != MESSAGE_KIND_REGULAR
                        || !retain_content_error(
                            self.decrypt_message_fields(
                                space_id,
                                &activity.kind,
                                &activity.encrypted_message_key,
                                &activity.message_cipher,
                            )
                            .await,
                        )?
                        .is_ok_and(|payload| payload.kind == MESSAGE_KIND_POKE)
                    {
                        return Ok(status);
                    }
                }
                if page.next_cursor.is_empty() {
                    status.notifications_unread = false;
                    break;
                }
                cursor = page.next_cursor;
            }
        }
        Ok(status)
    }

    pub async fn mark_notifications_read(
        &self,
        space_id: impl Into<String>,
        friend_space_id: impl Into<String>,
    ) -> Result<SpaceUnreadStatusResponse> {
        let space_id = space_id.into();
        let friend_space_id = friend_space_id.into();
        if space_id.trim().is_empty() {
            return Err(Error::InvalidInput("space id is required".into()));
        }
        if friend_space_id.trim().is_empty() {
            return Err(Error::InvalidInput("friend space id is required".into()));
        }
        let path = format!("/spaces/{space_id}/friends/{friend_space_id}/read");
        Ok(self
            .api()
            .post(&path)
            .json(&serde_json::json!({}))
            .send()
            .await?
            .error_for_status()?
            .json()
            .await?)
    }

    pub async fn get_post(
        &self,
        space_id: &str,
        post_id: i64,
        viewer_space_id: Option<&str>,
    ) -> Result<Post> {
        let post = self
            .get_post_raw(space_id, post_id, viewer_space_id)
            .await?;
        let post = self.open_post(post, viewer_space_id).await?;
        Ok(Post {
            content: Ok(post.content?),
            ..post
        })
    }

    async fn open_post_page(&self, page: PostPageResponse) -> Result<PostPage> {
        let mut items = Vec::with_capacity(page.items.len());
        for post in page.items {
            items.push(self.open_post(post, None).await?);
        }
        Ok(PostPage {
            items,
            next_cursor: page.next_cursor,
        })
    }

    async fn open_post(
        &self,
        mut post: PostResponse,
        viewer_space_id: Option<&str>,
    ) -> Result<Post> {
        let decrypted = self
            .decrypt_post_for_viewer(&post.space_id, viewer_space_id, &post)
            .await;
        let content = open_post_content(&mut post, decrypted)?;
        let profile = if content.is_ok() {
            retain_content_error(self.decrypt_actor_profile(&post.author).await)?
        } else {
            Ok(None)
        };
        Ok(opened_post(post, content, profile))
    }

    pub(super) async fn get_post_raw(
        &self,
        space_id: &str,
        post_id: i64,
        viewer_space_id: Option<&str>,
    ) -> Result<PostResponse> {
        let path = format!("/spaces/{space_id}/posts/{post_id}");
        let mut query = Vec::new();
        if let Some(value) = viewer_space_id.filter(|value| !value.trim().is_empty()) {
            query.push(("viewerSpaceId", value.to_owned()));
        }
        Ok(self
            .api()
            .get(&path)
            .query(&query)
            .send()
            .await?
            .error_for_status()?
            .json()
            .await?)
    }

    pub async fn download_post_asset(
        &self,
        asset: &PostAsset,
        viewer_space_id: Option<&str>,
    ) -> Result<Vec<u8>> {
        let post_key = self
            .decrypt_post_key_fields(
                &asset.space_id,
                viewer_space_id,
                &asset.encrypted_post_key,
                asset.key_version,
            )
            .await?;
        self.download_decrypted_asset(
            &asset.space_id,
            viewer_space_id,
            &asset.object_key,
            &post_key,
        )
        .await
    }

    pub async fn hydrate_space_keys(&self) -> Result<HydratedKeys> {
        let space_root_key = self.get_space_root_key()?;
        let owned_records = self.list_owned_spaces().await?;
        let mut owned = Vec::with_capacity(owned_records.len());
        if let Some(space_root_key) = space_root_key {
            for record in owned_records {
                let packed = b64::decode(&record.root_wrapped_space_key)?;
                let space_key = decrypt_secretbox_payload(&space_root_key, &packed)?;
                owned.push((record.space_id, space_key));
            }
        }

        let mut friends = Vec::new();
        for (space_id, _) in &owned {
            let friends_records = self.list_friend_shares(space_id).await?;
            for record in &friends_records {
                friends.push(self.decrypt_friend_share(space_id, record).await?);
            }
        }

        Ok(HydratedKeys { owned, friends })
    }

    pub(super) async fn decrypt_post_key_fields(
        &self,
        space_id: &str,
        viewer_space_id: Option<&str>,
        encrypted_post_key: &str,
        key_version: i32,
    ) -> Result<Vec<u8>> {
        let space_key = self
            .resolve_space_key_for_version_for_viewer(space_id, viewer_space_id, Some(key_version))
            .await?
            .ok_or_else(|| Error::InvalidInput("missing space key for post".into()))?;
        let packed = b64::decode(encrypted_post_key)?;
        decrypt_secretbox_payload(&space_key, &packed)
    }

    async fn decrypt_post_for_viewer(
        &self,
        space_id: &str,
        viewer_space_id: Option<&str>,
        post: &PostResponse,
    ) -> Result<DecryptedPost> {
        let space_key = self
            .resolve_space_key_for_version_for_viewer(
                space_id,
                viewer_space_id,
                Some(post.key_version),
            )
            .await?
            .ok_or_else(|| {
                Error::InvalidInput(format!("no space key available for post {}", post.post_id))
            })?;
        decrypt_post(&space_key, post)
    }

    pub async fn decrypt_actor_profile(
        &self,
        actor: &SpaceActorResponse,
    ) -> Result<Option<SpaceProfile>> {
        if actor.encrypted_profile.trim().is_empty()
            || actor.space_id.trim().is_empty()
            || actor.key_version <= 0
        {
            return Ok(None);
        }
        let Some(space_key) = self
            .resolve_space_key_for_version(&actor.space_id, Some(actor.key_version))
            .await?
        else {
            return Ok(None);
        };
        Ok(Some(SpaceProfile::from_bytes(&decrypt_secretbox_payload(
            &space_key,
            &b64::decode(&actor.encrypted_profile)?,
        )?)?))
    }

    pub async fn update_post_caption(
        &self,
        space_id: &str,
        post_id: i64,
        caption_plaintext: Option<&[u8]>,
    ) -> Result<()> {
        let post = self.get_post_raw(space_id, post_id, Some(space_id)).await?;
        let decrypted = self
            .decrypt_post_for_viewer(&post.space_id, Some(space_id), &post)
            .await?;
        let request = UpdatePostCaptionRequest {
            caption_cipher: match caption_plaintext {
                Some(value) => Some(b64::encode(&encrypt_secretbox_payload(
                    &decrypted.post_key,
                    value,
                )?)),
                None => None,
            },
        };
        let path = format!("/spaces/{space_id}/posts/{post_id}/caption");
        self.api()
            .post(&path)
            .json(&request)
            .send()
            .await?
            .error_for_status()?;
        Ok(())
    }

    pub async fn delete_post(&self, space_id: &str, post_id: i64) -> Result<()> {
        let path = format!("/spaces/{space_id}/posts/{post_id}");
        self.api().delete(&path).send().await?.error_for_status()?;
        Ok(())
    }

    pub async fn list_post_likes(&self, space_id: &str, post_id: i64) -> Result<Vec<SpaceActor>> {
        let path = format!("/spaces/{space_id}/posts/{post_id}/likes");
        let actors: Vec<SpaceActorResponse> = self
            .api()
            .get(&path)
            .send()
            .await?
            .error_for_status()?
            .json()
            .await?;
        if actors.is_empty() {
            return Ok(Vec::new());
        }
        let shares = self.list_decrypted_friend_shares_cached(space_id).await?;
        if actors.iter().any(|actor| {
            !actor.encrypted_profile.is_empty()
                && !shares.iter().any(|share| share.space_id == actor.space_id)
        }) {
            self.clear_friend_share_cache()?;
            self.list_decrypted_friend_shares_cached(space_id).await?;
        }
        let mut items = Vec::with_capacity(actors.len());
        for actor in actors {
            let profile = retain_content_error(self.decrypt_actor_profile(&actor).await)?;
            items.push(SpaceActor::from_response(actor, profile));
        }
        Ok(items)
    }

    pub async fn like_post(
        &self,
        space_id: &str,
        post_id: i64,
        like: bool,
    ) -> Result<LikePostResponse> {
        let path = format!("/spaces/{space_id}/posts/{post_id}/like");
        if like {
            Ok(self
                .api()
                .put(&path)
                .json(&serde_json::json!({}))
                .send()
                .await?
                .error_for_status()?
                .json()
                .await?)
        } else {
            Ok(self
                .api()
                .delete(&path)
                .send()
                .await?
                .error_for_status()?
                .json()
                .await?)
        }
    }
}

pub(super) struct DecryptedPost {
    post_key: Vec<u8>,
    caption_plaintext: Option<Vec<u8>>,
}

pub(super) fn decrypt_post(space_key: &[u8], post: &PostResponse) -> Result<DecryptedPost> {
    let post_key = decrypt_secretbox_payload(space_key, &b64::decode(&post.encrypted_post_key)?)?;
    let caption_plaintext = if post.caption_cipher.is_empty() {
        None
    } else {
        Some(decrypt_secretbox_payload(
            &post_key,
            &b64::decode(&post.caption_cipher)?,
        )?)
    };
    Ok(DecryptedPost {
        post_key,
        caption_plaintext,
    })
}

fn utf8_field(bytes: Vec<u8>, field: &str) -> Result<String> {
    String::from_utf8(bytes)
        .map_err(|error| Error::InvalidInput(format!("invalid {field} utf8: {error}")))
}

pub(super) fn open_post_content(
    post: &mut PostResponse,
    decrypted: Result<DecryptedPost>,
) -> Result<Result<PostContent>> {
    retain_content_error(decrypted.and_then(|decrypted| {
        let caption = decrypted
            .caption_plaintext
            .map(|bytes| utf8_field(bytes, "caption"))
            .transpose()?;
        let photos = std::mem::take(&mut post.objects)
            .into_iter()
            .filter(|object| !object.object_key.trim().is_empty())
            .map(|object| {
                let metadata = decrypt_post_object_metadata(&decrypted.post_key, &object)?;
                let video = object
                    .video
                    .as_ref()
                    .map(|video| {
                        let metadata = decrypt_post_object_metadata(&decrypted.post_key, video)?
                            .ok_or_else(|| {
                                Error::InvalidInput("video metadata is required".into())
                            })?;
                        let duration_ms = metadata
                            .duration_ms
                            .filter(|duration| (1..=10_000).contains(duration))
                            .ok_or_else(|| Error::InvalidInput("invalid video duration".into()))?;
                        if metadata.media_type.as_deref() != Some("video/mp4") {
                            return Err(Error::InvalidInput("invalid video format".into()));
                        }
                        Ok(PostVideo {
                            asset: PostAsset {
                                space_id: post.space_id.clone(),
                                post_id: post.post_id,
                                object_key: video.object_key.clone(),
                                encrypted_post_key: post.encrypted_post_key.clone(),
                                key_version: post.key_version,
                                size: video.size,
                            },
                            duration_ms,
                        })
                    })
                    .transpose()?;
                Ok(PostPhoto {
                    video,
                    asset: PostAsset {
                        space_id: post.space_id.clone(),
                        post_id: post.post_id,
                        object_key: object.object_key,
                        encrypted_post_key: post.encrypted_post_key.clone(),
                        key_version: post.key_version,
                        size: object.size,
                    },
                    position: object.position,
                    metadata,
                })
            })
            .collect::<Result<Vec<_>>>()?;
        if photos.is_empty() {
            return Err(Error::InvalidInput("post has no photos".into()));
        }
        Ok(PostContent { caption, photos })
    }))
}

pub(super) fn opened_post(
    post: PostResponse,
    content: Result<PostContent>,
    profile: Result<Option<SpaceProfile>>,
) -> Post {
    Post {
        post_id: post.post_id,
        space_id: post.space_id,
        space_slug: post.space_slug,
        author: SpaceActor::from_response(post.author, profile),
        content,
        created_at: post.created_at,
        viewer_liked: post.viewer_liked,
        comment_count: post.comment_count,
        like_count: post.like_count,
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use ente_core::crypto::{Key, secretbox};

    fn post(post_id: i64, encrypted_post_key: String) -> PostResponse {
        PostResponse {
            post_id,
            space_id: "space-1".into(),
            space_slug: "alice".into(),
            author: crate::SpaceActorResponse {
                space_id: "space-1".into(),
                space_slug: "alice".into(),
                ..Default::default()
            },
            encrypted_post_key,
            caption_cipher: String::new(),
            key_version: 1,
            objects: vec![PostObjectPayload {
                video: None,
                object_key: "photo".into(),
                size: None,
                position: None,
                metadata_cipher: None,
            }],
            created_at: format!("2026-08-0{post_id}T00:00:00Z"),
            viewer_liked: false,
            comment_count: 0,
            like_count: 0,
        }
    }

    #[tokio::test]
    async fn corrupt_posts_reject_single_reads_but_not_pages() {
        let mut server = mockito::Server::new_async().await;
        let root_key = Key::generate();
        let space_key = Key::generate();
        let wrapped_space_key = secretbox::encrypt_combined(space_key.as_bytes(), &root_key);
        let post_key = Key::generate();
        let valid_post_key = secretbox::encrypt_combined(post_key.as_bytes(), &space_key);
        let ctx = AccountSpaceCtx::open(crate::OpenAccountSpaceCtxInput {
            base_url: server.url(),
            space_session_token: None,
            space_root_key: root_key.as_bytes().to_vec(),
            initial_owned_spaces: Some(vec![crate::SpaceKeyResponse {
                space_id: "space-1".into(),
                space_slug: "alice".into(),
                root_wrapped_space_key: b64::encode(&wrapped_space_key),
                public_key: String::new(),
                encrypted_secret_key: String::new(),
                encrypted_profile: String::new(),
                key_version: 1,
            }]),
            user_agent: None,
            client_package: None,
            client_version: None,
        })
        .unwrap();
        let mut post_with_corrupt_actor_profile = post(1, b64::encode(&valid_post_key));
        post_with_corrupt_actor_profile.author.key_version = 1;
        post_with_corrupt_actor_profile.author.encrypted_profile = "not-base64".into();
        let mut valid_post = post(3, b64::encode(&valid_post_key));
        valid_post.comment_count = 3;
        valid_post.like_count = 8;
        valid_post.author.key_version = 1;
        valid_post.author.encrypted_profile = b64::encode(&secretbox::encrypt_combined(
            br#"{"fullName":"Alice"}"#,
            &space_key,
        ));
        let mut invalid_caption = post(4, b64::encode(&valid_post_key));
        invalid_caption.caption_cipher =
            b64::encode(&secretbox::encrypt_combined(&[0xff], &post_key));
        let mut invalid_metadata = post(5, b64::encode(&valid_post_key));
        invalid_metadata.objects.push(PostObjectPayload {
            video: None,
            object_key: "photo".into(),
            size: None,
            position: None,
            metadata_cipher: Some("not-base64".into()),
        });
        let mut corrupt_post = post(2, "not-base64".into());
        let mut corrupt_caption = post(6, b64::encode(&valid_post_key));
        corrupt_caption.caption_cipher =
            b64::encode(&secretbox::encrypt_combined(b"caption", &space_key));
        let mut empty_post = post(7, b64::encode(&valid_post_key));
        empty_post.objects.clear();
        let mut blank_photo = post(8, b64::encode(&valid_post_key));
        blank_photo.objects[0].object_key = " ".into();
        for post in [
            &mut empty_post,
            &mut blank_photo,
            &mut corrupt_post,
            &mut invalid_caption,
            &mut invalid_metadata,
            &mut corrupt_caption,
        ] {
            post.author.key_version = 2;
            post.author.encrypted_profile = "not-base64".into();
        }
        let profile_keys = server
            .mock("GET", "/account/space")
            .with_status(503)
            .expect(0)
            .create_async()
            .await;
        let page = PostPageResponse {
            items: vec![
                post_with_corrupt_actor_profile,
                corrupt_post,
                valid_post,
                invalid_caption,
                invalid_metadata,
                corrupt_caption,
                empty_post,
                blank_photo,
            ],
            next_cursor: "next".into(),
        };

        for index in [1, 3, 4, 5, 6, 7] {
            let post = &page.items[index];
            let read = server
                .mock(
                    "GET",
                    format!("/spaces/space-1/posts/{}", post.post_id).as_str(),
                )
                .with_body(serde_json::to_string(post).unwrap())
                .create_async()
                .await;
            assert!(matches!(
                ctx.get_post("space-1", post.post_id, None).await,
                Err(error) if error.is_content_error()
            ));
            read.assert_async().await;
        }

        let page = ctx.open_post_page(page).await.unwrap();

        assert_eq!(page.items.len(), 8);
        assert!(page.items[0].content.is_ok());
        assert!(matches!(
            page.items[0].author.profile,
            Err(Error::Base64Decode(_))
        ));
        assert!(matches!(page.items[1].content, Err(Error::Base64Decode(_))));
        assert_eq!(page.items[1].post_id, 2);
        assert!(page.items[2].content.is_ok());
        assert_eq!(page.items[2].comment_count, 3);
        assert_eq!(page.items[2].like_count, 8);
        assert_eq!(
            page.items[2]
                .author
                .profile
                .as_ref()
                .unwrap()
                .as_ref()
                .unwrap()
                .full_name
                .as_deref(),
            Some("Alice")
        );
        assert!(
            matches!(&page.items[3].content, Err(Error::InvalidInput(message)) if message.contains("caption utf8"))
        );
        assert!(matches!(page.items[4].content, Err(Error::Base64Decode(_))));
        assert!(matches!(page.items[5].content, Err(Error::Crypto(_))));
        assert!(matches!(page.items[6].content, Err(Error::InvalidInput(_))));
        assert!(matches!(page.items[7].content, Err(Error::InvalidInput(_))));
        for index in [1, 3, 4, 5, 6, 7] {
            assert!(matches!(page.items[index].author.profile, Ok(None)));
        }
        assert_eq!(page.next_cursor, "next");
        profile_keys.assert_async().await;
    }

    #[tokio::test]
    async fn key_fetch_failure_rejects_the_page() {
        let mut server = mockito::Server::new_async().await;
        let ctx = crate::client::test_support::test_account_ctx(&server.url());
        let page = PostPageResponse {
            items: vec![post(1, "not-base64".into())],
            next_cursor: String::new(),
        };
        let posts = server
            .mock("GET", "/spaces/space-1/posts")
            .with_body(serde_json::to_string(&page).unwrap())
            .create_async()
            .await;
        let keys = server
            .mock("GET", "/account/space")
            .with_status(403)
            .create_async()
            .await;

        assert!(matches!(
            ctx.list_posts("space-1", None, None, None).await,
            Err(Error::Http(http::Error::Http { status: 403, .. }))
        ));
        posts.assert_async().await;
        keys.assert_async().await;
    }
}