vaegram 0.3.0

Telegram MTProto client library for users and bots
Documentation
mod check_folder_invite_link;
mod create_folder;
mod create_folder_invite_link;
mod delete_folder;
mod delete_folder_invite_link;
mod edit_folder;
mod edit_folder_invite_link;
mod get_chats_for_folder_invite_link;
mod get_folder_invite_links;
mod get_folder_updates;
mod get_folders;
mod hide_folder_updates;
mod join_folder;
mod join_folder_updates;
mod leave_folder;
mod reorder_folders;
mod toggle_folder_tags;

pub use create_folder_invite_link::CreateFolderInviteLink;
pub use edit_folder_invite_link::EditFolderInviteLink;
pub use leave_folder::LeaveFolder;

#[cfg(test)]
mod tests {
    use tokio::sync::mpsc::UnboundedReceiver;

    use crate::Client;
    use crate::errors::{Error, RpcError};
    use crate::raw::functions::chatlists;
    use crate::raw::{Serializable, base, types};
    use crate::types::{Folder, FolderInviteLinkInfo};
    use crate::utils::get_channel_id;

    use super::check_folder_invite_link::slug;
    use super::create_folder_invite_link::chatlist;

    fn title(text: &str) -> base::TextWithEntities {
        let title = types::TextWithEntities { text: text.into(), entities: Vec::new() };
        base::TextWithEntities::TextWithEntities(Box::new(title))
    }

    #[tokio::test]
    async fn folders_round_trip_through_the_peer_cache() {
        let client = Client::offline();
        let channel = types::InputPeerChannel { channel_id: 9, access_hash: 1 };
        let channel = base::InputPeer::InputPeerChannel(Box::new(channel));
        let chat = base::InputPeer::InputPeerChat(types::InputPeerChat { chat_id: 3 });
        let raw = types::DialogFilter {
            contacts: true,
            non_contacts: false,
            groups: false,
            broadcasts: true,
            bots: false,
            exclude_muted: true,
            exclude_read: false,
            exclude_archived: false,
            title_noanimate: false,
            id: 4,
            title: title("Work"),
            emoticon: Some("💼".into()),
            color: None,
            pinned_peers: vec![channel.clone()],
            include_peers: vec![channel, chat],
            exclude_peers: vec![base::InputPeer::InputPeerEmpty],
        };
        let folder = Folder::parse(&client, base::DialogFilter::DialogFilter(Box::new(raw))).unwrap();
        let channel_id = get_channel_id(9);
        assert_eq!(
            (folder.id, folder.title.as_str(), folder.channels, folder.excluded_chats.is_empty()),
            (4, "Work", true, true)
        );
        assert_eq!((&folder.pinned_chats, &folder.included_chats), (&vec![channel_id], &vec![channel_id, -3]));

        let base::DialogFilter::DialogFilter(back) = folder.write(&client).await.unwrap() else {
            panic!("not a plain folder")
        };
        assert_eq!(
            (back.include_peers.len(), Folder::parse(&client, base::DialogFilter::DialogFilterDefault)),
            (2, None)
        );
    }

    #[tokio::test]
    async fn titles_keep_custom_emoji_and_animation_flag() {
        let client = Client::offline();
        let emoji = types::MessageEntityCustomEmoji { offset: 0, length: 2, document_id: 77 };
        let bold = types::MessageEntityBold { offset: 3, length: 4 };
        let title = types::TextWithEntities {
            text: "🙂 Work".into(),
            entities: vec![
                base::MessageEntity::MessageEntityCustomEmoji(Box::new(emoji)),
                base::MessageEntity::MessageEntityBold(bold),
            ],
        };
        let raw = types::DialogFilterChatlist {
            has_my_invites: false,
            title_noanimate: true,
            id: 5,
            title: base::TextWithEntities::TextWithEntities(Box::new(title.clone())),
            emoticon: None,
            color: None,
            pinned_peers: Vec::new(),
            include_peers: Vec::new(),
        };
        let folder = Folder::parse(&client, base::DialogFilter::DialogFilterChatlist(Box::new(raw.clone()))).unwrap();
        assert_eq!(folder.title_entities[0].custom_emoji_id, Some(77));
        let back = folder.write(&client).await.unwrap();
        assert_eq!(back, base::DialogFilter::DialogFilterChatlist(Box::new(raw)));
    }

