#[allow(dead_code)]
mod support;
use std::collections::HashMap;
use std::sync::{Arc, Mutex};
use std::time::{Duration, SystemTime, UNIX_EPOCH};
use tokio::sync::mpsc::{self, UnboundedReceiver};
use vaegram::types::{
CallbackQuery, EphemeralMessage, InlineKeyboardButton, InlineKeyboardMarkup, InputMedia, InputRichMessage, Text,
Upload,
};
use vaegram::{Client, Error, filters};
const WAIT: Duration = Duration::from_secs(30);
fn nonce() -> u128 {
SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_nanos()
}
async fn next<T>(rx: &mut UnboundedReceiver<T>, mut pick: impl FnMut(&T) -> bool) -> Option<T> {
let found = tokio::time::timeout(WAIT, async {
loop {
match rx.recv().await {
Some(item) if pick(&item) => return item,
Some(_) => {}
None => panic!("the handler feeding this channel is gone"),
}
}
});
found.await.ok()
}
async fn receive(
seen: &mut UnboundedReceiver<EphemeralMessage>,
sent: &EphemeralMessage,
) -> Result<EphemeralMessage, Vec<EphemeralMessage>> {
let mut others = Vec::new();
let found = tokio::time::timeout(WAIT, async {
loop {
match seen.recv().await {
Some(m) if m.id == sent.id && m.chat.id == sent.chat.id => return m,
Some(m) => others.push(m),
None => panic!("the handler feeding this channel is gone"),
}
}
})
.await;
found.map_err(|_| others)
}
fn missing(sent: &EphemeralMessage, text: Option<&str>, others: &[EphemeralMessage]) -> Outcome {
let arrived: Vec<String> = others.iter().map(fields).collect();
let details = format!("the bot's copy [{}]; arrived instead {arrived:?}", fields(sent));
match others.iter().find(|m| text.is_some_and(|text| m.text == text)) {
Some(m) => Outcome::IdsDiffer(format!("the user's copy has id {}, the bot's {}; {details}", m.id, sent.id)),
None => Outcome::Nothing(details),
}
}
fn fields(m: &EphemeralMessage) -> String {
format!(
"id {}, chat {}, anchor_message_id {:?}, reply to {:?}, thread {:?}, text {:?}",
m.id, m.chat.id, m.anchor_message_id, m.reply_to_message_id, m.message_thread_id, m.text
)
}
#[derive(Clone)]
enum How {
Plain { replace: bool },
ReplyTo(i32),
Rich,
Media,
To(i64),
}
async fn answer(query: &CallbackQuery, how: How) -> vaegram::Result<EphemeralMessage> {
let text = Text::new().plain(format!("ephemeral answer to {}", query.data).as_str());
let send = match how {
How::Plain { replace: false } => return query.answer_ephemeral(text)?.await,
How::Plain { replace: true } => query.answer_ephemeral(text)?,
How::ReplyTo(target) => return query.answer_ephemeral(text)?.reply_to(target).await,
How::Rich => {
let rich = InputRichMessage::html(format!("<b>rich</b> ephemeral answer to {}", query.data));
query.answer_ephemeral(rich)?
}
How::Media => {
let file = InputMedia::document(Upload::bytes("vaegram.txt", b"vaegram live test")).caption(text);
query.answer_ephemeral("")?.media(file)
}
How::To(receiver) => {
let chat = query.chat().ok_or(Error::InvalidArgument("the press has no chat"))?.id;
query.client().send_ephemeral_message(chat, receiver, text).callback_query_id(query.id)
}
};
send.replace_callback_query_message().await
}
type Answer = (String, vaegram::Result<EphemeralMessage>, vaegram::Result<()>);
#[derive(Default)]
struct Made {
messages: Vec<(i64, i32)>,
ephemerals: Vec<(i64, i64, i32)>,
pending: usize,
}
async fn settle(made: &Mutex<Made>) -> Option<String> {
let deadline = tokio::time::Instant::now() + WAIT;
loop {
let pending = made.lock().unwrap().pending;
if pending == 0 {
return None;
}
if tokio::time::Instant::now() >= deadline {
made.lock().unwrap().pending = 0;
let lost = "the press may not have reached the bot, or its answer may still arrive: check the chat";
return Some(format!("{pending} presses had no recorded answer after {WAIT:?}; {lost}"));
}
tokio::time::sleep(Duration::from_millis(200)).await;
}
}
async fn clean(made: &Mutex<Made>, bot: &Client) -> Vec<String> {
let (ephemerals, messages) = {
let mut made = made.lock().unwrap();
(std::mem::take(&mut made.ephemerals), std::mem::take(&mut made.messages))
};
let mut failed = Vec::new();
let mut note = |result: vaegram::Result<()>, what: String| match result {
Ok(()) => {}
Err(e) if e.flood_wait().is_some() => eprintln!("skipped the cleanup: {what} is flood-limited; do it by hand"),
Err(e) => failed.push(format!("{what}: {e:?}")),
};
for (chat_id, receiver, id) in ephemerals {
let what = format!("deleting ephemeral answer {id} in {chat_id}");
note(bot.delete_ephemeral_message(chat_id, receiver, id).await, what);
}
for (chat_id, id) in messages {
note(bot.delete_messages(chat_id, &[id]).await, format!("deleting message {id} in {chat_id}"));
}
failed
}
async fn finish(made: &Mutex<Made>, bot: &Client) -> Vec<String> {
let mut failed: Vec<String> = settle(made).await.into_iter().collect();
failed.extend(clean(made, bot).await);
failed
}
struct Ctx {
user: Client,
bot: Client,
plan: Arc<Mutex<HashMap<String, How>>>,
made: Arc<Mutex<Made>>,
answers: UnboundedReceiver<Answer>,
}
struct Pressed {
button: i32,
click: String,
sent: vaegram::Result<EphemeralMessage>,
answered: vaegram::Result<()>,
}
enum Stuck {
Telegram(&'static str, Error),
Missing(String),
}
impl Stuck {
fn describe(&self) -> String {
match self {
Stuck::Telegram(what, e) => format!("{what} failed: {e:?}"),
Stuck::Missing(what) => what.clone(),
}
}
}
impl Ctx {
fn new(user: Client, bot: Client, prefix: &str) -> Ctx {
let plan: Arc<Mutex<HashMap<String, How>>> = Arc::default();
let made: Arc<Mutex<Made>> = Arc::default();
let (answer_tx, answers) = mpsc::unbounded_channel();
let (handler_plan, handler_made) = (plan.clone(), made.clone());
bot.on_callback_query(filters::data_prefix(prefix), move |query| {
let (answer_tx, plan, made) = (answer_tx.clone(), handler_plan.clone(), handler_made.clone());
async move {
let how = plan.lock().unwrap().get(&query.data).cloned();
let sent = match how {
Some(how) => answer(&query, how).await,
None => Err(Error::InvalidArgument("no answer is planned for this button")),
};
{
let mut made = made.lock().unwrap();
if let Ok(m) = &sent {
made.ephemerals.push((m.chat.id, m.receiver_user.id, m.id));
}
made.pending = made.pending.saturating_sub(1);
}
let answered = query.answer().await;
let _ = answer_tx.send((query.data.clone(), sent, answered));
Ok(())
}
})
.group(1);
Ctx { user, bot, plan, made, answers }
}
async fn press(&mut self, chat_id: i64, topic: Option<i32>, data: &str, how: How) -> Result<Pressed, Stuck> {
self.plan.lock().unwrap().insert(data.to_owned(), how);
let keyboard = InlineKeyboardMarkup::new([vec![InlineKeyboardButton::callback("Tap", data)]]);
let text = Text::new().plain(format!("vaegram live test: press {data}").as_str());
let send = self.bot.send_message(chat_id, text).reply_markup(keyboard);
let send = match topic {
Some(topic) => send.message_thread_id(topic),
None => send,
};
let button = send.await.map_err(|e| Stuck::Telegram("posting the button", e))?;
self.made.lock().unwrap().messages.push((chat_id, button.id));
let found = self.user.get_messages(chat_id, &[button.id]).await;
let found = found.map_err(|e| Stuck::Telegram("the user reading the button's message", e))?;
let Some(pressed) = found.into_iter().next().flatten() else {
return Err(Stuck::Missing("the user can't read the button's message".into()));
};
self.made.lock().unwrap().pending += 1;
let click = tokio::spawn(async move { tokio::time::timeout(WAIT, async { pressed.click("Tap").await }).await });
let answer = next(&mut self.answers, |(answered_data, _, _)| *answered_data == data).await;
let click = format!("{:?}", click.await);
let Some((_, sent, answered)) = answer else {
return Err(Stuck::Missing(format!("the bot got no press within {WAIT:?}; the user's click: {click}")));
};
Ok(Pressed { button: button.id, click, sent, answered })
}
}
struct Tap {
button: i32,
sent: EphemeralMessage,
seen: EphemeralMessage,
}
async fn tap(
ctx: &mut Ctx,
chat_id: i64,
data: String,
seen: &mut UnboundedReceiver<EphemeralMessage>,
) -> Result<Tap, Error> {
let how = How::Plain { replace: data.ends_with(":replace") };
let pressed = match ctx.press(chat_id, None, &data, how).await {
Ok(pressed) => pressed,
Err(Stuck::Telegram(_, e)) if e.flood_wait().is_some() => return Err(e),
Err(stuck) => panic!("{data}: {}", stuck.describe()),
};
eprintln!("{data}: the user's click returned {}", pressed.click);
eprintln!("{data}: the bot's answer_callback_query after the ephemeral send returned {:?}", pressed.answered);
let sent = pressed.sent?;
eprintln!("{data}: the bot's copy of its ephemeral answer: {}", fields(&sent));
let text = format!("ephemeral answer to {data}");
let on_user = match receive(seen, &sent).await {
Ok(on_user) => on_user,
Err(others) => panic!("{data}: {}", missing(&sent, Some(text.as_str()), &others).line()),
};
eprintln!("{data}: the user's copy of the ephemeral answer: {}", fields(&on_user));
assert_eq!(on_user.text, text, "{data}: the user's copy with the bot's id has other text");
Ok(Tap { button: pressed.button, sent, seen: on_user })
}
fn refused_for_rights(error: &Error) -> bool {
let Some(rpc) = error.rpc() else { return false };
let refused = rpc.code == 403 || ["ADMIN", "RIGHT", "FORBIDDEN"].iter().any(|word| rpc.name.contains(word));
if refused {
eprintln!("skipped: Telegram refused the bot's ephemeral answer to a press in VAEGRAM_CHAT_ID: {rpc:?}");
}
refused
}
async fn replace_steps(mut ctx: Ctx, chat_id: i64, prefix: String, mut seen: UnboundedReceiver<EphemeralMessage>) {
let flood = "posting the button or its ephemeral answer";
let control = match tap(&mut ctx, chat_id, format!("{prefix}:control"), &mut seen).await {
Ok(tap) => tap,
Err(e) if support::flood_limited(&e, flood) || refused_for_rights(&e) => return,
Err(e) => panic!("the ephemeral answer without replace_callback_query_message failed: {e:?}"),
};
let replaced = match tap(&mut ctx, chat_id, format!("{prefix}:replace"), &mut seen).await {
Ok(tap) => tap,
Err(e) if support::flood_limited(&e, flood) => return,
Err(e) => panic!("Telegram took the answer without replace_callback_query_message but refused it with: {e:?}"),
};
let (control_seen, replaced_seen) = (control.seen.anchor_message_id, replaced.seen.anchor_message_id);
eprintln!("anchor_message_id the user saw: control {control_seen:?}, replace {replaced_seen:?}");
eprintln!("the pressed message of the replace run: {}", replaced.button);
let (control_sent, replaced_sent) = (control.sent.anchor_message_id, replaced.sent.anchor_message_id);
eprintln!("anchor_message_id in the bot's copies: control {control_sent:?}, replace {replaced_sent:?}");
assert_eq!(control_seen, None, "the answer sent without the anchor flag is anchored too");
assert_eq!(replaced_seen, Some(replaced.button), "the answer sent with the anchor flag isn't on the pressed one");
assert_eq!((control_sent, replaced_sent), (None, None), "the copy returned to the bot names an anchor");
}
fn ephemerals_of(client: &Client) -> UnboundedReceiver<EphemeralMessage> {
let (seen_tx, seen) = mpsc::unbounded_channel();
client
.on_ephemeral_message(filters::all(), move |m| {
let _ = seen_tx.send(m);
async { Ok(()) }
})
.group(1);
seen
}
#[tokio::test]
#[ignore = "needs the kit bot and user in VAEGRAM_CHAT_ID, a supergroup"]
async fn ephemeral_replaces_the_callback_message() {
let Ok(chat_id) = std::env::var("VAEGRAM_CHAT_ID") else {
eprintln!("skipped: set VAEGRAM_CHAT_ID (a supergroup with the kit bot and user)");
return;
};
let chat_id: i64 = chat_id.parse().unwrap();
let Some(kit) = support::Kit::from_env().await else { return };
let prefix = format!("vaegram-replace-{}", nonce());
let ctx = Ctx::new(kit.user.client.clone(), kit.bot.clone(), &prefix);
let seen = ephemerals_of(&kit.user.client);
let (made, bot) = (ctx.made.clone(), ctx.bot.clone());
let steps = tokio::spawn(replace_steps(ctx, chat_id, prefix, seen)).await;
let failed = finish(&made, &bot).await;
if let Err(failed) = steps {
std::panic::resume_unwind(failed.into_panic());
}
assert!(failed.is_empty(), "the cleanup failed: {failed:?}");
}
enum Outcome {
Arrived { anchored: bool, got: Box<EphemeralMessage>, sent_anchor: Option<i32>, details: String },
Refused(Error),
Nothing(String),
IdsDiffer(String),
OtherText(String),
Setup(Stuck),
}
impl Outcome {
fn line(&self) -> String {
match self {
Outcome::Arrived { anchored: true, details, .. } => format!("anchored: {details}"),
Outcome::Arrived { anchored: false, details, .. } => format!("not anchored: {details}"),
Outcome::Refused(e) => format!("refused: {e:?}"),
Outcome::Nothing(details) => format!("nothing arrived within {WAIT:?}: {details}"),
Outcome::IdsDiffer(details) => format!("ids differ: {details}"),
Outcome::OtherText(details) => format!("other text: {details}"),
Outcome::Setup(stuck) => format!("setup failed: {}", stuck.describe()),
}
}
fn flooded(&self) -> bool {
match self {
Outcome::Refused(e) | Outcome::Setup(Stuck::Telegram(_, e)) => e.flood_wait().is_some(),
_ => false,
}
}
fn anchored(&self) -> bool {
matches!(self, Outcome::Arrived { anchored: true, .. })
}
fn telegram_error(&self) -> Option<&str> {
match self {
Outcome::Refused(e) => e.rpc().map(|rpc| rpc.name.as_str()),
_ => None,
}
}
}
fn judge(problems: &mut Vec<String>, name: &str, outcome: &Outcome, ok: bool) {
eprintln!("{name}: {}", outcome.line());
if outcome.flooded() {
eprintln!("{name}: not judged, flood-limited");
} else if !ok {
problems.push(format!("{name}: {}", outcome.line()));
}
}
async fn outcome(
ctx: &mut Ctx,
chat_id: i64,
topic: Option<i32>,
data: &str,
how: How,
seen: &mut UnboundedReceiver<EphemeralMessage>,
) -> Outcome {
while seen.try_recv().is_ok() {}
let text = match how {
How::Rich => None,
_ => Some(format!("ephemeral answer to {data}")),
};
let pressed = match ctx.press(chat_id, topic, data, how).await {
Ok(pressed) => pressed,
Err(stuck) => return Outcome::Setup(stuck),
};
let sent = match pressed.sent {
Ok(sent) => sent,
Err(e) => return Outcome::Refused(e),
};
let got = match receive(seen, &sent).await {
Ok(got) => got,
Err(others) => return missing(&sent, text.as_deref(), &others),
};
if let Some(text) = text.filter(|text| got.text != *text) {
return Outcome::OtherText(format!("expected {text:?}; received [{}]", fields(&got)));
}
let details = format!(
"pressed {}; received [{}]; the bot's copy [{}]; click {}; answer_callback_query {:?}",
pressed.button,
fields(&got),
fields(&sent),
pressed.click,
pressed.answered
);
let anchored = got.anchor_message_id == Some(pressed.button);
Outcome::Arrived { anchored, got: Box::new(got), sent_anchor: sent.anchor_message_id, details }
}
struct Second {
id: i64,
seen: UnboundedReceiver<EphemeralMessage>,
_disconnect: support::Disconnect,
}
async fn second_user(session: String) -> Result<Second, String> {
let env = |k: &str| std::env::var(k).map_err(|_| format!("set {k}"));
let api_id: i32 = env("VAEGRAM_API_ID")?.parse().map_err(|e| format!("VAEGRAM_API_ID: {e}"))?;
let builder = Client::builder(session, api_id, env("VAEGRAM_API_HASH")?).catch_up(false);
let client = builder.connect().await.map_err(|e| format!("logging in the second user: {e:?}"))?;
let disconnect = support::Disconnect(vec![client.clone()]);
let seen = ephemerals_of(&client);
let (started_tx, mut started) = mpsc::unbounded_channel();
client.on_start(move |_| {
let _ = started_tx.send(());
async { Ok(()) }
});
let runner = client.clone();
tokio::spawn(async move { runner.run().await });
if tokio::time::timeout(WAIT, started.recv()).await.is_err() {
return Err("the second user's run didn't start".into());
}
let id = client.get_me().await.map_err(|e| format!("get_me for the second user: {e:?}"))?.id;
Ok(Second { id, seen, _disconnect: disconnect })
}
async fn option_steps(
mut ctx: Ctx,
chat_id: i64,
prefix: String,
mut seen: UnboundedReceiver<EphemeralMessage>,
) -> Vec<String> {
let mut problems = Vec::new();
let reply = "(a) reply_to another regular message, without replace";
let target = ctx.bot.send_message(chat_id, Text::new().plain("vaegram live test: the answer replies here")).await;
match target {
Ok(target) => {
ctx.made.lock().unwrap().messages.push((chat_id, target.id));
let data = format!("{prefix}:reply");
let control = outcome(&mut ctx, chat_id, None, &data, How::ReplyTo(target.id), &mut seen).await;
let replied = |got: &EphemeralMessage| got.reply_to_message_id == Some(target.id);
let ok = matches!(&control, Outcome::Arrived { anchored: false, got, .. } if replied(got));
judge(&mut problems, reply, &control, ok);
}
Err(e) => {
let posting = Outcome::Setup(Stuck::Telegram("posting the message to reply to", e));
judge(&mut problems, reply, &posting, false);
}
}
problems.extend(finish(&ctx.made, &ctx.bot).await);
let rich = outcome(&mut ctx, chat_id, None, &format!("{prefix}:rich"), How::Rich, &mut seen).await;
let ok = matches!(&rich, Outcome::Arrived { anchored: true, sent_anchor: None, .. });
judge(&mut problems, "(b) replace + a rich message", &rich, ok);
problems.extend(finish(&ctx.made, &ctx.bot).await);
let media = outcome(&mut ctx, chat_id, None, &format!("{prefix}:media"), How::Media, &mut seen).await;
let ok = matches!(&media, Outcome::Arrived { anchored: true, got, sent_anchor: None, .. } if got.media.is_some());
judge(&mut problems, "(c) replace + media (a document from memory)", &media, ok);
problems.extend(finish(&ctx.made, &ctx.bot).await);
let topic_press = "(d) replace answering a press in a forum topic";
match std::env::var("VAEGRAM_FORUM_CHAT_ID").map(|id| id.parse::<i64>()) {
Ok(Ok(forum)) => {
let result = match ctx.user.create_forum_topic(forum, "vaegram live test").await {
Ok(topic) => {
let (data, how) = (format!("{prefix}:topic"), How::Plain { replace: true });
let result = outcome(&mut ctx, forum, Some(topic.id), &data, how, &mut seen).await;
problems.extend(finish(&ctx.made, &ctx.bot).await);
if let Err(e) = ctx.user.delete_forum_topic(forum, topic.id).await {
problems.push(format!("deleting topic {} in {forum}: {e:?}", topic.id));
}
result
}
Err(e) => Outcome::Setup(Stuck::Telegram("the user creating a topic in VAEGRAM_FORUM_CHAT_ID", e)),
};
let ok = matches!(&result, Outcome::Arrived { anchored: true, sent_anchor: None, .. });
judge(&mut problems, topic_press, &result, ok);
}
Ok(Err(e)) => {
let result = Outcome::Setup(Stuck::Missing(format!("VAEGRAM_FORUM_CHAT_ID: {e}")));
judge(&mut problems, topic_press, &result, false);
}
Err(_) => eprintln!("{topic_press}: skipped: set VAEGRAM_FORUM_CHAT_ID (a forum supergroup)"),
}
eprintln!(
"(e) replace on a button of an ephemeral message: skipped: vaegram can't press one. Message::click takes a \
regular Message, and ephemeral.getCallbackAnswer has no method"
);
let other = "(f) replace + a receiver who didn't press";
match std::env::var("VAEGRAM_SECOND_USER_SESSION") {
Ok(session) => {
let result = match second_user(session).await {
Ok(mut second) => {
match ctx.bot.get_chat_member(chat_id, second.id).await {
Ok(_) => {
let data = format!("{prefix}:other");
outcome(&mut ctx, chat_id, None, &data, How::To(second.id), &mut second.seen).await
}
Err(e) => Outcome::Setup(Stuck::Telegram("the bot looking up the second user in the chat", e)),
}
}
Err(why) => Outcome::Setup(Stuck::Missing(why)),
};
let ok = result.anchored() || result.telegram_error().is_some();
judge(&mut problems, other, &result, ok);
if let Some(name) = result.telegram_error() {
eprintln!("{other}: Telegram's error: {name}");
}
problems.extend(finish(&ctx.made, &ctx.bot).await);
}
Err(_) => eprintln!("{other}: skipped: set VAEGRAM_SECOND_USER_SESSION"),
}
problems
}
#[tokio::test]
#[ignore = "needs the kit bot and user in VAEGRAM_CHAT_ID; checks what replace does next to other options"]
async fn replace_with_other_options() {
let Ok(chat_id) = std::env::var("VAEGRAM_CHAT_ID") else {
eprintln!("skipped: set VAEGRAM_CHAT_ID (a supergroup with the kit bot and user)");
return;
};
let chat_id: i64 = chat_id.parse().unwrap();
let Some(kit) = support::Kit::from_env().await else { return };
let prefix = format!("vaegram-options-{}", nonce());
let ctx = Ctx::new(kit.user.client.clone(), kit.bot.clone(), &prefix);
let seen = ephemerals_of(&kit.user.client);
let (made, bot) = (ctx.made.clone(), ctx.bot.clone());
let steps = tokio::spawn(option_steps(ctx, chat_id, prefix, seen)).await;
let mut problems = finish(&made, &bot).await;
match steps {
Ok(found) => problems.extend(found),
Err(panicked) => std::panic::resume_unwind(panicked.into_panic()),
}
assert!(problems.is_empty(), "{problems:#?}");
}