vaegram 0.3.0

Telegram MTProto client library for users and bots
Documentation
mod copy_story;
mod delete_stories;
mod edit_story_caption;
mod edit_story_media;
mod edit_story_privacy;
mod enable_stealth_mode;
mod export_story_link;
mod forward_story;
mod get_all_stories;
mod get_chat_stories;
mod get_pinned_stories;
mod get_stories;
mod get_stories_archive;
mod get_story_post_count;
mod get_story_viewers;
mod hide_chat_stories;
mod pin_chat_stories;
mod read_stories;
mod send_story;
mod send_story_reaction;
mod show_chat_stories;
mod unpin_chat_stories;
mod view_stories;

pub use copy_story::CopyStory;
pub use edit_story_caption::EditStoryCaption;
pub use edit_story_media::EditStoryMedia;
pub use edit_story_privacy::EditStoryPrivacy;
pub use enable_stealth_mode::EnableStealthMode;
pub use forward_story::ForwardStory;
pub use get_stories_archive::StoryPages;
pub use get_story_viewers::GetStoryViewers;
pub use send_story::SendStory;
pub use send_story_reaction::SendStoryReaction;

#[cfg(test)]
mod tests {
    use crate::Client;
    use crate::dispatcher::Entities;
    use crate::enums::{MessageEntityType, StoriesPrivacyRules};
    use crate::errors::Error;
    use crate::raw::functions::stories;
    use crate::raw::{Serializable, base, types};
    use crate::types::{Media, ReactionType, Story, StoryViewer, Text};
    use crate::utils::{get_channel_id, get_peer};

    #[tokio::test]
    async fn reaction_none_sends_empty_reaction() {
        let (client, mut rx) = Client::recording();
        let _ = client.send_story_reaction(0_i64, 7).await;
        let expected = stories::SendReaction {
            add_to_recent: true,
            peer: base::InputPeer::InputPeerSelf,
            story_id: 7,
            reaction: base::Reaction::ReactionEmpty,
        };
        assert_eq!(rx.try_recv().unwrap(), expected.to_bytes());

        let _ = client.hide_chat_stories(0_i64).await;
        let expected = stories::TogglePeerStoriesHidden { peer: base::InputPeer::InputPeerSelf, hidden: true };
        assert_eq!(rx.try_recv().unwrap(), expected.to_bytes());
    }

    #[tokio::test]
    async fn empty_story_id_lists_are_refused_without_a_request() {
        let (client, mut rx) = Client::recording();
        let results = (
            matches!(client.get_stories(0_i64, &[]).await, Err(Error::InvalidArgument(_))),
            matches!(client.view_stories(0_i64, &[]).await, Err(Error::InvalidArgument(_))),
            matches!(client.delete_stories(0_i64, &[]).await, Err(Error::InvalidArgument(_))),
            matches!(client.pin_chat_stories(0_i64, &[]).await, Err(Error::InvalidArgument(_))),
            matches!(client.unpin_chat_stories(0_i64, &[]).await, Err(Error::InvalidArgument(_))),
        );
        assert_eq!(results, (true, true, true, true, true));
        assert!(rx.try_recv().is_err());
    }

    #[test]
    fn parses_stories_and_drops_deleted_ones() {
        let client = Client::offline();
        let views = types::StoryViews {
            has_viewers: true,
            views_count: 12,
            forwards_count: None,
            reactions: None,
            reactions_count: Some(3),
            recent_viewers: None,
        };
        let item = types::StoryItem {
            pinned: true,
            public: true,
            close_friends: false,
            min: false,
            noforwards: false,
            edited: false,
            contacts: false,
            selected_contacts: false,
            out: true,
            id: 5,
            date: 100,
            from_id: None,
            fwd_from: None,
            expire_date: 200,
            caption: Some("hi".into()),
            entities: None,
            media: base::MessageMedia::MessageMediaEmpty,
            media_areas: None,
            privacy: None,
            views: Some(base::StoryViews::StoryViews(Box::new(views))),
            sent_reaction: None,
            albums: None,
            music: None,
        };
        let skipped = types::StoryItemSkipped { close_friends: true, live: false, id: 6, date: 101, expire_date: 201 };
        let items = vec![
            base::StoryItem::StoryItem(Box::new(item)),
            base::StoryItem::StoryItemDeleted(types::StoryItemDeleted { id: 4 }),
            base::StoryItem::StoryItemSkipped(Box::new(skipped)),
        ];
        let stories = Story::parse_list(&client, &get_peer(42), items, Vec::new(), Vec::new());
        assert_eq!(stories.len(), 2);
        let (full, skipped) = (&stories[0], &stories[1]);
        assert_eq!((full.chat.id, full.id, full.caption.as_deref()), (42, 5, Some("hi")));
        assert_eq!((full.view_count, full.reaction_count, full.is_pinned), (Some(12), Some(3), true));
        assert_eq!((skipped.id, skipped.date, skipped.view_count, skipped.is_close_friends), (6, 101, None, true));
    }

