From adf0896b7d0a8747b9698e4ae966f4ecd7275641 Mon Sep 17 00:00:00 2001 From: Alex Clarke Date: Fri, 4 Sep 2026 00:07:33 -0600 Subject: [PATCH] feat(readarr): add the downloads handler --- .../downloads/downloads_handler_tests.rs | 502 ++++++++++++++++++ .../readarr_handlers/downloads/mod.rs | 171 ++++++ src/handlers/readarr_handlers/mod.rs | 5 + .../readarr_handlers/readarr_handler_tests.rs | 16 + 4 files changed, 694 insertions(+) create mode 100644 src/handlers/readarr_handlers/downloads/downloads_handler_tests.rs create mode 100644 src/handlers/readarr_handlers/downloads/mod.rs diff --git a/src/handlers/readarr_handlers/downloads/downloads_handler_tests.rs b/src/handlers/readarr_handlers/downloads/downloads_handler_tests.rs new file mode 100644 index 00000000..b8666b0e --- /dev/null +++ b/src/handlers/readarr_handlers/downloads/downloads_handler_tests.rs @@ -0,0 +1,502 @@ +#[cfg(test)] +mod tests { + use pretty_assertions::assert_eq; + use rstest::rstest; + use serde_json::Number; + use strum::IntoEnumIterator; + + use crate::app::App; + use crate::app::key_binding::DEFAULT_KEYBINDINGS; + use crate::assert_navigation_pushed; + use crate::event::Key; + use crate::handlers::KeyEventHandler; + use crate::handlers::readarr_handlers::downloads::DownloadsHandler; + use crate::models::readarr_models::{DownloadRecord, DownloadStatus}; + use crate::models::servarr_data::readarr::readarr_data::{ActiveReadarrBlock, DOWNLOADS_BLOCKS}; + + mod test_handle_delete { + use pretty_assertions::assert_eq; + + use super::*; + + const DELETE_KEY: Key = DEFAULT_KEYBINDINGS.delete.key; + + #[test] + fn test_delete_download_prompt() { + let mut app = App::test_default(); + app.push_navigation_stack(ActiveReadarrBlock::Downloads.into()); + app.data.readarr_data.downloads.set_items(downloads_vec()); + + DownloadsHandler::new(DELETE_KEY, &mut app, ActiveReadarrBlock::Downloads, None).handle(); + + assert_navigation_pushed!(app, ActiveReadarrBlock::DeleteDownloadPrompt.into()); + } + + #[test] + fn test_delete_download_prompt_no_op_when_not_ready() { + let mut app = App::test_default(); + app.is_loading = true; + app.push_navigation_stack(ActiveReadarrBlock::Downloads.into()); + app.data.readarr_data.downloads.set_items(downloads_vec()); + + DownloadsHandler::new(DELETE_KEY, &mut app, ActiveReadarrBlock::Downloads, None).handle(); + + assert_eq!( + app.get_current_route(), + ActiveReadarrBlock::Downloads.into() + ); + } + } + + mod test_handle_left_right_action { + use pretty_assertions::assert_eq; + use rstest::rstest; + + use super::*; + use crate::assert_navigation_pushed; + + #[rstest] + fn test_downloads_tab_left(#[values(true, false)] is_ready: bool) { + let mut app = App::test_default(); + app.push_navigation_stack(ActiveReadarrBlock::Downloads.into()); + app.is_loading = is_ready; + app.data.readarr_data.main_tabs.set_index(1); + + DownloadsHandler::new( + DEFAULT_KEYBINDINGS.left.key, + &mut app, + ActiveReadarrBlock::Downloads, + None, + ) + .handle(); + + assert_eq!( + app.data.readarr_data.main_tabs.get_active_route(), + ActiveReadarrBlock::Authors.into() + ); + assert_navigation_pushed!(app, ActiveReadarrBlock::Authors.into()); + } + + #[rstest] + fn test_downloads_tab_right(#[values(true, false)] is_ready: bool) { + let mut app = App::test_default(); + app.push_navigation_stack(ActiveReadarrBlock::Downloads.into()); + app.is_loading = is_ready; + app.data.readarr_data.main_tabs.set_index(1); + + DownloadsHandler::new( + DEFAULT_KEYBINDINGS.right.key, + &mut app, + ActiveReadarrBlock::Downloads, + None, + ) + .handle(); + + assert_eq!( + app.data.readarr_data.main_tabs.get_active_route(), + ActiveReadarrBlock::Blocklist.into() + ); + assert_navigation_pushed!(app, ActiveReadarrBlock::Blocklist.into()); + } + + #[rstest] + fn test_downloads_left_right_prompt_toggle( + #[values( + ActiveReadarrBlock::DeleteDownloadPrompt, + ActiveReadarrBlock::UpdateDownloadsPrompt + )] + active_readarr_block: ActiveReadarrBlock, + #[values(DEFAULT_KEYBINDINGS.left.key, DEFAULT_KEYBINDINGS.right.key)] key: Key, + ) { + let mut app = App::test_default(); + app.push_navigation_stack(ActiveReadarrBlock::Downloads.into()); + + DownloadsHandler::new(key, &mut app, active_readarr_block, None).handle(); + + assert!(app.data.readarr_data.prompt_confirm); + + DownloadsHandler::new(key, &mut app, active_readarr_block, None).handle(); + + assert!(!app.data.readarr_data.prompt_confirm); + } + } + + mod test_handle_submit { + use rstest::rstest; + + use super::*; + use crate::assert_navigation_popped; + use crate::network::readarr_network::ReadarrEvent; + + const SUBMIT_KEY: Key = DEFAULT_KEYBINDINGS.submit.key; + + #[rstest] + #[case( + ActiveReadarrBlock::Downloads, + ActiveReadarrBlock::DeleteDownloadPrompt, + ReadarrEvent::DeleteDownload(3) + )] + #[case( + ActiveReadarrBlock::Downloads, + ActiveReadarrBlock::UpdateDownloadsPrompt, + ReadarrEvent::UpdateDownloads + )] + fn test_downloads_prompt_confirm_submit( + #[case] base_route: ActiveReadarrBlock, + #[case] prompt_block: ActiveReadarrBlock, + #[case] expected_action: ReadarrEvent, + ) { + let mut app = App::test_default(); + app.data.readarr_data.downloads.set_items(downloads_vec()); + app.data.readarr_data.prompt_confirm = true; + app.push_navigation_stack(base_route.into()); + app.push_navigation_stack(prompt_block.into()); + + DownloadsHandler::new(SUBMIT_KEY, &mut app, prompt_block, None).handle(); + + assert!(app.data.readarr_data.prompt_confirm); + assert_some_eq_x!( + &app.data.readarr_data.prompt_confirm_action, + &expected_action + ); + assert_navigation_popped!(app, base_route.into()); + } + + #[rstest] + #[case( + ActiveReadarrBlock::Downloads, + ActiveReadarrBlock::DeleteDownloadPrompt + )] + #[case( + ActiveReadarrBlock::Downloads, + ActiveReadarrBlock::UpdateDownloadsPrompt + )] + fn test_downloads_prompt_decline_submit( + #[case] base_route: ActiveReadarrBlock, + #[case] prompt_block: ActiveReadarrBlock, + ) { + let mut app = App::test_default(); + app.data.readarr_data.downloads.set_items(downloads_vec()); + app.push_navigation_stack(base_route.into()); + app.push_navigation_stack(prompt_block.into()); + + DownloadsHandler::new(SUBMIT_KEY, &mut app, prompt_block, None).handle(); + + assert!(!app.data.readarr_data.prompt_confirm); + assert_none!(app.data.readarr_data.prompt_confirm_action); + assert_navigation_popped!(app, base_route.into()); + } + } + + mod test_handle_esc { + use rstest::rstest; + + use super::*; + use crate::assert_navigation_popped; + + const ESC_KEY: Key = DEFAULT_KEYBINDINGS.esc.key; + + #[rstest] + #[case( + ActiveReadarrBlock::Downloads, + ActiveReadarrBlock::DeleteDownloadPrompt + )] + #[case( + ActiveReadarrBlock::Downloads, + ActiveReadarrBlock::UpdateDownloadsPrompt + )] + fn test_downloads_prompt_blocks_esc( + #[case] base_block: ActiveReadarrBlock, + #[case] prompt_block: ActiveReadarrBlock, + ) { + let mut app = App::test_default(); + app.push_navigation_stack(base_block.into()); + app.push_navigation_stack(prompt_block.into()); + app.data.readarr_data.prompt_confirm = true; + + DownloadsHandler::new(ESC_KEY, &mut app, prompt_block, None).handle(); + + assert_navigation_popped!(app, base_block.into()); + assert!(!app.data.readarr_data.prompt_confirm); + } + + #[rstest] + fn test_default_esc(#[values(true, false)] is_ready: bool) { + let mut app = App::test_default(); + app.is_loading = is_ready; + app.error = "test error".to_owned().into(); + app.push_navigation_stack(ActiveReadarrBlock::Downloads.into()); + app.push_navigation_stack(ActiveReadarrBlock::Downloads.into()); + + DownloadsHandler::new(ESC_KEY, &mut app, ActiveReadarrBlock::Downloads, None).handle(); + + assert_navigation_popped!(app, ActiveReadarrBlock::Downloads.into()); + assert_is_empty!(app.error.text); + } + } + + mod test_handle_key_char { + use pretty_assertions::assert_eq; + use rstest::rstest; + + use super::*; + use crate::network::readarr_network::ReadarrEvent; + use crate::{assert_navigation_popped, assert_navigation_pushed}; + + #[test] + fn test_update_downloads_key() { + let mut app = App::test_default(); + app.push_navigation_stack(ActiveReadarrBlock::Downloads.into()); + app.data.readarr_data.downloads.set_items(downloads_vec()); + + DownloadsHandler::new( + DEFAULT_KEYBINDINGS.update.key, + &mut app, + ActiveReadarrBlock::Downloads, + None, + ) + .handle(); + + assert_navigation_pushed!(app, ActiveReadarrBlock::UpdateDownloadsPrompt.into()); + } + + #[test] + fn test_update_downloads_key_no_op_when_not_ready() { + let mut app = App::test_default(); + app.is_loading = true; + app.push_navigation_stack(ActiveReadarrBlock::Downloads.into()); + app.data.readarr_data.downloads.set_items(downloads_vec()); + + DownloadsHandler::new( + DEFAULT_KEYBINDINGS.update.key, + &mut app, + ActiveReadarrBlock::Downloads, + None, + ) + .handle(); + + assert_eq!( + app.get_current_route(), + ActiveReadarrBlock::Downloads.into() + ); + } + + #[test] + fn test_refresh_downloads_key() { + let mut app = App::test_default(); + app.data.readarr_data.downloads.set_items(downloads_vec()); + app.push_navigation_stack(ActiveReadarrBlock::Downloads.into()); + + DownloadsHandler::new( + DEFAULT_KEYBINDINGS.refresh.key, + &mut app, + ActiveReadarrBlock::Downloads, + None, + ) + .handle(); + + assert_navigation_pushed!(app, ActiveReadarrBlock::Downloads.into()); + assert!(app.should_refresh); + } + + #[test] + fn test_refresh_downloads_key_no_op_when_not_ready() { + let mut app = App::test_default(); + app.is_loading = true; + app.push_navigation_stack(ActiveReadarrBlock::Downloads.into()); + app.data.readarr_data.downloads.set_items(downloads_vec()); + + DownloadsHandler::new( + DEFAULT_KEYBINDINGS.refresh.key, + &mut app, + ActiveReadarrBlock::Downloads, + None, + ) + .handle(); + + assert_eq!( + app.get_current_route(), + ActiveReadarrBlock::Downloads.into() + ); + assert!(!app.should_refresh); + } + + #[rstest] + #[case( + ActiveReadarrBlock::Downloads, + ActiveReadarrBlock::DeleteDownloadPrompt, + ReadarrEvent::DeleteDownload(3) + )] + #[case( + ActiveReadarrBlock::Downloads, + ActiveReadarrBlock::UpdateDownloadsPrompt, + ReadarrEvent::UpdateDownloads + )] + fn test_downloads_prompt_confirm( + #[case] base_route: ActiveReadarrBlock, + #[case] prompt_block: ActiveReadarrBlock, + #[case] expected_action: ReadarrEvent, + ) { + let mut app = App::test_default(); + app.data.readarr_data.downloads.set_items(downloads_vec()); + app.push_navigation_stack(base_route.into()); + app.push_navigation_stack(prompt_block.into()); + + DownloadsHandler::new( + DEFAULT_KEYBINDINGS.confirm.key, + &mut app, + prompt_block, + None, + ) + .handle(); + + assert!(app.data.readarr_data.prompt_confirm); + assert_some_eq_x!( + &app.data.readarr_data.prompt_confirm_action, + &expected_action + ); + assert_navigation_popped!(app, base_route.into()); + } + } + + #[test] + fn test_downloads_handler_accepts() { + ActiveReadarrBlock::iter().for_each(|active_readarr_block| { + if DOWNLOADS_BLOCKS.contains(&active_readarr_block) { + assert!(DownloadsHandler::accepts(active_readarr_block)); + } else { + assert!(!DownloadsHandler::accepts(active_readarr_block)); + } + }) + } + + #[rstest] + fn test_downloads_handler_ignore_special_keys( + #[values(true, false)] ignore_special_keys_for_textbox_input: bool, + ) { + let mut app = App::test_default(); + app.ignore_special_keys_for_textbox_input = ignore_special_keys_for_textbox_input; + let handler = DownloadsHandler::new( + DEFAULT_KEYBINDINGS.esc.key, + &mut app, + ActiveReadarrBlock::default(), + None, + ); + + assert_eq!( + handler.ignore_special_keys(), + ignore_special_keys_for_textbox_input + ); + } + + #[test] + fn test_extract_download_id() { + let mut app = App::test_default(); + app.data.readarr_data.downloads.set_items(downloads_vec()); + app.data.readarr_data.downloads.select_index(Some(1)); + + let download_id = DownloadsHandler::new( + DEFAULT_KEYBINDINGS.esc.key, + &mut app, + ActiveReadarrBlock::Downloads, + None, + ) + .extract_download_id(); + + assert_eq!(download_id, 2); + } + + #[test] + fn test_downloads_handler_not_ready_when_loading() { + let mut app = App::test_default(); + app.push_navigation_stack(ActiveReadarrBlock::Downloads.into()); + app.is_loading = true; + + let handler = DownloadsHandler::new( + DEFAULT_KEYBINDINGS.esc.key, + &mut app, + ActiveReadarrBlock::Downloads, + None, + ); + + assert!(!handler.is_ready()); + } + + #[test] + fn test_downloads_handler_not_ready_when_downloads_is_empty() { + let mut app = App::test_default(); + app.push_navigation_stack(ActiveReadarrBlock::Downloads.into()); + app.is_loading = false; + + let handler = DownloadsHandler::new( + DEFAULT_KEYBINDINGS.esc.key, + &mut app, + ActiveReadarrBlock::Downloads, + None, + ); + + assert!(!handler.is_ready()); + } + + #[test] + fn test_downloads_handler_ready_when_not_loading_and_downloads_is_not_empty() { + let mut app = App::test_default(); + app.push_navigation_stack(ActiveReadarrBlock::Downloads.into()); + app.is_loading = false; + app + .data + .readarr_data + .downloads + .set_items(vec![DownloadRecord::default()]); + + let handler = DownloadsHandler::new( + DEFAULT_KEYBINDINGS.esc.key, + &mut app, + ActiveReadarrBlock::Downloads, + None, + ); + + assert!(handler.is_ready()); + } + + fn downloads_vec() -> Vec { + vec![ + DownloadRecord { + title: "Test Book Download Three".to_owned(), + status: DownloadStatus::Downloading, + id: 3, + book_id: Some(Number::from(13)), + author_id: Some(Number::from(23)), + size: 3000.0, + sizeleft: 750.0, + output_path: Some("/nfs/nzbget/completed/books/Zora Neale - Test Book Three".into()), + indexer: "test-indexer-three".to_owned(), + download_client: Some("NZBGet".to_owned()), + }, + DownloadRecord { + title: "Test Book Download Two".to_owned(), + status: DownloadStatus::Queued, + id: 2, + book_id: Some(Number::from(12)), + author_id: Some(Number::from(22)), + size: 2000.0, + sizeleft: 500.0, + output_path: Some("/nfs/nzbget/completed/books/Mary Shelley - Test Book Two".into()), + indexer: "test-indexer-two".to_owned(), + download_client: Some("Transmission".to_owned()), + }, + DownloadRecord { + title: "Test Book Download One".to_owned(), + status: DownloadStatus::Paused, + id: 1, + book_id: Some(Number::from(11)), + author_id: Some(Number::from(21)), + size: 1000.0, + sizeleft: 250.0, + output_path: Some("/nfs/nzbget/completed/books/Ursula Le Guin - Test Book One".into()), + indexer: "test-indexer-one".to_owned(), + download_client: Some("SABnzbd".to_owned()), + }, + ] + } +} diff --git a/src/handlers/readarr_handlers/downloads/mod.rs b/src/handlers/readarr_handlers/downloads/mod.rs new file mode 100644 index 00000000..3e0bf18d --- /dev/null +++ b/src/handlers/readarr_handlers/downloads/mod.rs @@ -0,0 +1,171 @@ +use crate::app::App; +use crate::event::Key; +use crate::handlers::readarr_handlers::handle_change_tab_left_right_keys; +use crate::handlers::table_handler::{TableHandlingConfig, handle_table}; +use crate::handlers::{KeyEventHandler, handle_clear_errors, handle_prompt_toggle}; +use crate::matches_key; +use crate::models::Route; +use crate::models::servarr_data::readarr::readarr_data::{ActiveReadarrBlock, DOWNLOADS_BLOCKS}; +use crate::network::readarr_network::ReadarrEvent; + +#[cfg(test)] +#[path = "downloads_handler_tests.rs"] +mod downloads_handler_tests; + +pub(super) struct DownloadsHandler<'a, 'b> { + key: Key, + app: &'a mut App<'b>, + active_readarr_block: ActiveReadarrBlock, + _context: Option, +} + +impl DownloadsHandler<'_, '_> { + fn extract_download_id(&self) -> i64 { + self.app.data.readarr_data.downloads.current_selection().id + } +} + +impl<'a, 'b> KeyEventHandler<'a, 'b, ActiveReadarrBlock> for DownloadsHandler<'a, 'b> { + fn handle(&mut self) { + let downloads_table_handling_config = + TableHandlingConfig::new(ActiveReadarrBlock::Downloads.into()); + + if !handle_table( + self, + |app| &mut app.data.readarr_data.downloads, + downloads_table_handling_config, + ) { + self.handle_key_event(); + } + } + + fn accepts(active_block: ActiveReadarrBlock) -> bool { + DOWNLOADS_BLOCKS.contains(&active_block) + } + + fn ignore_special_keys(&self) -> bool { + self.app.ignore_special_keys_for_textbox_input + } + + fn new( + key: Key, + app: &'a mut App<'b>, + active_block: ActiveReadarrBlock, + _context: Option, + ) -> DownloadsHandler<'a, 'b> { + DownloadsHandler { + key, + app, + active_readarr_block: active_block, + _context, + } + } + + fn get_key(&self) -> Key { + self.key + } + + fn is_ready(&self) -> bool { + !self.app.is_loading && !self.app.data.readarr_data.downloads.is_empty() + } + + fn handle_scroll_up(&mut self) {} + + fn handle_scroll_down(&mut self) {} + + fn handle_home(&mut self) {} + + fn handle_end(&mut self) {} + + fn handle_delete(&mut self) { + if self.active_readarr_block == ActiveReadarrBlock::Downloads { + self + .app + .push_navigation_stack(ActiveReadarrBlock::DeleteDownloadPrompt.into()); + } + } + + fn handle_left_right_action(&mut self) { + match self.active_readarr_block { + ActiveReadarrBlock::Downloads => handle_change_tab_left_right_keys(self.app, self.key), + ActiveReadarrBlock::DeleteDownloadPrompt | ActiveReadarrBlock::UpdateDownloadsPrompt => { + handle_prompt_toggle(self.app, self.key) + } + _ => (), + } + } + + fn handle_submit(&mut self) { + match self.active_readarr_block { + ActiveReadarrBlock::DeleteDownloadPrompt => { + if self.app.data.readarr_data.prompt_confirm { + self.app.data.readarr_data.prompt_confirm_action = + Some(ReadarrEvent::DeleteDownload(self.extract_download_id())); + } + + self.app.pop_navigation_stack(); + } + ActiveReadarrBlock::UpdateDownloadsPrompt => { + if self.app.data.readarr_data.prompt_confirm { + self.app.data.readarr_data.prompt_confirm_action = Some(ReadarrEvent::UpdateDownloads); + } + + self.app.pop_navigation_stack(); + } + _ => (), + } + } + + fn handle_esc(&mut self) { + match self.active_readarr_block { + ActiveReadarrBlock::DeleteDownloadPrompt | ActiveReadarrBlock::UpdateDownloadsPrompt => { + self.app.pop_navigation_stack(); + self.app.data.readarr_data.prompt_confirm = false; + } + _ => handle_clear_errors(self.app), + } + } + + fn handle_char_key_event(&mut self) { + let key = self.key; + match self.active_readarr_block { + ActiveReadarrBlock::Downloads => match self.key { + _ if matches_key!(update, key) => { + self + .app + .push_navigation_stack(ActiveReadarrBlock::UpdateDownloadsPrompt.into()); + } + _ if matches_key!(refresh, key) => { + self.app.should_refresh = true; + } + _ => (), + }, + ActiveReadarrBlock::DeleteDownloadPrompt => { + if matches_key!(confirm, key) { + self.app.data.readarr_data.prompt_confirm = true; + self.app.data.readarr_data.prompt_confirm_action = + Some(ReadarrEvent::DeleteDownload(self.extract_download_id())); + + self.app.pop_navigation_stack(); + } + } + ActiveReadarrBlock::UpdateDownloadsPrompt => { + if matches_key!(confirm, key) { + self.app.data.readarr_data.prompt_confirm = true; + self.app.data.readarr_data.prompt_confirm_action = Some(ReadarrEvent::UpdateDownloads); + + self.app.pop_navigation_stack(); + } + } + _ => (), + } + } + + fn app_mut(&mut self) -> &mut App<'b> { + self.app + } + + fn current_route(&self) -> Route { + self.app.get_current_route() + } +} diff --git a/src/handlers/readarr_handlers/mod.rs b/src/handlers/readarr_handlers/mod.rs index 2de29fc0..6233cffc 100644 --- a/src/handlers/readarr_handlers/mod.rs +++ b/src/handlers/readarr_handlers/mod.rs @@ -1,5 +1,6 @@ use super::KeyEventHandler; use crate::handlers::readarr_handlers::blocklist::BlocklistHandler; +use crate::handlers::readarr_handlers::downloads::DownloadsHandler; use crate::handlers::readarr_handlers::library::LibraryHandler; use crate::models::Route; use crate::{ @@ -8,6 +9,7 @@ use crate::{ }; mod blocklist; +mod downloads; mod history; mod library; @@ -28,6 +30,9 @@ impl<'a, 'b> KeyEventHandler<'a, 'b, ActiveReadarrBlock> for ReadarrHandler<'a, _ if LibraryHandler::accepts(self.active_readarr_block) => { LibraryHandler::new(self.key, self.app, self.active_readarr_block, self.context).handle(); } + _ if DownloadsHandler::accepts(self.active_readarr_block) => { + DownloadsHandler::new(self.key, self.app, self.active_readarr_block, self.context).handle(); + } _ if BlocklistHandler::accepts(self.active_readarr_block) => { BlocklistHandler::new(self.key, self.app, self.active_readarr_block, self.context).handle(); } diff --git a/src/handlers/readarr_handlers/readarr_handler_tests.rs b/src/handlers/readarr_handlers/readarr_handler_tests.rs index d0806dd2..6d8445c3 100644 --- a/src/handlers/readarr_handlers/readarr_handler_tests.rs +++ b/src/handlers/readarr_handlers/readarr_handler_tests.rs @@ -194,4 +194,20 @@ mod tests { active_readarr_block ); } + + #[rstest] + fn test_delegates_downloads_blocks_to_downloads_handler( + #[values( + ActiveReadarrBlock::Downloads, + ActiveReadarrBlock::DeleteDownloadPrompt, + ActiveReadarrBlock::UpdateDownloadsPrompt + )] + active_readarr_block: ActiveReadarrBlock, + ) { + test_handler_delegation!( + ReadarrHandler, + ActiveReadarrBlock::Downloads, + active_readarr_block + ); + } }