    #[tokio::test]
    async fn every_title_entity_kind_is_written_back() {
        use base::MessageEntity as E;
        let client = Client::offline();
        let (offset, length) = (0, 1);
        let date = types::MessageEntityFormattedDate {
            relative: false,
            short_time: true,
            long_time: false,
            short_date: false,
            long_date: true,
            day_of_week: true,
            offset,
            length,
            date: 9,
        };
        let quote = types::MessageEntityBlockquote { collapsed: true, offset, length };
        let entities = vec![
            E::MessageEntityUnknown(types::MessageEntityUnknown { offset, length }),
            E::MessageEntityMention(types::MessageEntityMention { offset, length }),
            E::MessageEntityHashtag(types::MessageEntityHashtag { offset, length }),
            E::MessageEntityBotCommand(types::MessageEntityBotCommand { offset, length }),
            E::MessageEntityUrl(types::MessageEntityUrl { offset, length }),
            E::MessageEntityEmail(types::MessageEntityEmail { offset, length }),
            E::MessageEntityBold(types::MessageEntityBold { offset, length }),
            E::MessageEntityItalic(types::MessageEntityItalic { offset, length }),
            E::MessageEntityCode(types::MessageEntityCode { offset, length }),
            E::MessageEntityPre(Box::new(types::MessageEntityPre { offset, length, language: "rust".into() })),
            E::MessageEntityTextUrl(Box::new(types::MessageEntityTextUrl { offset, length, url: "https://a".into() })),
            E::MessageEntityPhone(types::MessageEntityPhone { offset, length }),
            E::MessageEntityCashtag(types::MessageEntityCashtag { offset, length }),
            E::MessageEntityUnderline(types::MessageEntityUnderline { offset, length }),
            E::MessageEntityStrike(types::MessageEntityStrike { offset, length }),
            E::MessageEntityBankCard(types::MessageEntityBankCard { offset, length }),
            E::MessageEntitySpoiler(types::MessageEntitySpoiler { offset, length }),
            E::MessageEntityCustomEmoji(Box::new(types::MessageEntityCustomEmoji { offset, length, document_id: 7 })),
            E::MessageEntityBlockquote(Box::new(quote)),
            E::MessageEntityFormattedDate(Box::new(date)),
            E::MessageEntityDiffInsert(types::MessageEntityDiffInsert { offset, length }),
            E::MessageEntityDiffReplace(Box::new(types::MessageEntityDiffReplace {
                offset,
                length,
                old_text: "was".into(),
            })),
            E::MessageEntityDiffDelete(types::MessageEntityDiffDelete { offset, length }),
            E::MessageEntityTonAddress(types::MessageEntityTonAddress { offset, length }),
        ];
        let title = types::TextWithEntities { text: "x".into(), entities };
        let raw = types::DialogFilterChatlist {
            has_my_invites: false,
            title_noanimate: false,
            id: 6,
            title: base::TextWithEntities::TextWithEntities(Box::new(title)),
            emoticon: None,
            color: None,
            pinned_peers: Vec::new(),
            include_peers: Vec::new(),
        };
        let folder = Folder::parse(&client, base::DialogFilter::DialogFilterChatlist(Box::new(raw.clone()))).unwrap();
        assert_eq!(folder.write(&client).await.unwrap(), base::DialogFilter::DialogFilterChatlist(Box::new(raw)));
    }

    #[tokio::test]
    async fn reordering_no_folders_is_refused_without_a_request() {
        let (client, mut rx) = Client::recording();
        assert!(matches!(client.reorder_folders(&[]).await, Err(Error::InvalidArgument(_))));
        assert!(rx.try_recv().is_err());
    }

    #[tokio::test]
    async fn shareable_folders_write_as_chatlists() {
        let client = Client::offline();
        let folder = Folder::new("Shared").id(2).is_shareable(true);
        let raw = folder.write(&client).await.unwrap();
        assert!(matches!(raw, base::DialogFilter::DialogFilterChatlist(_)));
    }

    fn recording() -> (Client, UnboundedReceiver<Vec<u8>>) {
        let (client, rx) = Client::recording();
        client.0.peers.lock().unwrap().insert(get_channel_id(9), channel());
        (client, rx)
    }

    fn channel() -> base::InputPeer {
        base::InputPeer::InputPeerChannel(Box::new(types::InputPeerChannel { channel_id: 9, access_hash: 1 }))
    }

    #[test]
    fn finds_the_slug() {
        assert_eq!(slug("https://t.me/addlist/AbC-d_1").unwrap(), "AbC-d_1");
        assert_eq!(slug("t.me/addlist/AbC").unwrap(), "AbC");
        assert_eq!(slug("tg://addlist?slug=AbC").unwrap(), "AbC");
        assert_eq!(slug("AbC").unwrap(), "AbC");
        assert!(slug("https://t.me/addlist/").is_err());
    }

    #[tokio::test]
    async fn links_without_a_slug_are_refused_without_a_request() {
        let (client, mut rx) = recording();
        let link = "https://t.me/addlist/";
        let results = (
            matches!(client.check_folder_invite_link(link).await, Err(Error::InvalidArgument(_))),
            matches!(client.join_folder(link).await, Err(Error::InvalidArgument(_))),
            matches!(client.delete_folder_invite_link(3, link).await, Err(Error::InvalidArgument(_))),
            matches!(client.edit_folder_invite_link(3, link).name("x").await, Err(Error::InvalidArgument(_))),
        );
        assert_eq!(results, (true, true, true, true));
        assert!(rx.try_recv().is_err());
    }