    #[tokio::test]
    async fn custom_emoji_reactions_are_sent() {
        let (client, mut rx) = Client::recording();
        let _ = client.send_story_reaction(0_i64, 7).reaction(ReactionType::CustomEmoji(5)).await;
        let emoji = types::ReactionCustomEmoji { document_id: 5 };
        let expected = stories::SendReaction {
            add_to_recent: true,
            peer: base::InputPeer::InputPeerSelf,
            story_id: 7,
            reaction: base::Reaction::ReactionCustomEmoji(emoji),
        };
        assert_eq!(rx.try_recv().unwrap(), expected.to_bytes());
    }

    #[test]
    fn viewers_keep_custom_emoji_and_paid_reactions() {
        let entities = Entities::default();
        let view = |reaction| {
            let view =
                types::StoryView { blocked: false, blocked_my_stories_from: false, user_id: 9, date: 50, reaction };
            StoryViewer::parse(base::StoryView::StoryView(Box::new(view)), &entities).unwrap().reaction
        };
        let custom = base::Reaction::ReactionCustomEmoji(types::ReactionCustomEmoji { document_id: 5 });
        assert_eq!(view(Some(custom)), Some(ReactionType::CustomEmoji(5)));
        assert_eq!(view(Some(base::Reaction::ReactionPaid)), Some(ReactionType::Paid));
        assert_eq!(view(Some(base::Reaction::ReactionEmpty)), None);
    }

    #[test]
    fn stories_keep_caption_entities_and_media() {
        let document = types::Document {
            id: 1,
            access_hash: 2,
            file_reference: vec![3],
            date: 4,
            mime_type: "application/pdf".into(),
            size: 5,
            thumbs: None,
            video_thumbs: None,
            dc_id: 2,
            attributes: Vec::new(),
        };
        let media = types::MessageMediaDocument {
            nopremium: false,
            spoiler: false,
            video: false,
            round: false,
            voice: false,
            document: Some(base::Document::Document(Box::new(document))),
            alt_documents: None,
            video_cover: None,
            video_timestamp: None,
            ttl_seconds: None,
        };
        let bold = base::MessageEntity::MessageEntityBold(types::MessageEntityBold { offset: 0, length: 2 });
        let item = types::StoryItem {
            pinned: false,
            public: false,
            close_friends: false,
            min: false,
            noforwards: false,
            edited: false,
            contacts: false,
            selected_contacts: false,
            out: false,
            id: 5,
            date: 100,
            from_id: None,
            fwd_from: None,
            expire_date: 200,
            caption: Some("hi".into()),
            entities: Some(vec![bold]),
            media: base::MessageMedia::MessageMediaDocument(Box::new(media)),
            media_areas: None,
            privacy: None,
            views: None,
            sent_reaction: None,
            albums: None,
            music: None,
        };
        let story = Story::parse(
            &Client::offline(),
            &get_peer(42),
            base::StoryItem::StoryItem(Box::new(item)),
            &Entities::default(),
        )
        .unwrap();
        let entities = story.caption_entities.unwrap();
        assert_eq!((entities.len(), entities[0].kind, entities[0].length), (1, MessageEntityType::Bold, 2));
        assert!(story.media.as_ref().and_then(Media::file_location).is_some());
    }

    #[test]
    fn viewer_keeps_both_block_flags() {
        let entities = Entities::default();
        let flags = |blocked, blocked_my_stories_from| {
            let view = types::StoryView { blocked, blocked_my_stories_from, user_id: 9, date: 50, reaction: None };
            let viewer = StoryViewer::parse(base::StoryView::StoryView(Box::new(view)), &entities).unwrap();
            (viewer.is_blocked, viewer.is_blocked_my_stories_from)
        };
        assert_eq!(
            [flags(false, false), flags(true, false), flags(false, true), flags(true, true)],
            [(false, false), (true, false), (false, true), (true, true)]
        );
    }

    #[test]
    fn viewers_skip_reposts_and_keep_emoji() {
        let entities = Entities::default();
        let fire = base::Reaction::ReactionEmoji(Box::new(types::ReactionEmoji { emoticon: "🔥".into() }));
        let view = types::StoryView {
            blocked: false,
            blocked_my_stories_from: true,
            user_id: 9,
            date: 50,
            reaction: Some(fire),
        };
        let viewer = StoryViewer::parse(base::StoryView::StoryView(Box::new(view)), &entities).unwrap();
        assert_eq!(
            (viewer.user.id, viewer.date, viewer.reaction, viewer.is_blocked, viewer.is_blocked_my_stories_from),
            (9, 50, Some(ReactionType::Emoji("🔥".into())), false, true)
        );

        let repost = types::StoryViewPublicRepost {
            blocked: false,
            blocked_my_stories_from: false,
            peer_id: get_peer(9),
            story: base::StoryItem::StoryItemDeleted(types::StoryItemDeleted { id: 1 }),
        };
        assert!(StoryViewer::parse(base::StoryView::StoryViewPublicRepost(Box::new(repost)), &entities).is_none());
    }

