diff --git a/AGENTS.md b/AGENTS.md index efd83f4..ff55858 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -20,7 +20,9 @@ Telegram update → Dispatcher (polling or axum webhook) → dptree branches Message flow: `message_handler` extracts URLs (from `url`/`text_link` entities, text + caption, deduped) → `x_media::site::fetch(url)` → `Fetched` → builds a `Task` → `send::send_media_sequence` (media groups ≤ 9, caption on first item) or `send::send_animation`. On Telegram URL-fetch failure or size error (`send_batch_via_upload`): download via `x_media::site::download_media` to a temp file (≤ 10 MiB), sniff magic bytes (`sniff_ext`), upload via multipart; oversized items fall back to `fallback_url`. On failure: `enqueue_retry` persists resume-state `Task` into the SQLite queue → workers lease (120 s lock TTL) → retry with exponential backoff (≤ 30 s, `MAX_RETRIES = 2`) → dead-letter → `notify_failure`. Success → `post_send_actions`: edit-before-forward prompt with inline buttons, or `copy_messages` to the bound forward channel. -Debug command: `/test ` runs the same `x_media::site::fetch` and replies with `test_parse_report` (`handlers/commands.rs`) — site id, normalized cache key, source URL, title/author/tags, sensitive flag, caption and the media list — nothing is sent, cached or forwarded; the report is capped at 4000 chars and sent with HTML parse mode: raw fields are escaped, and the caption is wrapped in a `
` so it renders exactly like the sent media caption (escaped text and links included). It uses a custom `parse_test_arg` parser (whole remainder, trimmed) because teloxide's built-in `split` parser takes exactly one space-separated token. +Debug command: `/debug ` runs the same `x_media::site::fetch` and replies with `debug_report` (`handlers/commands.rs`) — site id, normalized cache key, source URL, title/author/tags, sensitive flag, caption and the media list — nothing is sent, cached or forwarded; the report is capped at 4000 chars and sent with HTML parse mode: raw fields are escaped, and the caption is wrapped in a `
` so it renders exactly like the sent media caption (escaped text and links included). + +The `/test ` command runs the ordinary link pipeline (`urls::url_media`) with `PostSend::Suppressed`: the media is sent and cached like any other link, but the chat's `forward_channel_id`/`edit_before_forward` are ignored, so a test never forwards to the channel and never opens the edit prompt (retries and dead-letter notifications behave as usual). Both commands use a custom `parse_arg_remainder` parser (whole remainder, trimmed) because teloxide's built-in `split` parser takes exactly one space-separated token. The `x-media` library: `site::fetch(url)` dispatches through the `SITES` registry (per-site `impl Site`, in order twitter → bsky → misskey → pixiv) and returns `Ok(None)` for unmatched URLs. `Fetched { source_url, caption, title, media: Vec, sensitive, site_id, … }`; `caption_with(format)` substitutes `{url} {author} {author_url} {title} {tags}`. @@ -33,7 +35,7 @@ The `x-media` library: `site::fetch(url)` dispatches through the `SITES` registr | `crates/xmedia-bot/src/main.rs` | Entry point: env/log init, command registration (`register_commands`), shared `send::BOT` force-init, queue worker start, site login validation (`site::validate_all`), 300 s edit-expiry sweep, dptree handler tree, webhook vs polling dispatch | | `crates/xmedia-bot/src/config.rs` | Manual env parsing into `Config` | | `crates/xmedia-bot/src/db.rs` | `DbPool`: one shared SQLite connection pool (`POOL_SIZE = 4`, WAL, busy_timeout) for all three tables over `$DATA_DIR/task_queue.db` (default `data/`) — the three stores share it; `open_store` creates file + schema, `with_conn` runs all rusqlite I/O in `spawn_blocking` | -| `crates/xmedia-bot/src/handlers/` | Handler modules: `mod.rs` (message entry point, `reply`, `log_key`), `commands.rs` (teloxide `BotCommands` enum + command executor, incl. the `/test ` parse-only debug command and the admin-only `/bot_dict` state dump), `urls.rs` (URL extraction + bounded job channel (256) drained by `URL_WORKERS = 8` workers (`start_url_workers`) — backpressure instead of unbounded spawns; teloxide's per-chat workers are sequential — batch-forwards need concurrency), `inline.rs`/`callback.rs` (inline queries / edit-before-forward buttons), `statics.rs` (global statics) | +| `crates/xmedia-bot/src/handlers/` | Handler modules: `mod.rs` (message entry point, `reply`, `log_key`), `commands.rs` (teloxide `BotCommands` enum + command executor, incl. `/test ` (send-only) / `/debug ` (parse-only) and the admin-only `/bot_dict` state dump), `urls.rs` (URL extraction + bounded job channel (256) drained by `URL_WORKERS = 8` workers (`start_url_workers`) — backpressure instead of unbounded spawns; teloxide's per-chat workers are sequential — batch-forwards need concurrency), `inline.rs`/`callback.rs` (inline queries / edit-before-forward buttons), `statics.rs` (global statics) | | `crates/xmedia-bot/src/state.rs` | `ChatStore`: parking_lot `Mutex` cache + SQLite write-through (`chat_state` table) | | `crates/xmedia-bot/src/link_cache.rs` | `LinkCache`: SQLite-backed cache (`link_cache` table) of successfully sent posts — raw caption fields + Telegram `file_id`s; repeat links re-send locally (no fetch/upload), TTL + prune, invalidated on permanent send failure | | `crates/xmedia-bot/src/queue.rs` | `PersistentTaskQueue`: SQLite-backed queue (`tasks` table), `QUEUE_WORKERS = 4` concurrent workers (lease via `BEGIN IMMEDIATE` + `locked_until` TTL), retry→dead-letter, `notify_one` worker wakeup plus a separate `Notify` for the 30 s lease-expiry sweep (a shared one let the sweep steal the workers' wakeup permit), `busy_timeout` on all connections | @@ -73,7 +75,7 @@ Docker: `docker build -t tgxmb .` then `docker run --rm -d --name tgxmb --env-fi | File | Why it matters | |---|---| | `crates/xmedia-bot/src/main.rs` | Startup sequence, webhook vs polling, graceful shutdown (SIGINT via teloxide ctrlc / SIGTERM via `stop_token` for docker, → sweep stop → admin msg → queue stop) | -| `crates/xmedia-bot/src/handlers/` | `statics.rs` = `CHAT_STORE`/`TASK_QUEUE`/`CONFIG` singletons (open `$DATA_DIR/task_queue.db`, default `data/` **relative to CWD**, dir auto-created); `commands.rs` = command dispatch (incl. the `/test ` parse-only debug command and the admin-only `/bot_dict` state dump); `urls.rs` = URL extraction + the per-URL pipeline (`enqueue_retry` lives in `send/post_send.rs`); `inline.rs` = debounced inline queries; `callback.rs` = edit-before-forward buttons (dptree entry + testable `handle_callback` core) | +| `crates/xmedia-bot/src/handlers/` | `statics.rs` = `CHAT_STORE`/`TASK_QUEUE`/`CONFIG` singletons (open `$DATA_DIR/task_queue.db`, default `data/` **relative to CWD**, dir auto-created); `commands.rs` = command dispatch (incl. `/test ` send-only, `/debug ` parse-only, and the admin-only `/bot_dict` state dump); `urls.rs` = URL extraction + the per-URL pipeline (`url_media` takes a `PostSend` mode: chat settings vs `/test`'s suppressed actions); `inline.rs` = debounced inline queries; `callback.rs` = edit-before-forward buttons (dptree entry + testable `handle_callback` core) | | `crates/xmedia-bot/src/send/` | `mod.rs`: constants `MAX_MEDIA_GROUP = 9`; `classify_request_error`; the senders. `upload.rs`: download-and-reupload fallback triggered only by Telegram API errors (`is_media_fetch_failure` / `is_size_error`). `post_send.rs`: settlement (`settle_task`), cache write, post-send actions, queue handlers. `input_media.rs`: payload → `InputMedia` | | `crates/xmedia-bot/src/photo.rs` | Pure-Rust photo processing (no ffmpeg): `png` (image-png) decode/encode + `zune-jpeg` decode + `fast_image_resize` Lanczos3 downscale + `jpeg-encoder`. Photos over Telegram's limits (width + height > 10000 px → `PHOTO_INVALID_DIMENSIONS`; bytes > 10 MiB) are decoded, downscaled keeping the format, PNG bit depth > 24 (RGBA 32-bit / 16-bit per channel) reduced to 24-bit RGB with alpha flattened white (≤24-bit untouched, never upconverted), and transcoded to JPEG only if still over the cap; memory budget guarded, otherwise the item's smaller fallback URL | | `crates/x-media/src/site/mod.rs` | Dispatcher, `Fetched`/`FetchError`, shared `CLIENT`, `download_media` (adds `Referer: https://www.pixiv.net/` for `pximg.net` hotlink protection) | diff --git a/README.en.md b/README.en.md index 3d55c50..55650cc 100644 --- a/README.en.md +++ b/README.en.md @@ -114,7 +114,8 @@ Telegram only accepts ports 443/80/88/8443. | `/set_format ` | Customize the caption format for one site. Sites: `twitter` / `bsky` / `pixiv` / `misskey`. Placeholders: `{url}` `{author}` `{author_url}` `{title}` `{tags}` | | `/clear_cache [link]` | Clear the link cache (admin only); with a link only that entry, otherwise everything | | `/bot_dict` | Show the current chat state (debugging; admin only) | -| `/test ` | Debug: parse a link and report the parse result only (site, title, author, tags, media list) — no media is sent | +| `/test ` | Parse a link and send its media; no channel forward, no edit-before-forward prompt (send only) | +| `/debug ` | Debug: parse a link and report the parse result only (site, title, author, tags, media list) — no media is sent | Link processing works only in private chats; commands work in any chat. diff --git a/README.md b/README.md index f7ac499..bebdc9c 100644 --- a/README.md +++ b/README.md @@ -114,7 +114,8 @@ Telegram 只接受 443/80/88/8443 端口。 | `/set_format <站点> <格式>` | 自定义某站点的 caption 格式。站点：`twitter` / `bsky` / `pixiv` / `misskey`。占位符：`{url}` `{author}` `{author_url}` `{title}` `{tags}` | | `/clear_cache [链接]` | 清空链接缓存（仅管理员）；带链接只清该条，否则清空全部 | | `/bot_dict` | 查看当前聊天状态（调试用；仅管理员） | -| `/test <链接>` | 调试：只解析链接并返回解析结果（站点、标题、作者、标签、媒体列表），不发送任何媒体 | +| `/test <链接>` | 解析链接并发送媒体；不转发到频道、不弹转发前编辑提示（仅发送） | +| `/debug <链接>` | 调试：只解析链接并返回解析结果（站点、标题、作者、标签、媒体列表），不发送任何媒体 | 链接处理仅限私聊；命令在任意聊天可用。 diff --git a/crates/xmedia-bot/src/handlers/commands.rs b/crates/xmedia-bot/src/handlers/commands.rs index 19224e9..3cdf2e6 100644 --- a/crates/xmedia-bot/src/handlers/commands.rs +++ b/crates/xmedia-bot/src/handlers/commands.rs @@ -1,7 +1,9 @@ //! Bot command parsing, the `/`-command executor and `setMyCommands` //! registration. URL/inline/callback flows live in their own modules. +use super::urls::{PostSend, url_media}; use super::{CHAT_STORE, CONFIG, LINK_CACHE, log_key, reply, reply_html}; +use crate::ctx::AppContext; use teloxide::RequestError; use teloxide::prelude::*; use teloxide::types::{ChatId, Message, Recipient}; @@ -41,17 +43,22 @@ pub(crate) enum Command { )] ClearCache(String), #[command( - description = "Test link parsing (debug; no media sent)", - parse_with = parse_test_arg + description = "Send a link's media (no forwarding)", + parse_with = parse_arg_remainder )] Test(String), + #[command( + description = "Parse a link and report it (debug; nothing sent)", + parse_with = parse_arg_remainder + )] + Debug(String), } -/// `/test` argument parser: the whole remainder after the command name, -/// trimmed. The built-in `split` parser takes exactly one space-separated +/// `/test` and `/debug` argument parser: the whole remainder after the command +/// name, trimmed. The built-in `split` parser takes exactly one space-separated /// token and rejects the rest, so a URL followed by a trailing space (or /// pasted text) would silently fall through to the URL flow instead. -fn parse_test_arg(s: String) -> Result<(String,), ParseError> { +fn parse_arg_remainder(s: String) -> Result<(String,), ParseError> { Ok((s.trim().to_string(),)) } @@ -346,10 +353,47 @@ pub(crate) async fn execute_command( .await?; return Ok(()); } + if x_media::site::cache_key(url).is_none() { + reply( + bot, + message.chat.id.0, + message.id, + "No enabled site matches this link (twitter/x, pixiv, bsky or misskey).", + ) + .await?; + return Ok(()); + } + // The ordinary link pipeline with the chat's post-send actions + // suppressed: the media is sent (and cached) like a normal link, + // but nothing is forwarded to the channel and no + // edit-before-forward prompt opens. Info level echoes the + // normalized key (never the raw URL) per the logging convention. + log::info!("test: sending [key={}]", log_key(url)); + let ctx = AppContext::from_statics(bot); + url_media( + &ctx, + message.chat.id.0, + message.id.0 as i64, + url, + PostSend::Suppressed, + ) + .await; + } + Command::Debug(arg) => { + let url = arg.trim(); + if url.is_empty() { + reply( + bot, + message.chat.id.0, + message.id, + "Usage: /debug ", + ) + .await?; + return Ok(()); + } // Debug tool: report the parse result only — nothing is sent, - // cached or forwarded. Info level echoes the normalized key - // (never the raw URL) per the logging convention. - log::info!("test: parsing [key={}]", log_key(url)); + // cached or forwarded. + log::info!("debug: parsing [key={}]", log_key(url)); match x_media::site::fetch(url).await { Ok(None) => { reply( @@ -370,7 +414,7 @@ pub(crate) async fn execute_command( .await?; } Ok(Some(fetched)) => { - let report = test_parse_report( + let report = debug_report( url, fetched.site_name(), &fetched.source_url, @@ -406,13 +450,13 @@ pub async fn register_commands(bot: &Bot) -> Result<(), RequestError> { /// Telegram's plain-text message limit is 4096 chars; the report stays under /// it even for very large threads (many media lines + a long caption). -const MAX_TEST_REPORT_CHARS: usize = 4000; +const MAX_DEBUG_REPORT_CHARS: usize = 4000; /// Cap for the `/bot_dict` debug dump: the state is echoed as one plain-text /// message, so it must stay under Telegram's 4096-char limit. const MAX_DEBUG_DUMP_CHARS: usize = 3500; -/// Builds the HTML report for the `/test` command: what the parser produced +/// Builds the HTML report for the `/debug` command: what the parser produced /// for a link (site, canonical URL, title/author/tags, caption and the media /// list) — no media is sent and nothing is cached or forwarded. Sent with /// HTML parse mode: raw fields are escaped, the pre-escaped render fields are @@ -422,7 +466,7 @@ const MAX_DEBUG_DUMP_CHARS: usize = 3500; /// constructing a `Fetched` (its render fields are `pub(crate)` to the /// x-media crate). #[allow(clippy::too_many_arguments)] -fn test_parse_report( +fn debug_report( url: &str, site_id: &str, source_url: &str, @@ -483,8 +527,8 @@ fn test_parse_report( " ", ); - if out.chars().count() > MAX_TEST_REPORT_CHARS { - let end = out.floor_char_boundary(MAX_TEST_REPORT_CHARS - 1); + if out.chars().count() > MAX_DEBUG_REPORT_CHARS { + let end = out.floor_char_boundary(MAX_DEBUG_REPORT_CHARS - 1); out = format!("{}…", &out[..end]); } out @@ -492,11 +536,11 @@ fn test_parse_report( #[cfg(test)] mod tests { - use super::{MAX_TEST_REPORT_CHARS, test_parse_report}; + use super::{MAX_DEBUG_REPORT_CHARS, debug_report}; use x_media::media::Media; #[test] - fn test_parse_report_renders_fields_and_media() { + fn debug_report_renders_fields_and_media() { let media = vec![ Media::Illustration { title: None, @@ -510,7 +554,7 @@ mod tests { thumbnail_url: "https://cdn.example/2.jpg".into(), }, ]; - let report = test_parse_report( + let report = debug_report( "https://x.com/u/status/1", "twitter", "https://x.com/u/status/1", @@ -539,20 +583,20 @@ mod tests { } #[test] - fn test_parse_report_without_render_data_and_no_media() { - let report = test_parse_report("u", "pixiv", "s", "t", None, true, "c", &[]); + fn debug_report_without_render_data_and_no_media() { + let report = debug_report("u", "pixiv", "s", "t", None, true, "c", &[]); assert!(!report.contains("author:"), "{report}"); assert!(report.contains("sensitive: true"), "{report}"); assert!(report.contains("media (0):"), "{report}"); } #[test] - fn test_parse_report_wraps_caption_in_blockquote() { + fn debug_report_wraps_caption_in_blockquote() { // The report is an HTML message: raw fields are escaped, pre-escaped // render fields are embedded as-is, and the caption is wrapped in a //
so it shows exactly as it will render in the sent // media caption (escaped text and links included). - let report = test_parse_report( + let report = debug_report( "https://x.com/u/status/1", "twitter", "https://x.com/u/status/1", @@ -586,7 +630,7 @@ mod tests { } #[test] - fn test_parse_report_is_capped() { + fn debug_report_is_capped() { // 200 media lines ≈ 8 KB, comfortably over the cap. let media: Vec = (0..200) .map(|i| Media::Illustration { @@ -596,8 +640,8 @@ mod tests { fallback_url: None, }) .collect(); - let report = test_parse_report("u", "twitter", "s", "t", None, false, "c", &media); - assert!(report.chars().count() <= MAX_TEST_REPORT_CHARS, "{report}"); + let report = debug_report("u", "twitter", "s", "t", None, false, "c", &media); + assert!(report.chars().count() <= MAX_DEBUG_REPORT_CHARS, "{report}"); assert!(report.ends_with('…'), "{report}"); } } diff --git a/crates/xmedia-bot/src/handlers/urls.rs b/crates/xmedia-bot/src/handlers/urls.rs index ea012a8..d5e45d3 100644 --- a/crates/xmedia-bot/src/handlers/urls.rs +++ b/crates/xmedia-bot/src/handlers/urls.rs @@ -50,7 +50,14 @@ pub async fn start_url_workers() { let job = rx.lock().await.recv().await; match job { Some((message, url)) => { - url_media(&CONTEXT, message.chat.id.0, message.id.0 as i64, &url).await + url_media( + &CONTEXT, + message.chat.id.0, + message.id.0 as i64, + &url, + PostSend::FromChat, + ) + .await } None => break, } @@ -208,8 +215,20 @@ async fn dispatch_send( } } +/// Whether a send also runs the chat's post-send actions. `/test` sends with +/// them suppressed so a test can never forward to the channel or open the +/// edit-before-forward prompt; a normal link uses whatever the chat is +/// configured with. +#[derive(Clone, Copy, PartialEq, Eq, Debug)] +pub(crate) enum PostSend { + /// Apply the chat's `forward_channel_id` / `edit_before_forward`. + FromChat, + /// Send only: no channel forward, no edit prompt. + Suppressed, +} + /// Builds the send task from ready-made items, sharing the payload shape -/// between the fresh-fetch and link-cache paths. +/// between the fresh-fetch, link-cache and `/test` paths. #[allow(clippy::too_many_arguments)] fn build_send_task( chat_data: &ChatData, @@ -219,7 +238,14 @@ fn build_send_task( caption: String, items: Vec, cache_data: Option, + post_send: PostSend, ) -> Task { + // Notification ids stay set in both modes: a queued retry that + // dead-letters should still tell the chat. + let (edit_before_forward, forward_channel_id) = match post_send { + PostSend::FromChat => (chat_data.edit_before_forward, chat_data.forward_channel_id), + PostSend::Suppressed => (false, None), + }; if items.len() == 1 && matches!(items[0], MediaItemPayload::Animation { .. }) { Task::SendAnimation { chat_id, @@ -227,8 +253,8 @@ fn build_send_task( caption, animation: items.into_iter().next().unwrap(), source_url, - edit_before_forward: chat_data.edit_before_forward, - forward_channel_id: chat_data.forward_channel_id, + edit_before_forward, + forward_channel_id, notify_chat_id: Some(chat_id), notify_message_id: Some(reply_to_message_id), cache_data, @@ -244,8 +270,8 @@ fn build_send_task( batch_index: 0, sent_message_ids: vec![], source_url, - edit_before_forward: chat_data.edit_before_forward, - forward_channel_id: chat_data.forward_channel_id, + edit_before_forward, + forward_channel_id, notify_chat_id: Some(chat_id), notify_message_id: Some(reply_to_message_id), cache_data, @@ -253,7 +279,19 @@ fn build_send_task( } } -async fn url_media(ctx: &AppContext<'_>, chat_id: i64, reply_to_message_id: i64, url: &str) { +/// The per-URL pipeline: link cache → fetch → build → send → post-send. +/// +/// `post_send` selects whether the chat's forward/edit settings apply: the URL +/// workers pass [`PostSend::FromChat`], the `/test` command +/// [`PostSend::Suppressed`]. Everything else (cache write, retry enqueue, +/// dead-letter notification) is identical. +pub(crate) async fn url_media( + ctx: &AppContext<'_>, + chat_id: i64, + reply_to_message_id: i64, + url: &str, + post_send: PostSend, +) { let reply_to = MessageId(reply_to_message_id as i32); if let Err(e) = ctx .sender @@ -324,6 +362,7 @@ async fn url_media(ctx: &AppContext<'_>, chat_id: i64, reply_to_message_id: i64, caption, items, Some(cached), + post_send, ); dispatch_send(ctx, chat_id, reply_to, &task, url).await; return; @@ -392,6 +431,7 @@ async fn url_media(ctx: &AppContext<'_>, chat_id: i64, reply_to_message_id: i64, caption, items, cache_data, + post_send, ); // Hand the keep-alive temp dir (ugoira / bsky remux MP4) to the // retry registry: a queued retry runs after this function returns @@ -449,7 +489,7 @@ mod tests { .put("twitter:1", &cached_photo_entry()) .await; - url_media(&ctx, 1, 2, "https://x.com/u/status/1").await; + url_media(&ctx, 1, 2, "https://x.com/u/status/1", PostSend::FromChat).await; // The cached file id went out as a group send; the permanent failure // then triggered the fire-and-forget reply (its mock error is fine). @@ -477,7 +517,7 @@ mod tests { .put("twitter:1", &cached_photo_entry()) .await; - url_media(&ctx, 1, 2, "https://x.com/u/status/1").await; + url_media(&ctx, 1, 2, "https://x.com/u/status/1", PostSend::FromChat).await; assert_eq!(sender.calls(), vec!["send_chat_action", "send_media_group"]); // Success must not evict the entry. @@ -498,7 +538,128 @@ mod tests { // No cache key → the fetch dispatcher returns Ok(None) without any // network; nothing is sent or replied. - url_media(&ctx, 1, 2, "https://example.com/not-a-post").await; + url_media( + &ctx, + 1, + 2, + "https://example.com/not-a-post", + PostSend::FromChat, + ) + .await; assert_eq!(sender.calls(), vec!["send_chat_action"]); } + + // ── Send modes: the URL flow vs `/test` ───────────────────────────── + + /// A chat that has both post-send actions configured. + async fn seed_post_send_settings(ctx: &AppContext<'_>) { + ctx.chat_store + .update(1, |data| { + data.forward_channel_id = Some(2); + data.edit_before_forward = true; + }) + .await; + } + + #[tokio::test] + async fn chat_settings_apply_to_the_normal_link_flow() { + let stores = TestStores::new(); + let sender = + MockSender::scripted(vec![Outcome::GroupOk, Outcome::MessageOk], permanent_error); + let ctx = stores.ctx(&sender); + stores + .link_cache() + .put("twitter:1", &cached_photo_entry()) + .await; + seed_post_send_settings(&ctx).await; + + url_media(&ctx, 1, 2, "https://x.com/u/status/1", PostSend::FromChat).await; + + // Media group, then the edit prompt (edit-before-forward wins over the + // channel forward, which only runs once the prompt is confirmed). + assert_eq!( + sender.calls(), + vec!["send_chat_action", "send_media_group", "send_message"] + ); + } + + #[tokio::test] + async fn test_mode_sends_the_media_without_forwarding_or_editing() { + let stores = TestStores::new(); + // Only the group send is scripted: any forward (copy_messages) or edit + // prompt (send_message) would panic with "unexpected outcome". + let sender = MockSender::scripted(vec![Outcome::GroupOk], permanent_error); + let ctx = stores.ctx(&sender); + stores + .link_cache() + .put("twitter:1", &cached_photo_entry()) + .await; + seed_post_send_settings(&ctx).await; + + url_media(&ctx, 1, 2, "https://x.com/u/status/1", PostSend::Suppressed).await; + + assert_eq!(sender.calls(), vec!["send_chat_action", "send_media_group"]); + // The send is otherwise ordinary: the post stays cached. + assert!( + stores + .link_cache() + .get("twitter:1", Duration::from_secs(3600)) + .await + .is_some() + ); + } + + #[test] + fn send_mode_decides_whether_chat_actions_ride_along() { + let chat = ChatData { + forward_channel_id: Some(2), + edit_before_forward: true, + ..ChatData::default() + }; + + let with_chat = build_send_task( + &chat, + 1, + 2, + "https://x.com/u/status/1".into(), + "cap".into(), + vec![], + None, + PostSend::FromChat, + ); + let Task::SendMediaSequence { + edit_before_forward, + forward_channel_id, + .. + } = with_chat + else { + panic!("expected a media sequence task"); + }; + assert!(edit_before_forward); + assert_eq!(forward_channel_id, Some(2)); + + let suppressed = build_send_task( + &chat, + 1, + 2, + "https://x.com/u/status/1".into(), + "cap".into(), + vec![], + None, + PostSend::Suppressed, + ); + let Task::SendMediaSequence { + edit_before_forward, + forward_channel_id, + notify_chat_id, + .. + } = suppressed + else { + panic!("expected a media sequence task"); + }; + assert!(!edit_before_forward, "`/test` must not open an edit prompt"); + assert_eq!(forward_channel_id, None, "`/test` must not forward"); + // Dead-letter notification still reaches the chat that asked. + assert_eq!(notify_chat_id, Some(1)); + } }