    #[test]
    fn invite_info_keeps_the_title_and_has_none_once_joined() {
        use base::chatlists::ChatlistInvite as I;
        let client = Client::offline();
        let emoji = types::MessageEntityCustomEmoji { offset: 0, length: 2, document_id: 7 };
        let title = types::TextWithEntities {
            text: "🙂".into(),
            entities: vec![base::MessageEntity::MessageEntityCustomEmoji(Box::new(emoji))],
        };
        let invite = types::chatlists::ChatlistInvite {
            title_noanimate: false,
            title: base::TextWithEntities::TextWithEntities(Box::new(title)),
            emoticon: None,
            peers: Vec::new(),
            chats: Vec::new(),
            users: Vec::new(),
        };
        let info = FolderInviteLinkInfo::parse(&client, I::ChatlistInvite(Box::new(invite)));
        assert_eq!((info.title.as_deref(), info.title_entities[0].custom_emoji_id), (Some("🙂"), Some(7)));

        let already = types::chatlists::ChatlistInviteAlready {
            filter_id: 4,
            missing_peers: Vec::new(),
            already_peers: Vec::new(),
            chats: Vec::new(),
            users: Vec::new(),
        };
        let info = FolderInviteLinkInfo::parse(&client, I::ChatlistInviteAlready(Box::new(already)));
        assert_eq!((info.folder_id, info.title), (Some(4), None));
    }

    #[tokio::test]
    async fn sharing_no_chats_is_refused_without_a_request() {
        let (client, mut rx) = recording();
        let results = (
            matches!(client.create_folder_invite_link(3, Vec::<i64>::new()).await, Err(Error::InvalidArgument(_))),
            matches!(client.join_folder_updates(3, Vec::<i64>::new()).await, Err(Error::InvalidArgument(_))),
        );
        assert_eq!(results, (true, true));
        assert!(rx.try_recv().is_err());
    }

    #[tokio::test]
    async fn invite_link_requests_carry_the_folder_and_slug() {
        let (client, mut rx) = recording();
        let channel_id = get_channel_id(9);

        let _ = client.create_folder_invite_link(3, [channel_id]).name("News").await;
        let peers = vec![channel()];
        let sent = chatlists::ExportChatlistInvite { chatlist: chatlist(3), title: "News".into(), peers };
        assert_eq!(rx.try_recv().unwrap(), sent.to_bytes());

        let _ = client.edit_folder_invite_link(3, "https://t.me/addlist/AbC").chat_ids([channel_id]).await;
        let sent = chatlists::EditExportedInvite {
            chatlist: chatlist(3),
            slug: "AbC".into(),
            title: None,
            peers: Some(vec![channel()]),
        };
        assert_eq!(rx.try_recv().unwrap(), sent.to_bytes());

        let _ = client.delete_folder_invite_link(3, "t.me/addlist/AbC").await;
        let sent = chatlists::DeleteExportedInvite { chatlist: chatlist(3), slug: "AbC".into() };
        assert_eq!(rx.try_recv().unwrap(), sent.to_bytes());
    }

    #[tokio::test]
    async fn folder_update_requests_carry_the_folder() {
        let (client, mut rx) = recording();

        let _ = client.join_folder_updates(3, [get_channel_id(9)]).await;
        let sent = chatlists::JoinChatlistUpdates { chatlist: chatlist(3), peers: vec![channel()] };
        assert_eq!(rx.try_recv().unwrap(), sent.to_bytes());

        let _ = client.hide_folder_updates(3).await;
        assert_eq!(rx.try_recv().unwrap(), chatlists::HideChatlistUpdates { chatlist: chatlist(3) }.to_bytes());

        let _ = client.leave_folder(3).await;
        let sent = chatlists::LeaveChatlist { chatlist: chatlist(3), peers: Vec::new() };
        assert_eq!(rx.try_recv().unwrap(), sent.to_bytes());

        let _ = client.leave_folder(3).leave_chats().await;
        let sent = chatlists::GetLeaveChatlistSuggestions { chatlist: chatlist(3) };
        assert_eq!(rx.try_recv().unwrap(), sent.to_bytes());
    }

    #[tokio::test]
    async fn folder_tags_send_the_flag_and_return_telegram_errors() {
        use crate::raw::functions::messages::ToggleDialogFilterTags;
        let premium = Error::Rpc(RpcError::parse(400, "PREMIUM_ACCOUNT_REQUIRED"));
        let (client, mut rx) = Client::scripted(vec![Err(premium)]);
        let result = client.toggle_folder_tags(true).await;
        assert!(matches!(&result, Err(Error::Rpc(e)) if e.name == "PREMIUM_ACCOUNT_REQUIRED"), "{result:?}");
        assert_eq!(rx.try_recv().unwrap(), ToggleDialogFilterTags { enabled: true }.to_bytes());
        let _ = client.toggle_folder_tags(false).await;
        assert_eq!(rx.try_recv().unwrap(), ToggleDialogFilterTags { enabled: false }.to_bytes());
    }
}