    fn edit(id: i32) -> stories::EditStory {
        let peer = types::InputPeerChannel { channel_id: 9, access_hash: 1 };
        stories::EditStory {
            peer: base::InputPeer::InputPeerChannel(Box::new(peer)),
            id,
            media: None,
            media_areas: None,
            caption: None,
            entities: None,
            privacy_rules: None,
            music: None,
        }
    }

    fn known_channel(client: &Client) -> i64 {
        let peer = types::InputPeerChannel { channel_id: 9, access_hash: 1 };
        client.0.peers.lock().unwrap().insert(get_channel_id(9), base::InputPeer::InputPeerChannel(Box::new(peer)));
        get_channel_id(9)
    }

    #[tokio::test]
    async fn edits_and_pins_send_only_what_changes() {
        let (client, mut rx) = Client::recording();
        let channel = known_channel(&client);

        let _ = client.edit_story_caption(channel, 3, "<i>new</i>").html().await;
        let italic = types::MessageEntityItalic { offset: 0, length: 3 };
        let expected = stories::EditStory {
            caption: Some("new".into()),
            entities: Some(vec![base::MessageEntity::MessageEntityItalic(italic)]),
            ..edit(3)
        };
        assert_eq!(rx.try_recv().unwrap(), expected.to_bytes());

        let _ = client.edit_story_caption(channel, 3, Text::new().bold("new")).await;
        let bold = types::MessageEntityBold { offset: 0, length: 3 };
        let expected = stories::EditStory {
            caption: Some("new".into()),
            entities: Some(vec![base::MessageEntity::MessageEntityBold(bold)]),
            ..edit(3)
        };
        assert_eq!(rx.try_recv().unwrap(), expected.to_bytes());

        let _ = client.edit_story_caption(channel, 3, "").await;
        let expected = stories::EditStory { caption: Some(String::new()), entities: Some(Vec::new()), ..edit(3) };
        assert_eq!(rx.try_recv().unwrap(), expected.to_bytes());

        let peer = edit(0).peer;
        let _ = client.pin_chat_stories(channel, &[1, 2]).await;
        let pin = stories::TogglePinned { peer: peer.clone(), id: vec![1, 2], pinned: true };
        assert_eq!(rx.try_recv().unwrap(), pin.to_bytes());
        let _ = client.unpin_chat_stories(channel, &[2]).await;
        let unpin = stories::TogglePinned { peer: peer.clone(), id: vec![2], pinned: false };
        assert_eq!(rx.try_recv().unwrap(), unpin.to_bytes());

        let _ = client.get_stories_archive(channel).limit(5).next().await;
        let archive = stories::GetStoriesArchive { peer: peer.clone(), offset_id: 0, limit: 5 };
        assert_eq!(rx.try_recv().unwrap(), archive.to_bytes());
        let _ = client.get_pinned_stories(channel).offset_id(8).next().await;
        assert_eq!(rx.try_recv().unwrap(), stories::GetPinnedStories { peer, offset_id: 8, limit: 100 }.to_bytes());

        let _ = client.enable_stealth_mode().past().future().await;
        assert_eq!(rx.try_recv().unwrap(), stories::ActivateStealthMode { past: true, future: true }.to_bytes());
        let _ = client.enable_stealth_mode().future().await;
        assert_eq!(rx.try_recv().unwrap(), stories::ActivateStealthMode { past: false, future: true }.to_bytes());
    }

    #[tokio::test]
    async fn privacy_edit_returns_the_story_telegram_sent_back() {
        let skipped = types::StoryItemSkipped { close_friends: true, live: false, id: 4, date: 101, expire_date: 201 };
        let story = base::StoryItem::StoryItemSkipped(Box::new(skipped));
        let update = types::UpdateStory { peer: get_peer(get_channel_id(9)), story };
        let updates = types::Updates {
            updates: vec![
                base::Update::UpdateStoryID(Box::new(types::UpdateStoryID { id: 4, random_id: 1 })),
                base::Update::UpdateStory(Box::new(update)),
            ],
            users: Vec::new(),
            chats: Vec::new(),
            date: 0,
            seq: 0,
        };
        let reply = base::Updates::Updates(Box::new(updates)).to_bytes();
        let (client, mut rx) = Client::scripted(vec![Ok(reply)]);
        let channel = known_channel(&client);

        let story = client.edit_story_privacy(channel, 4, StoriesPrivacyRules::CloseFriends).await.unwrap();
        assert_eq!((story.chat.id, story.id, story.date, story.is_close_friends), (channel, 4, 101, true));
        let rules = vec![base::InputPrivacyRule::InputPrivacyValueAllowCloseFriends];
        assert_eq!(rx.try_recv().unwrap(), stories::EditStory { privacy_rules: Some(rules), ..edit(4) }.to_bytes());

        assert!(client.edit_story_privacy(channel, 4, StoriesPrivacyRules::default()).await.is_err());
    }
}