use bimap::BiMap; use chrono::{DateTime, Utc}; use strum::IntoEnumIterator; use crate::app::{App, Route}; use crate::models::radarr_models::{ AddMovieSearchResult, Collection, CollectionMovie, Credit, DiskSpace, DownloadRecord, MinimumAvailability, Monitor, Movie, MovieHistoryItem, Release, ReleaseField, RootFolder, }; use crate::models::{ HorizontallyScrollableText, ScrollableText, StatefulList, StatefulTable, TabRoute, TabState, }; use crate::network::radarr_network::RadarrEvent; pub struct RadarrData { pub root_folders: StatefulTable, pub disk_space_vec: Vec, pub version: String, pub start_time: DateTime, pub movies: StatefulTable, pub filtered_movies: StatefulTable, pub add_searched_movies: StatefulTable, pub monitor_list: StatefulList, pub minimum_availability_list: StatefulList, pub quality_profile_list: StatefulList, pub root_folder_list: StatefulList, pub selected_block: ActiveRadarrBlock, pub downloads: StatefulTable, pub quality_profile_map: BiMap, pub tags_map: BiMap, pub movie_details: ScrollableText, pub file_details: String, pub audio_details: String, pub video_details: String, pub movie_history: StatefulTable, pub movie_cast: StatefulTable, pub movie_crew: StatefulTable, pub movie_releases: StatefulTable, pub movie_releases_sort: StatefulList, pub collections: StatefulTable, pub filtered_collections: StatefulTable, pub collection_movies: StatefulTable, pub prompt_confirm_action: Option, pub main_tabs: TabState, pub movie_info_tabs: TabState, pub search: HorizontallyScrollableText, pub filter: HorizontallyScrollableText, pub edit_path: HorizontallyScrollableText, pub edit_tags: HorizontallyScrollableText, pub edit_monitored: Option, pub edit_search_on_add: Option, pub sort_ascending: Option, pub prompt_confirm: bool, pub is_searching: bool, pub is_filtering: bool, } impl RadarrData { pub fn reset_movie_collection_table(&mut self) { self.collection_movies = StatefulTable::default(); } pub fn reset_search(&mut self) { self.is_searching = false; self.search = HorizontallyScrollableText::default(); self.filter = HorizontallyScrollableText::default(); self.filtered_movies = StatefulTable::default(); self.filtered_collections = StatefulTable::default(); self.add_searched_movies = StatefulTable::default(); } pub fn reset_filter(&mut self) { self.is_filtering = false; self.filter = HorizontallyScrollableText::default(); self.filtered_movies = StatefulTable::default(); self.filtered_collections = StatefulTable::default(); } pub fn reset_add_edit_media_fields(&mut self) { self.edit_monitored = None; self.edit_search_on_add = None; self.edit_path = HorizontallyScrollableText::default(); self.edit_tags = HorizontallyScrollableText::default(); self.reset_preferences_selections(); } pub fn reset_movie_info_tabs(&mut self) { self.file_details = String::default(); self.audio_details = String::default(); self.video_details = String::default(); self.movie_details = ScrollableText::default(); self.movie_history = StatefulTable::default(); self.movie_cast = StatefulTable::default(); self.movie_crew = StatefulTable::default(); self.movie_releases = StatefulTable::default(); self.movie_releases_sort = StatefulList::default(); self.sort_ascending = None; self.movie_info_tabs.index = 0; } pub fn reset_preferences_selections(&mut self) { self.monitor_list = StatefulList::default(); self.minimum_availability_list = StatefulList::default(); self.quality_profile_list = StatefulList::default(); self.root_folder_list = StatefulList::default(); } pub fn populate_preferences_lists(&mut self) { self.monitor_list.set_items(Vec::from_iter(Monitor::iter())); self .minimum_availability_list .set_items(Vec::from_iter(MinimumAvailability::iter())); let mut quality_profile_names: Vec = self.quality_profile_map.right_values().cloned().collect(); quality_profile_names.sort(); self.quality_profile_list.set_items(quality_profile_names); self .root_folder_list .set_items(self.root_folders.items.to_vec()); } pub fn populate_edit_movie_fields(&mut self) { self.populate_preferences_lists(); let Movie { path, tags, monitored, minimum_availability, quality_profile_id, .. } = if self.filtered_movies.items.is_empty() { self.movies.current_selection() } else { self.filtered_movies.current_selection() }; self.edit_path = path.clone().into(); self.edit_tags = tags .iter() .map(|tag_id| { self .tags_map .get_by_left(&tag_id.as_u64().unwrap()) .unwrap() .clone() }) .collect::>() .join(", ") .into(); self.edit_monitored = Some(*monitored); let minimum_availability_index = self .minimum_availability_list .items .iter() .position(|ma| ma == minimum_availability); self .minimum_availability_list .state .select(minimum_availability_index); let quality_profile_name = self .quality_profile_map .get_by_left(&quality_profile_id.as_u64().unwrap()) .unwrap(); let quality_profile_index = self .quality_profile_list .items .iter() .position(|profile| profile == quality_profile_name); self .quality_profile_list .state .select(quality_profile_index); } pub fn populate_edit_collection_fields(&mut self) { self.populate_preferences_lists(); let Collection { root_folder_path, monitored, search_on_add, minimum_availability, quality_profile_id, .. } = if self.filtered_collections.items.is_empty() { self.collections.current_selection() } else { self.filtered_collections.current_selection() }; self.edit_path = root_folder_path.clone().unwrap_or_default().into(); self.edit_monitored = Some(*monitored); self.edit_search_on_add = Some(*search_on_add); let minimum_availability_index = self .minimum_availability_list .items .iter() .position(|ma| ma == minimum_availability); self .minimum_availability_list .state .select(minimum_availability_index); let quality_profile_name = self .quality_profile_map .get_by_left(&quality_profile_id.as_u64().unwrap()) .unwrap(); let quality_profile_index = self .quality_profile_list .items .iter() .position(|profile| profile == quality_profile_name); self .quality_profile_list .state .select(quality_profile_index); } } impl Default for RadarrData { fn default() -> RadarrData { RadarrData { root_folders: StatefulTable::default(), disk_space_vec: Vec::new(), version: String::default(), start_time: DateTime::default(), movies: StatefulTable::default(), add_searched_movies: StatefulTable::default(), monitor_list: StatefulList::default(), minimum_availability_list: StatefulList::default(), quality_profile_list: StatefulList::default(), root_folder_list: StatefulList::default(), selected_block: ActiveRadarrBlock::AddMovieSelectRootFolder, filtered_movies: StatefulTable::default(), downloads: StatefulTable::default(), quality_profile_map: BiMap::default(), tags_map: BiMap::default(), file_details: String::default(), audio_details: String::default(), video_details: String::default(), movie_details: ScrollableText::default(), movie_history: StatefulTable::default(), movie_cast: StatefulTable::default(), movie_crew: StatefulTable::default(), movie_releases: StatefulTable::default(), movie_releases_sort: StatefulList::default(), collections: StatefulTable::default(), filtered_collections: StatefulTable::default(), collection_movies: StatefulTable::default(), prompt_confirm_action: None, search: HorizontallyScrollableText::default(), filter: HorizontallyScrollableText::default(), edit_path: HorizontallyScrollableText::default(), edit_tags: HorizontallyScrollableText::default(), edit_monitored: None, edit_search_on_add: None, sort_ascending: None, is_searching: false, is_filtering: false, prompt_confirm: false, main_tabs: TabState::new(vec![ TabRoute { title: "Library".to_owned(), route: ActiveRadarrBlock::Movies.into(), help: String::default(), contextual_help: Some(" add | edit | delete | search | filter | refresh | update all | details | cancel filter" .to_owned()), }, TabRoute { title: "Downloads".to_owned(), route: ActiveRadarrBlock::Downloads.into(), help: String::default(), contextual_help: Some(" refresh | delete".to_owned()), }, TabRoute { title: "Collections".to_owned(), route: ActiveRadarrBlock::Collections.into(), help: String::default(), contextual_help: Some(" search | edit | filter | refresh | update all | details | cancel filter" .to_owned()), }, TabRoute { title: "Root Folders".to_owned(), route: ActiveRadarrBlock::RootFolders.into(), help: String::default(), contextual_help: Some(" add | delete | refresh".to_owned()), }, ]), movie_info_tabs: TabState::new(vec![ TabRoute { title: "Details".to_owned(), route: ActiveRadarrBlock::MovieDetails.into(), help: " refresh | update | edit | auto search | close".to_owned(), contextual_help: None }, TabRoute { title: "History".to_owned(), route: ActiveRadarrBlock::MovieHistory.into(), help: " refresh | update | edit | auto search | close".to_owned(), contextual_help: None }, TabRoute { title: "File".to_owned(), route: ActiveRadarrBlock::FileInfo.into(), help: " refresh | update | edit | auto search | close".to_owned(), contextual_help: None, }, TabRoute { title: "Cast".to_owned(), route: ActiveRadarrBlock::Cast.into(), help: " refresh | update | edit | auto search | close".to_owned(), contextual_help: None, }, TabRoute { title: "Crew".to_owned(), route: ActiveRadarrBlock::Crew.into(), help: " refresh | update | edit | auto search | close".to_owned(), contextual_help: None, }, TabRoute { title: "Manual Search".to_owned(), route: ActiveRadarrBlock::ManualSearch.into(), help: " refresh | update | edit | sort | auto search | close".to_owned(), contextual_help: Some(" details".to_owned()) } ]), } } } #[derive(Clone, Copy, PartialEq, Eq, Debug)] pub enum ActiveRadarrBlock { AddMovieAlreadyInLibrary, AddMovieSearchInput, AddMovieSearchResults, AddMoviePrompt, AddMovieSelectMinimumAvailability, AddMovieSelectQualityProfile, AddMovieSelectMonitor, AddMovieSelectRootFolder, AddMovieConfirmPrompt, AddMovieTagsInput, AddMovieEmptySearchResults, AddRootFolderPrompt, AutomaticallySearchMoviePrompt, Collections, CollectionDetails, Cast, Crew, DeleteMoviePrompt, DeleteDownloadPrompt, DeleteRootFolderPrompt, Downloads, EditCollectionPrompt, EditCollectionConfirmPrompt, EditCollectionRootFolderPathInput, EditCollectionSelectMinimumAvailability, EditCollectionSelectQualityProfile, EditCollectionToggleSearchOnAdd, EditCollectionToggleMonitored, EditMoviePrompt, EditMovieConfirmPrompt, EditMoviePathInput, EditMovieSelectMinimumAvailability, EditMovieSelectQualityProfile, EditMovieTagsInput, EditMovieToggleMonitored, FileInfo, FilterCollections, FilterMovies, ManualSearch, ManualSearchSortPrompt, ManualSearchConfirmPrompt, MovieDetails, MovieHistory, Movies, RootFolders, UpdateAndScanPrompt, UpdateAllCollectionsPrompt, UpdateAllMoviesPrompt, UpdateDownloadsPrompt, SearchMovie, SearchCollection, ViewMovieOverview, } pub const ADD_MOVIE_BLOCKS: [ActiveRadarrBlock; 10] = [ ActiveRadarrBlock::AddMovieSearchInput, ActiveRadarrBlock::AddMovieSearchResults, ActiveRadarrBlock::AddMovieEmptySearchResults, ActiveRadarrBlock::AddMoviePrompt, ActiveRadarrBlock::AddMovieSelectMinimumAvailability, ActiveRadarrBlock::AddMovieSelectMonitor, ActiveRadarrBlock::AddMovieSelectQualityProfile, ActiveRadarrBlock::AddMovieSelectRootFolder, ActiveRadarrBlock::AddMovieAlreadyInLibrary, ActiveRadarrBlock::AddMovieTagsInput, ]; pub const EDIT_COLLECTION_BLOCKS: [ActiveRadarrBlock; 7] = [ ActiveRadarrBlock::EditCollectionPrompt, ActiveRadarrBlock::EditCollectionConfirmPrompt, ActiveRadarrBlock::EditCollectionRootFolderPathInput, ActiveRadarrBlock::EditCollectionSelectMinimumAvailability, ActiveRadarrBlock::EditCollectionSelectQualityProfile, ActiveRadarrBlock::EditCollectionToggleSearchOnAdd, ActiveRadarrBlock::EditCollectionToggleMonitored, ]; pub const EDIT_MOVIE_BLOCKS: [ActiveRadarrBlock; 7] = [ ActiveRadarrBlock::EditMoviePrompt, ActiveRadarrBlock::EditMovieConfirmPrompt, ActiveRadarrBlock::EditMoviePathInput, ActiveRadarrBlock::EditMovieSelectMinimumAvailability, ActiveRadarrBlock::EditMovieSelectQualityProfile, ActiveRadarrBlock::EditMovieTagsInput, ActiveRadarrBlock::EditMovieToggleMonitored, ]; pub const MOVIE_DETAILS_BLOCKS: [ActiveRadarrBlock; 10] = [ ActiveRadarrBlock::MovieDetails, ActiveRadarrBlock::MovieHistory, ActiveRadarrBlock::FileInfo, ActiveRadarrBlock::Cast, ActiveRadarrBlock::Crew, ActiveRadarrBlock::AutomaticallySearchMoviePrompt, ActiveRadarrBlock::UpdateAndScanPrompt, ActiveRadarrBlock::ManualSearch, ActiveRadarrBlock::ManualSearchSortPrompt, ActiveRadarrBlock::ManualSearchConfirmPrompt, ]; pub const COLLECTION_DETAILS_BLOCKS: [ActiveRadarrBlock; 2] = [ ActiveRadarrBlock::CollectionDetails, ActiveRadarrBlock::ViewMovieOverview, ]; pub const SEARCH_BLOCKS: [ActiveRadarrBlock; 2] = [ ActiveRadarrBlock::SearchMovie, ActiveRadarrBlock::SearchCollection, ]; pub const FILTER_BLOCKS: [ActiveRadarrBlock; 2] = [ ActiveRadarrBlock::FilterMovies, ActiveRadarrBlock::FilterCollections, ]; impl ActiveRadarrBlock { pub fn next_add_movie_prompt_block(&self) -> Self { match self { ActiveRadarrBlock::AddMovieSelectRootFolder => ActiveRadarrBlock::AddMovieSelectMonitor, ActiveRadarrBlock::AddMovieSelectMonitor => { ActiveRadarrBlock::AddMovieSelectMinimumAvailability } ActiveRadarrBlock::AddMovieSelectMinimumAvailability => { ActiveRadarrBlock::AddMovieSelectQualityProfile } ActiveRadarrBlock::AddMovieSelectQualityProfile => ActiveRadarrBlock::AddMovieTagsInput, ActiveRadarrBlock::AddMovieTagsInput => ActiveRadarrBlock::AddMovieConfirmPrompt, _ => ActiveRadarrBlock::AddMovieSelectRootFolder, } } pub fn next_edit_movie_prompt_block(&self) -> Self { match self { ActiveRadarrBlock::EditMovieToggleMonitored => { ActiveRadarrBlock::EditMovieSelectMinimumAvailability } ActiveRadarrBlock::EditMovieSelectMinimumAvailability => { ActiveRadarrBlock::EditMovieSelectQualityProfile } ActiveRadarrBlock::EditMovieSelectQualityProfile => ActiveRadarrBlock::EditMoviePathInput, ActiveRadarrBlock::EditMoviePathInput => ActiveRadarrBlock::EditMovieTagsInput, ActiveRadarrBlock::EditMovieTagsInput => ActiveRadarrBlock::EditMovieConfirmPrompt, _ => ActiveRadarrBlock::EditMovieToggleMonitored, } } pub fn next_edit_collection_prompt_block(&self) -> Self { match self { ActiveRadarrBlock::EditCollectionToggleMonitored => { ActiveRadarrBlock::EditCollectionSelectMinimumAvailability } ActiveRadarrBlock::EditCollectionSelectMinimumAvailability => { ActiveRadarrBlock::EditCollectionSelectQualityProfile } ActiveRadarrBlock::EditCollectionSelectQualityProfile => { ActiveRadarrBlock::EditCollectionRootFolderPathInput } ActiveRadarrBlock::EditCollectionRootFolderPathInput => { ActiveRadarrBlock::EditCollectionToggleSearchOnAdd } ActiveRadarrBlock::EditCollectionToggleSearchOnAdd => { ActiveRadarrBlock::EditCollectionConfirmPrompt } _ => ActiveRadarrBlock::EditCollectionToggleMonitored, } } pub fn previous_add_movie_prompt_block(&self) -> Self { match self { ActiveRadarrBlock::AddMovieSelectRootFolder => ActiveRadarrBlock::AddMovieConfirmPrompt, ActiveRadarrBlock::AddMovieSelectMonitor => ActiveRadarrBlock::AddMovieSelectRootFolder, ActiveRadarrBlock::AddMovieSelectMinimumAvailability => { ActiveRadarrBlock::AddMovieSelectMonitor } ActiveRadarrBlock::AddMovieSelectQualityProfile => { ActiveRadarrBlock::AddMovieSelectMinimumAvailability } ActiveRadarrBlock::AddMovieTagsInput => ActiveRadarrBlock::AddMovieSelectQualityProfile, ActiveRadarrBlock::AddMovieConfirmPrompt => ActiveRadarrBlock::AddMovieTagsInput, _ => ActiveRadarrBlock::AddMovieSelectRootFolder, } } pub fn previous_edit_movie_prompt_block(&self) -> Self { match self { ActiveRadarrBlock::EditMovieToggleMonitored => ActiveRadarrBlock::EditMovieConfirmPrompt, ActiveRadarrBlock::EditMovieSelectMinimumAvailability => { ActiveRadarrBlock::EditMovieToggleMonitored } ActiveRadarrBlock::EditMovieSelectQualityProfile => { ActiveRadarrBlock::EditMovieSelectMinimumAvailability } ActiveRadarrBlock::EditMoviePathInput => ActiveRadarrBlock::EditMovieSelectQualityProfile, ActiveRadarrBlock::EditMovieTagsInput => ActiveRadarrBlock::EditMoviePathInput, ActiveRadarrBlock::EditMovieConfirmPrompt => ActiveRadarrBlock::EditMovieTagsInput, _ => ActiveRadarrBlock::EditMovieToggleMonitored, } } pub fn previous_edit_collection_prompt_block(&self) -> Self { match self { ActiveRadarrBlock::EditCollectionToggleMonitored => { ActiveRadarrBlock::EditCollectionConfirmPrompt } ActiveRadarrBlock::EditCollectionSelectMinimumAvailability => { ActiveRadarrBlock::EditCollectionToggleMonitored } ActiveRadarrBlock::EditCollectionSelectQualityProfile => { ActiveRadarrBlock::EditCollectionSelectMinimumAvailability } ActiveRadarrBlock::EditCollectionRootFolderPathInput => { ActiveRadarrBlock::EditCollectionSelectQualityProfile } ActiveRadarrBlock::EditCollectionToggleSearchOnAdd => { ActiveRadarrBlock::EditCollectionRootFolderPathInput } ActiveRadarrBlock::EditCollectionConfirmPrompt => { ActiveRadarrBlock::EditCollectionToggleSearchOnAdd } _ => ActiveRadarrBlock::EditCollectionToggleMonitored, } } } impl From for Route { fn from(active_radarr_block: ActiveRadarrBlock) -> Route { Route::Radarr(active_radarr_block, None) } } impl From<(ActiveRadarrBlock, Option)> for Route { fn from(value: (ActiveRadarrBlock, Option)) -> Route { Route::Radarr(value.0, value.1) } } impl App { pub(super) async fn dispatch_by_radarr_block(&mut self, active_radarr_block: &ActiveRadarrBlock) { match active_radarr_block { ActiveRadarrBlock::Collections => { self .dispatch_network_event(RadarrEvent::GetCollections.into()) .await; } ActiveRadarrBlock::CollectionDetails => { self.is_loading = true; self.populate_movie_collection_table().await; self.is_loading = false; } ActiveRadarrBlock::Downloads => { self .dispatch_network_event(RadarrEvent::GetDownloads.into()) .await; } ActiveRadarrBlock::RootFolders => { self .dispatch_network_event(RadarrEvent::GetRootFolders.into()) .await; } ActiveRadarrBlock::Movies => { self .dispatch_network_event(RadarrEvent::GetMovies.into()) .await; self .dispatch_network_event(RadarrEvent::GetDownloads.into()) .await; } ActiveRadarrBlock::AddMovieSearchResults => { self .dispatch_network_event(RadarrEvent::SearchNewMovie.into()) .await; } ActiveRadarrBlock::MovieDetails | ActiveRadarrBlock::FileInfo => { self .dispatch_network_event(RadarrEvent::GetMovieDetails.into()) .await; } ActiveRadarrBlock::MovieHistory => { self .dispatch_network_event(RadarrEvent::GetMovieHistory.into()) .await; } ActiveRadarrBlock::Cast | ActiveRadarrBlock::Crew => { if self.data.radarr_data.movie_cast.items.is_empty() || self.data.radarr_data.movie_crew.items.is_empty() { self .dispatch_network_event(RadarrEvent::GetMovieCredits.into()) .await; } } ActiveRadarrBlock::ManualSearch => { if self.data.radarr_data.movie_releases.items.is_empty() { self .dispatch_network_event(RadarrEvent::GetReleases.into()) .await; } } _ => (), } self.check_for_prompt_action().await; self.reset_tick_count(); } async fn check_for_prompt_action(&mut self) { if self.data.radarr_data.prompt_confirm { self.data.radarr_data.prompt_confirm = false; if let Some(radarr_event) = &self.data.radarr_data.prompt_confirm_action { self.dispatch_network_event((*radarr_event).into()).await; self.should_refresh = true; self.data.radarr_data.prompt_confirm_action = None; } } } pub(super) async fn radarr_on_tick( &mut self, active_radarr_block: ActiveRadarrBlock, is_first_render: bool, ) { if is_first_render { self .dispatch_network_event(RadarrEvent::GetQualityProfiles.into()) .await; self .dispatch_network_event(RadarrEvent::GetTags.into()) .await; self .dispatch_network_event(RadarrEvent::GetRootFolders.into()) .await; self .dispatch_network_event(RadarrEvent::GetOverview.into()) .await; self .dispatch_network_event(RadarrEvent::GetStatus.into()) .await; self.dispatch_by_radarr_block(&active_radarr_block).await; } if self.should_refresh { self.dispatch_by_radarr_block(&active_radarr_block).await; } if self.is_routing || self.tick_count % self.tick_until_poll == 0 { self.dispatch_by_radarr_block(&active_radarr_block).await; self.refresh_metadata().await; } } async fn refresh_metadata(&mut self) { self .dispatch_network_event(RadarrEvent::GetQualityProfiles.into()) .await; self .dispatch_network_event(RadarrEvent::GetTags.into()) .await; self .dispatch_network_event(RadarrEvent::GetDownloads.into()) .await; } async fn populate_movie_collection_table(&mut self) { let collection_movies = if !self.data.radarr_data.filtered_collections.items.is_empty() { self .data .radarr_data .filtered_collections .current_selection() .clone() .movies .unwrap_or_default() } else { self .data .radarr_data .collections .current_selection() .clone() .movies .unwrap_or_default() }; self .data .radarr_data .collection_movies .set_items(collection_movies); } } #[cfg(test)] #[macro_use] pub mod radarr_test_utils { use crate::app::radarr::RadarrData; use crate::models::radarr_models::{ AddMovieSearchResult, Collection, CollectionMovie, Credit, MinimumAvailability, Monitor, Movie, MovieHistoryItem, Release, ReleaseField, RootFolder, }; use crate::models::ScrollableText; pub fn create_test_radarr_data() -> RadarrData { let mut radarr_data = RadarrData { is_searching: true, is_filtering: true, search: "test search".to_owned().into(), filter: "test filter".to_owned().into(), edit_path: "test path".to_owned().into(), edit_tags: "usenet, test".to_owned().into(), edit_monitored: Some(true), edit_search_on_add: Some(true), file_details: "test file details".to_owned(), audio_details: "test audio details".to_owned(), video_details: "test video details".to_owned(), movie_details: ScrollableText::with_string("test movie details".to_owned()), ..RadarrData::default() }; radarr_data .movie_history .set_items(vec![MovieHistoryItem::default()]); radarr_data.movie_cast.set_items(vec![Credit::default()]); radarr_data.movie_crew.set_items(vec![Credit::default()]); radarr_data .movie_releases .set_items(vec![Release::default()]); radarr_data.movie_info_tabs.index = 1; radarr_data.monitor_list.set_items(vec![Monitor::default()]); radarr_data .minimum_availability_list .set_items(vec![MinimumAvailability::default()]); radarr_data .quality_profile_list .set_items(vec![String::default()]); radarr_data .root_folder_list .set_items(vec![RootFolder::default()]); radarr_data .movie_releases_sort .set_items(vec![ReleaseField::default()]); radarr_data.sort_ascending = Some(true); radarr_data .filtered_movies .set_items(vec![Movie::default()]); radarr_data .filtered_collections .set_items(vec![Collection::default()]); radarr_data .add_searched_movies .set_items(vec![AddMovieSearchResult::default()]); radarr_data .collection_movies .set_items(vec![CollectionMovie::default()]); radarr_data } #[macro_export] macro_rules! assert_movie_collection_table_reset { ($radarr_data:expr) => { assert!($radarr_data.collection_movies.items.is_empty()); }; } #[macro_export] macro_rules! assert_search_reset { ($radarr_data:expr) => { assert!(!$radarr_data.is_searching); assert!($radarr_data.search.text.is_empty()); assert!($radarr_data.filter.text.is_empty()); assert!($radarr_data.filtered_movies.items.is_empty()); assert!($radarr_data.filtered_collections.items.is_empty()); assert!($radarr_data.add_searched_movies.items.is_empty()); }; } #[macro_export] macro_rules! assert_edit_media_reset { ($radarr_data:expr) => { assert!($radarr_data.edit_monitored.is_none()); assert!($radarr_data.edit_search_on_add.is_none()); assert!($radarr_data.edit_path.text.is_empty()); assert!($radarr_data.edit_tags.text.is_empty()); }; } #[macro_export] macro_rules! assert_filter_reset { ($radarr_data:expr) => { assert!(!$radarr_data.is_filtering); assert!($radarr_data.filter.text.is_empty()); assert!($radarr_data.filtered_movies.items.is_empty()); assert!($radarr_data.filtered_collections.items.is_empty()); }; } #[macro_export] macro_rules! assert_movie_info_tabs_reset { ($radarr_data:expr) => { assert!($radarr_data.file_details.is_empty()); assert!($radarr_data.audio_details.is_empty()); assert!($radarr_data.video_details.is_empty()); assert!($radarr_data.movie_details.get_text().is_empty()); assert!($radarr_data.movie_history.items.is_empty()); assert!($radarr_data.movie_cast.items.is_empty()); assert!($radarr_data.movie_crew.items.is_empty()); assert!($radarr_data.movie_releases.items.is_empty()); assert!($radarr_data.movie_releases_sort.items.is_empty()); assert!($radarr_data.sort_ascending.is_none()); assert_eq!($radarr_data.movie_info_tabs.index, 0); }; } #[macro_export] macro_rules! assert_preferences_selections_reset { ($radarr_data:expr) => { assert!($radarr_data.monitor_list.items.is_empty()); assert!($radarr_data.minimum_availability_list.items.is_empty()); assert!($radarr_data.quality_profile_list.items.is_empty()); assert!($radarr_data.root_folder_list.items.is_empty()); }; } } #[cfg(test)] mod tests { mod radarr_data_tests { use bimap::BiMap; use chrono::{DateTime, Utc}; use pretty_assertions::{assert_eq, assert_str_eq}; use rstest::rstest; use serde_json::Number; use strum::IntoEnumIterator; use crate::app::radarr::radarr_test_utils::create_test_radarr_data; use crate::app::radarr::{ActiveRadarrBlock, RadarrData}; use crate::models::radarr_models::{ Collection, MinimumAvailability, Monitor, Movie, RootFolder, }; use crate::models::HorizontallyScrollableText; use crate::models::Route; use crate::models::StatefulTable; #[test] fn test_from_tuple_to_route_with_context() { assert_eq!( Route::from(( ActiveRadarrBlock::AddMoviePrompt, Some(ActiveRadarrBlock::AddMovieSearchResults) )), Route::Radarr( ActiveRadarrBlock::AddMoviePrompt, Some(ActiveRadarrBlock::AddMovieSearchResults) ) ); } #[test] fn test_reset_movie_collection_table() { let mut radarr_data = create_test_radarr_data(); radarr_data.reset_movie_collection_table(); assert_movie_collection_table_reset!(radarr_data); } #[test] fn test_reset_search() { let mut radarr_data = create_test_radarr_data(); radarr_data.reset_search(); assert_search_reset!(radarr_data); } #[test] fn test_reset_filter() { let mut radarr_data = create_test_radarr_data(); radarr_data.reset_filter(); assert_filter_reset!(radarr_data); } #[test] fn test_reset_movie_info_tabs() { let mut radarr_data = create_test_radarr_data(); radarr_data.reset_movie_info_tabs(); assert_movie_info_tabs_reset!(radarr_data); } #[test] fn test_reset_add_edit_media_fields() { let mut radarr_data = RadarrData { edit_monitored: Some(true), edit_search_on_add: Some(true), edit_path: "test path".to_owned().into(), edit_tags: "test tag".to_owned().into(), ..RadarrData::default() }; radarr_data.reset_add_edit_media_fields(); assert_edit_media_reset!(radarr_data); } #[test] fn test_reset_preferences_selections() { let mut radarr_data = create_test_radarr_data(); radarr_data.reset_preferences_selections(); assert_preferences_selections_reset!(radarr_data); } #[test] fn test_populate_preferences_lists() { let root_folder = RootFolder { id: Number::from(1), path: "/nfs".to_owned(), accessible: true, free_space: Number::from(219902325555200u64), unmapped_folders: None, }; let mut radarr_data = RadarrData { quality_profile_map: BiMap::from_iter([ (2222, "HD - 1080p".to_owned()), (1111, "Any".to_owned()), ]), ..RadarrData::default() }; radarr_data .root_folders .set_items(vec![root_folder.clone()]); radarr_data.populate_preferences_lists(); assert_eq!( radarr_data.monitor_list.items, Vec::from_iter(Monitor::iter()) ); assert_eq!( radarr_data.minimum_availability_list.items, Vec::from_iter(MinimumAvailability::iter()) ); assert_eq!( radarr_data.quality_profile_list.items, vec!["Any".to_owned(), "HD - 1080p".to_owned()] ); assert_eq!(radarr_data.root_folder_list.items, vec![root_folder]); } #[rstest] fn test_populate_edit_movie_fields(#[values(true, false)] test_filtered_movies: bool) { let mut radarr_data = RadarrData { edit_path: HorizontallyScrollableText::default(), edit_tags: HorizontallyScrollableText::default(), edit_monitored: None, quality_profile_map: BiMap::from_iter([ (2222, "HD - 1080p".to_owned()), (1111, "Any".to_owned()), ]), tags_map: BiMap::from_iter([(1, "usenet".to_owned()), (2, "test".to_owned())]), filtered_movies: StatefulTable::default(), ..create_test_radarr_data() }; let movie = Movie { path: "/nfs/movies/Test".to_owned(), monitored: true, quality_profile_id: Number::from(2222), minimum_availability: MinimumAvailability::Released, tags: vec![Number::from(1), Number::from(2)], ..Movie::default() }; if test_filtered_movies { radarr_data.filtered_movies.set_items(vec![movie]); } else { radarr_data.movies.set_items(vec![movie]); } radarr_data.populate_edit_movie_fields(); assert_eq!( radarr_data.minimum_availability_list.items, Vec::from_iter(MinimumAvailability::iter()) ); assert_eq!( radarr_data.minimum_availability_list.current_selection(), &MinimumAvailability::Released ); assert_eq!( radarr_data.quality_profile_list.items, vec!["Any".to_owned(), "HD - 1080p".to_owned()] ); assert_str_eq!( radarr_data.quality_profile_list.current_selection(), "HD - 1080p" ); assert_str_eq!(radarr_data.edit_path.text, "/nfs/movies/Test"); assert_str_eq!(radarr_data.edit_tags.text, "usenet, test"); assert_eq!(radarr_data.edit_monitored, Some(true)); } #[rstest] fn test_populate_edit_collection_fields( #[values(true, false)] test_filtered_collections: bool, ) { let mut radarr_data = RadarrData { edit_path: HorizontallyScrollableText::default(), edit_monitored: None, edit_search_on_add: None, quality_profile_map: BiMap::from_iter([ (2222, "HD - 1080p".to_owned()), (1111, "Any".to_owned()), ]), filtered_collections: StatefulTable::default(), ..create_test_radarr_data() }; let collection = Collection { root_folder_path: Some("/nfs/movies/Test".to_owned()), monitored: true, search_on_add: true, quality_profile_id: Number::from(2222), minimum_availability: MinimumAvailability::Released, ..Collection::default() }; if test_filtered_collections { radarr_data.filtered_collections.set_items(vec![collection]); } else { radarr_data.collections.set_items(vec![collection]); } radarr_data.populate_edit_collection_fields(); assert_eq!( radarr_data.minimum_availability_list.items, Vec::from_iter(MinimumAvailability::iter()) ); assert_eq!( radarr_data.minimum_availability_list.current_selection(), &MinimumAvailability::Released ); assert_eq!( radarr_data.quality_profile_list.items, vec!["Any".to_owned(), "HD - 1080p".to_owned()] ); assert_str_eq!( radarr_data.quality_profile_list.current_selection(), "HD - 1080p" ); assert_str_eq!(radarr_data.edit_path.text, "/nfs/movies/Test"); assert_eq!(radarr_data.edit_monitored, Some(true)); assert_eq!(radarr_data.edit_search_on_add, Some(true)); } #[test] fn test_radarr_data_defaults() { let radarr_data = RadarrData::default(); assert!(radarr_data.root_folders.items.is_empty()); assert_eq!(radarr_data.disk_space_vec, Vec::new()); assert!(radarr_data.version.is_empty()); assert_eq!(radarr_data.start_time, >::default()); assert!(radarr_data.movies.items.is_empty()); assert!(radarr_data.add_searched_movies.items.is_empty()); assert!(radarr_data.monitor_list.items.is_empty()); assert!(radarr_data.minimum_availability_list.items.is_empty()); assert!(radarr_data.quality_profile_list.items.is_empty()); assert!(radarr_data.root_folder_list.items.is_empty()); assert_eq!( radarr_data.selected_block, ActiveRadarrBlock::AddMovieSelectRootFolder ); assert!(radarr_data.filtered_movies.items.is_empty()); assert!(radarr_data.downloads.items.is_empty()); assert!(radarr_data.quality_profile_map.is_empty()); assert!(radarr_data.tags_map.is_empty()); assert!(radarr_data.file_details.is_empty()); assert!(radarr_data.audio_details.is_empty()); assert!(radarr_data.video_details.is_empty()); assert!(radarr_data.movie_details.get_text().is_empty()); assert!(radarr_data.movie_history.items.is_empty()); assert!(radarr_data.movie_cast.items.is_empty()); assert!(radarr_data.movie_crew.items.is_empty()); assert!(radarr_data.movie_releases.items.is_empty()); assert!(radarr_data.movie_releases_sort.items.is_empty()); assert!(radarr_data.collections.items.is_empty()); assert!(radarr_data.filtered_collections.items.is_empty()); assert!(radarr_data.collection_movies.items.is_empty()); assert!(radarr_data.prompt_confirm_action.is_none()); assert!(radarr_data.search.text.is_empty()); assert!(radarr_data.filter.text.is_empty()); assert!(radarr_data.edit_path.text.is_empty()); assert!(radarr_data.edit_tags.text.is_empty()); assert!(radarr_data.edit_monitored.is_none()); assert!(radarr_data.edit_search_on_add.is_none()); assert!(radarr_data.sort_ascending.is_none()); assert!(!radarr_data.is_searching); assert!(!radarr_data.is_filtering); assert!(!radarr_data.prompt_confirm); assert_eq!(radarr_data.main_tabs.tabs.len(), 4); assert_str_eq!(radarr_data.main_tabs.tabs[0].title, "Library"); assert_eq!( radarr_data.main_tabs.tabs[0].route, ActiveRadarrBlock::Movies.into() ); assert!(radarr_data.main_tabs.tabs[0].help.is_empty()); assert_eq!(radarr_data.main_tabs.tabs[0].contextual_help, Some(" add | edit | delete | search | filter | refresh | update all | details | cancel filter".to_owned())); assert_str_eq!(radarr_data.main_tabs.tabs[1].title, "Downloads"); assert_eq!( radarr_data.main_tabs.tabs[1].route, ActiveRadarrBlock::Downloads.into() ); assert!(radarr_data.main_tabs.tabs[1].help.is_empty()); assert_eq!( radarr_data.main_tabs.tabs[1].contextual_help, Some(" refresh | delete".to_owned()) ); assert_str_eq!(radarr_data.main_tabs.tabs[2].title, "Collections"); assert_eq!( radarr_data.main_tabs.tabs[2].route, ActiveRadarrBlock::Collections.into() ); assert!(radarr_data.main_tabs.tabs[2].help.is_empty()); assert_eq!(radarr_data.main_tabs.tabs[2].contextual_help, Some(" search | edit | filter | refresh | update all | details | cancel filter".to_owned())); assert_str_eq!(radarr_data.main_tabs.tabs[3].title, "Root Folders"); assert_eq!( radarr_data.main_tabs.tabs[3].route, ActiveRadarrBlock::RootFolders.into() ); assert!(radarr_data.main_tabs.tabs[3].help.is_empty()); assert_eq!( radarr_data.main_tabs.tabs[3].contextual_help, Some(" add | delete | refresh".to_owned()) ); assert_eq!(radarr_data.movie_info_tabs.tabs.len(), 6); assert_str_eq!(radarr_data.movie_info_tabs.tabs[0].title, "Details"); assert_eq!( radarr_data.movie_info_tabs.tabs[0].route, ActiveRadarrBlock::MovieDetails.into() ); assert_str_eq!( radarr_data.movie_info_tabs.tabs[0].help, " refresh | update | edit | auto search | close" ); assert!(radarr_data.movie_info_tabs.tabs[0] .contextual_help .is_none()); assert_str_eq!(radarr_data.movie_info_tabs.tabs[1].title, "History"); assert_eq!( radarr_data.movie_info_tabs.tabs[1].route, ActiveRadarrBlock::MovieHistory.into() ); assert_str_eq!( radarr_data.movie_info_tabs.tabs[1].help, " refresh | update | edit | auto search | close" ); assert!(radarr_data.movie_info_tabs.tabs[1] .contextual_help .is_none()); assert_str_eq!(radarr_data.movie_info_tabs.tabs[2].title, "File"); assert_eq!( radarr_data.movie_info_tabs.tabs[2].route, ActiveRadarrBlock::FileInfo.into() ); assert_str_eq!( radarr_data.movie_info_tabs.tabs[2].help, " refresh | update | edit | auto search | close" ); assert!(radarr_data.movie_info_tabs.tabs[2] .contextual_help .is_none()); assert_str_eq!(radarr_data.movie_info_tabs.tabs[3].title, "Cast"); assert_eq!( radarr_data.movie_info_tabs.tabs[3].route, ActiveRadarrBlock::Cast.into() ); assert_str_eq!( radarr_data.movie_info_tabs.tabs[3].help, " refresh | update | edit | auto search | close" ); assert!(radarr_data.movie_info_tabs.tabs[3] .contextual_help .is_none()); assert_str_eq!(radarr_data.movie_info_tabs.tabs[4].title, "Crew"); assert_eq!( radarr_data.movie_info_tabs.tabs[4].route, ActiveRadarrBlock::Crew.into() ); assert_str_eq!( radarr_data.movie_info_tabs.tabs[4].help, " refresh | update | edit | auto search | close" ); assert!(radarr_data.movie_info_tabs.tabs[4] .contextual_help .is_none()); assert_str_eq!(radarr_data.movie_info_tabs.tabs[5].title, "Manual Search"); assert_eq!( radarr_data.movie_info_tabs.tabs[5].route, ActiveRadarrBlock::ManualSearch.into() ); assert_str_eq!( radarr_data.movie_info_tabs.tabs[5].help, " refresh | update | edit | sort | auto search | close" ); assert_eq!( radarr_data.movie_info_tabs.tabs[5].contextual_help, Some(" details".to_owned()) ); } } mod active_radarr_block_tests { use pretty_assertions::assert_eq; use crate::app::radarr::ActiveRadarrBlock; #[test] fn test_next_add_movie_prompt_block() { let active_block = ActiveRadarrBlock::AddMovieSelectRootFolder.next_add_movie_prompt_block(); assert_eq!(active_block, ActiveRadarrBlock::AddMovieSelectMonitor); let active_block = active_block.next_add_movie_prompt_block(); assert_eq!( active_block, ActiveRadarrBlock::AddMovieSelectMinimumAvailability ); let active_block = active_block.next_add_movie_prompt_block(); assert_eq!( active_block, ActiveRadarrBlock::AddMovieSelectQualityProfile ); let active_block = active_block.next_add_movie_prompt_block(); assert_eq!(active_block, ActiveRadarrBlock::AddMovieTagsInput); let active_block = active_block.next_add_movie_prompt_block(); assert_eq!(active_block, ActiveRadarrBlock::AddMovieConfirmPrompt); let active_block = active_block.next_add_movie_prompt_block(); assert_eq!(active_block, ActiveRadarrBlock::AddMovieSelectRootFolder); } #[test] fn test_next_edit_movie_prompt_block() { let active_block = ActiveRadarrBlock::EditMovieToggleMonitored.next_edit_movie_prompt_block(); assert_eq!( active_block, ActiveRadarrBlock::EditMovieSelectMinimumAvailability ); let active_block = active_block.next_edit_movie_prompt_block(); assert_eq!( active_block, ActiveRadarrBlock::EditMovieSelectQualityProfile ); let active_block = active_block.next_edit_movie_prompt_block(); assert_eq!(active_block, ActiveRadarrBlock::EditMoviePathInput); let active_block = active_block.next_edit_movie_prompt_block(); assert_eq!(active_block, ActiveRadarrBlock::EditMovieTagsInput); let active_block = active_block.next_edit_movie_prompt_block(); assert_eq!(active_block, ActiveRadarrBlock::EditMovieConfirmPrompt); let active_block = active_block.next_edit_movie_prompt_block(); assert_eq!(active_block, ActiveRadarrBlock::EditMovieToggleMonitored); } #[test] fn test_next_edit_collection_prompt_block() { let active_block = ActiveRadarrBlock::EditCollectionToggleMonitored.next_edit_collection_prompt_block(); assert_eq!( active_block, ActiveRadarrBlock::EditCollectionSelectMinimumAvailability ); let active_block = active_block.next_edit_collection_prompt_block(); assert_eq!( active_block, ActiveRadarrBlock::EditCollectionSelectQualityProfile ); let active_block = active_block.next_edit_collection_prompt_block(); assert_eq!( active_block, ActiveRadarrBlock::EditCollectionRootFolderPathInput ); let active_block = active_block.next_edit_collection_prompt_block(); assert_eq!( active_block, ActiveRadarrBlock::EditCollectionToggleSearchOnAdd ); let active_block = active_block.next_edit_collection_prompt_block(); assert_eq!(active_block, ActiveRadarrBlock::EditCollectionConfirmPrompt); let active_block = active_block.next_edit_collection_prompt_block(); assert_eq!( active_block, ActiveRadarrBlock::EditCollectionToggleMonitored ); } #[test] fn test_previous_add_movie_prompt_block() { let active_block = ActiveRadarrBlock::AddMovieSelectRootFolder.previous_add_movie_prompt_block(); assert_eq!(active_block, ActiveRadarrBlock::AddMovieConfirmPrompt); let active_block = active_block.previous_add_movie_prompt_block(); assert_eq!(active_block, ActiveRadarrBlock::AddMovieTagsInput); let active_block = active_block.previous_add_movie_prompt_block(); assert_eq!( active_block, ActiveRadarrBlock::AddMovieSelectQualityProfile ); let active_block = active_block.previous_add_movie_prompt_block(); assert_eq!( active_block, ActiveRadarrBlock::AddMovieSelectMinimumAvailability ); let active_block = active_block.previous_add_movie_prompt_block(); assert_eq!(active_block, ActiveRadarrBlock::AddMovieSelectMonitor); let active_block = active_block.previous_add_movie_prompt_block(); assert_eq!(active_block, ActiveRadarrBlock::AddMovieSelectRootFolder); } #[test] fn test_previous_edit_movie_prompt_block() { let active_block = ActiveRadarrBlock::EditMovieToggleMonitored.previous_edit_movie_prompt_block(); assert_eq!(active_block, ActiveRadarrBlock::EditMovieConfirmPrompt); let active_block = active_block.previous_edit_movie_prompt_block(); assert_eq!(active_block, ActiveRadarrBlock::EditMovieTagsInput); let active_block = active_block.previous_edit_movie_prompt_block(); assert_eq!(active_block, ActiveRadarrBlock::EditMoviePathInput); let active_block = active_block.previous_edit_movie_prompt_block(); assert_eq!( active_block, ActiveRadarrBlock::EditMovieSelectQualityProfile ); let active_block = active_block.previous_edit_movie_prompt_block(); assert_eq!( active_block, ActiveRadarrBlock::EditMovieSelectMinimumAvailability ); let active_block = active_block.previous_edit_movie_prompt_block(); assert_eq!(active_block, ActiveRadarrBlock::EditMovieToggleMonitored); } #[test] fn test_previous_edit_collection_prompt_block() { let active_block = ActiveRadarrBlock::EditCollectionToggleMonitored.previous_edit_collection_prompt_block(); assert_eq!(active_block, ActiveRadarrBlock::EditCollectionConfirmPrompt); let active_block = active_block.previous_edit_collection_prompt_block(); assert_eq!( active_block, ActiveRadarrBlock::EditCollectionToggleSearchOnAdd ); let active_block = active_block.previous_edit_collection_prompt_block(); assert_eq!( active_block, ActiveRadarrBlock::EditCollectionRootFolderPathInput ); let active_block = active_block.previous_edit_collection_prompt_block(); assert_eq!( active_block, ActiveRadarrBlock::EditCollectionSelectQualityProfile ); let active_block = active_block.previous_edit_collection_prompt_block(); assert_eq!( active_block, ActiveRadarrBlock::EditCollectionSelectMinimumAvailability ); let active_block = active_block.previous_edit_collection_prompt_block(); assert_eq!( active_block, ActiveRadarrBlock::EditCollectionToggleMonitored ); } } mod radarr_tests { use pretty_assertions::assert_eq; use tokio::sync::mpsc; use crate::app::radarr::ActiveRadarrBlock; use crate::app::App; use crate::models::radarr_models::{Collection, CollectionMovie, Credit, Release}; use crate::models::StatefulTable; use crate::network::radarr_network::RadarrEvent; use crate::network::NetworkEvent; #[tokio::test] async fn test_dispatch_by_collections_block() { let (mut app, mut sync_network_rx) = construct_app_unit(); app .dispatch_by_radarr_block(&ActiveRadarrBlock::Collections) .await; assert!(app.is_loading); assert_eq!( sync_network_rx.recv().await.unwrap(), RadarrEvent::GetCollections.into() ); assert!(!app.data.radarr_data.prompt_confirm); assert_eq!(app.tick_count, 0); } #[tokio::test] async fn test_dispatch_by_collection_details_block() { let (mut app, _) = construct_app_unit(); app.data.radarr_data.collections.set_items(vec![Collection { movies: Some(vec![CollectionMovie::default()]), ..Collection::default() }]); app .dispatch_by_radarr_block(&ActiveRadarrBlock::CollectionDetails) .await; assert!(!app.is_loading); assert!(!app.data.radarr_data.collection_movies.items.is_empty()); assert_eq!(app.tick_count, 0); assert!(!app.data.radarr_data.prompt_confirm); } #[tokio::test] async fn test_dispatch_by_collection_details_block_with_add_movie() { let (mut app, mut sync_network_rx) = construct_app_unit(); app.data.radarr_data.prompt_confirm_action = Some(RadarrEvent::AddMovie); app.data.radarr_data.collections.set_items(vec![Collection { movies: Some(vec![CollectionMovie::default()]), ..Collection::default() }]); app .dispatch_by_radarr_block(&ActiveRadarrBlock::CollectionDetails) .await; assert!(app.is_loading); assert_eq!( sync_network_rx.recv().await.unwrap(), RadarrEvent::AddMovie.into() ); assert!(!app.data.radarr_data.collection_movies.items.is_empty()); assert_eq!(app.tick_count, 0); assert!(!app.data.radarr_data.prompt_confirm); } #[tokio::test] async fn test_dispatch_by_downloads_block() { let (mut app, mut sync_network_rx) = construct_app_unit(); app .dispatch_by_radarr_block(&ActiveRadarrBlock::Downloads) .await; assert!(app.is_loading); assert_eq!( sync_network_rx.recv().await.unwrap(), RadarrEvent::GetDownloads.into() ); assert!(!app.data.radarr_data.prompt_confirm); assert_eq!(app.tick_count, 0); } #[tokio::test] async fn test_dispatch_by_root_folders_block() { let (mut app, mut sync_network_rx) = construct_app_unit(); app .dispatch_by_radarr_block(&ActiveRadarrBlock::RootFolders) .await; assert!(app.is_loading); assert_eq!( sync_network_rx.recv().await.unwrap(), RadarrEvent::GetRootFolders.into() ); assert!(!app.data.radarr_data.prompt_confirm); assert_eq!(app.tick_count, 0); } #[tokio::test] async fn test_dispatch_by_movies_block() { let (mut app, mut sync_network_rx) = construct_app_unit(); app .dispatch_by_radarr_block(&ActiveRadarrBlock::Movies) .await; assert!(app.is_loading); assert_eq!( sync_network_rx.recv().await.unwrap(), RadarrEvent::GetMovies.into() ); assert_eq!( sync_network_rx.recv().await.unwrap(), RadarrEvent::GetDownloads.into() ); assert!(!app.data.radarr_data.prompt_confirm); assert_eq!(app.tick_count, 0); } #[tokio::test] async fn test_dispatch_by_add_movie_search_results_block() { let (mut app, mut sync_network_rx) = construct_app_unit(); app .dispatch_by_radarr_block(&ActiveRadarrBlock::AddMovieSearchResults) .await; assert!(app.is_loading); assert_eq!( sync_network_rx.recv().await.unwrap(), RadarrEvent::SearchNewMovie.into() ); assert!(!app.data.radarr_data.prompt_confirm); assert_eq!(app.tick_count, 0); } #[tokio::test] async fn test_dispatch_by_movie_details_block() { let (mut app, mut sync_network_rx) = construct_app_unit(); app .dispatch_by_radarr_block(&ActiveRadarrBlock::MovieDetails) .await; assert!(app.is_loading); assert_eq!( sync_network_rx.recv().await.unwrap(), RadarrEvent::GetMovieDetails.into() ); assert!(!app.data.radarr_data.prompt_confirm); assert_eq!(app.tick_count, 0); } #[tokio::test] async fn test_dispatch_by_file_info_block() { let (mut app, mut sync_network_rx) = construct_app_unit(); app .dispatch_by_radarr_block(&ActiveRadarrBlock::FileInfo) .await; assert!(app.is_loading); assert_eq!( sync_network_rx.recv().await.unwrap(), RadarrEvent::GetMovieDetails.into() ); assert!(!app.data.radarr_data.prompt_confirm); assert_eq!(app.tick_count, 0); } #[tokio::test] async fn test_dispatch_by_movie_history_block() { let (mut app, mut sync_network_rx) = construct_app_unit(); app .dispatch_by_radarr_block(&ActiveRadarrBlock::MovieHistory) .await; assert!(app.is_loading); assert_eq!( sync_network_rx.recv().await.unwrap(), RadarrEvent::GetMovieHistory.into() ); assert!(!app.data.radarr_data.prompt_confirm); assert_eq!(app.tick_count, 0); } #[tokio::test] async fn test_dispatch_by_cast_crew_blocks() { let (mut app, mut sync_network_rx) = construct_app_unit(); for active_radarr_block in &[ActiveRadarrBlock::Cast, ActiveRadarrBlock::Crew] { app.data.radarr_data.movie_cast = StatefulTable::default(); app.data.radarr_data.movie_crew = StatefulTable::default(); app.dispatch_by_radarr_block(active_radarr_block).await; assert!(app.is_loading); assert_eq!( sync_network_rx.recv().await.unwrap(), RadarrEvent::GetMovieCredits.into() ); assert!(!app.data.radarr_data.prompt_confirm); assert_eq!(app.tick_count, 0); } } #[tokio::test] async fn test_dispatch_by_cast_crew_blocks_movie_cast_non_empty() { let (mut app, mut sync_network_rx) = construct_app_unit(); for active_radarr_block in &[ActiveRadarrBlock::Cast, ActiveRadarrBlock::Crew] { app .data .radarr_data .movie_cast .set_items(vec![Credit::default()]); app.dispatch_by_radarr_block(active_radarr_block).await; assert!(app.is_loading); assert_eq!( sync_network_rx.recv().await.unwrap(), RadarrEvent::GetMovieCredits.into() ); assert!(!app.data.radarr_data.prompt_confirm); assert_eq!(app.tick_count, 0); } } #[tokio::test] async fn test_dispatch_by_cast_crew_blocks_movie_crew_non_empty() { let (mut app, mut sync_network_rx) = construct_app_unit(); for active_radarr_block in &[ActiveRadarrBlock::Cast, ActiveRadarrBlock::Crew] { app .data .radarr_data .movie_crew .set_items(vec![Credit::default()]); app.dispatch_by_radarr_block(active_radarr_block).await; assert!(app.is_loading); assert_eq!( sync_network_rx.recv().await.unwrap(), RadarrEvent::GetMovieCredits.into() ); assert!(!app.data.radarr_data.prompt_confirm); assert_eq!(app.tick_count, 0); } } #[tokio::test] async fn test_dispatch_by_cast_crew_blocks_cast_and_crew_non_empty() { let mut app = App::default(); for active_radarr_block in &[ActiveRadarrBlock::Cast, ActiveRadarrBlock::Crew] { app .data .radarr_data .movie_cast .set_items(vec![Credit::default()]); app .data .radarr_data .movie_crew .set_items(vec![Credit::default()]); app.dispatch_by_radarr_block(active_radarr_block).await; assert!(!app.is_loading); assert!(!app.data.radarr_data.prompt_confirm); assert_eq!(app.tick_count, 0); } } #[tokio::test] async fn test_dispatch_by_manual_search_block() { let (mut app, mut sync_network_rx) = construct_app_unit(); app .dispatch_by_radarr_block(&ActiveRadarrBlock::ManualSearch) .await; assert!(app.is_loading); assert_eq!( sync_network_rx.recv().await.unwrap(), RadarrEvent::GetReleases.into() ); assert!(!app.data.radarr_data.prompt_confirm); assert_eq!(app.tick_count, 0); } #[tokio::test] async fn test_dispatch_by_manual_search_block_movie_releases_non_empty() { let mut app = App::default(); app .data .radarr_data .movie_releases .set_items(vec![Release::default()]); app .dispatch_by_radarr_block(&ActiveRadarrBlock::ManualSearch) .await; assert!(!app.is_loading); assert!(!app.data.radarr_data.prompt_confirm); assert_eq!(app.tick_count, 0); } #[tokio::test] async fn test_dispatch_by_manual_search_block_is_loading() { let mut app = App { is_loading: true, ..App::default() }; app .dispatch_by_radarr_block(&ActiveRadarrBlock::ManualSearch) .await; assert!(app.is_loading); assert!(!app.data.radarr_data.prompt_confirm); assert_eq!(app.tick_count, 0); } #[tokio::test] async fn test_check_for_prompt_action_no_prompt_confirm() { let mut app = App::default(); app.data.radarr_data.prompt_confirm = false; app.check_for_prompt_action().await; assert!(!app.data.radarr_data.prompt_confirm); assert!(!app.should_refresh); } #[tokio::test] async fn test_check_for_prompt_action() { let (mut app, mut sync_network_rx) = construct_app_unit(); app.data.radarr_data.prompt_confirm_action = Some(RadarrEvent::GetStatus); app.check_for_prompt_action().await; assert!(!app.data.radarr_data.prompt_confirm); assert_eq!( sync_network_rx.recv().await.unwrap(), RadarrEvent::GetStatus.into() ); assert!(app.should_refresh); assert_eq!(app.data.radarr_data.prompt_confirm_action, None); } #[tokio::test] async fn test_radarr_refresh_metadata() { let (mut app, mut sync_network_rx) = construct_app_unit(); app.is_routing = true; app.refresh_metadata().await; assert_eq!( sync_network_rx.recv().await.unwrap(), RadarrEvent::GetQualityProfiles.into() ); assert_eq!( sync_network_rx.recv().await.unwrap(), RadarrEvent::GetTags.into() ); assert!(app.is_loading); } #[tokio::test] async fn test_radarr_on_tick_first_render() { let (mut app, mut sync_network_rx) = construct_app_unit(); app.radarr_on_tick(ActiveRadarrBlock::Downloads, true).await; assert_eq!( sync_network_rx.recv().await.unwrap(), RadarrEvent::GetQualityProfiles.into() ); assert_eq!( sync_network_rx.recv().await.unwrap(), RadarrEvent::GetTags.into() ); assert_eq!( sync_network_rx.recv().await.unwrap(), RadarrEvent::GetRootFolders.into() ); assert_eq!( sync_network_rx.recv().await.unwrap(), RadarrEvent::GetOverview.into() ); assert_eq!( sync_network_rx.recv().await.unwrap(), RadarrEvent::GetStatus.into() ); assert_eq!( sync_network_rx.recv().await.unwrap(), RadarrEvent::GetDownloads.into() ); assert!(app.is_loading); assert!(!app.data.radarr_data.prompt_confirm); } #[tokio::test] async fn test_radarr_on_tick_not_routing() { let mut app = App::default(); app .radarr_on_tick(ActiveRadarrBlock::Downloads, false) .await; assert!(!app.is_routing); } #[tokio::test] async fn test_radarr_on_tick_routing() { let (mut app, mut sync_network_rx) = construct_app_unit(); app.is_routing = true; app .radarr_on_tick(ActiveRadarrBlock::Downloads, false) .await; assert_eq!( sync_network_rx.recv().await.unwrap(), RadarrEvent::GetDownloads.into() ); assert_eq!( sync_network_rx.recv().await.unwrap(), RadarrEvent::GetQualityProfiles.into() ); assert_eq!( sync_network_rx.recv().await.unwrap(), RadarrEvent::GetTags.into() ); assert_eq!( sync_network_rx.recv().await.unwrap(), RadarrEvent::GetDownloads.into() ); assert!(app.is_loading); assert!(!app.data.radarr_data.prompt_confirm); } #[tokio::test] async fn test_radarr_on_tick_should_refresh() { let (mut app, mut sync_network_rx) = construct_app_unit(); app.should_refresh = true; app .radarr_on_tick(ActiveRadarrBlock::Downloads, false) .await; assert_eq!( sync_network_rx.recv().await.unwrap(), RadarrEvent::GetDownloads.into() ); assert!(app.is_loading); assert!(app.should_refresh); assert!(!app.data.radarr_data.prompt_confirm); } #[tokio::test] async fn test_radarr_on_tick_network_tick_frequency() { let (mut app, mut sync_network_rx) = construct_app_unit(); app.tick_count = 2; app.tick_until_poll = 2; app .radarr_on_tick(ActiveRadarrBlock::Downloads, false) .await; assert_eq!( sync_network_rx.recv().await.unwrap(), RadarrEvent::GetDownloads.into() ); assert_eq!( sync_network_rx.recv().await.unwrap(), RadarrEvent::GetQualityProfiles.into() ); assert_eq!( sync_network_rx.recv().await.unwrap(), RadarrEvent::GetTags.into() ); assert_eq!( sync_network_rx.recv().await.unwrap(), RadarrEvent::GetDownloads.into() ); assert!(app.is_loading); assert!(!app.data.radarr_data.prompt_confirm); } #[tokio::test] async fn test_populate_movie_collection_table_unfiltered() { let mut app = App::default(); app.data.radarr_data.collections.set_items(vec![Collection { movies: Some(vec![CollectionMovie::default()]), ..Collection::default() }]); app.populate_movie_collection_table().await; assert!(!app.data.radarr_data.collection_movies.items.is_empty()); } #[tokio::test] async fn test_populate_movie_collection_table_filtered() { let mut app = App::default(); app .data .radarr_data .filtered_collections .set_items(vec![Collection { movies: Some(vec![CollectionMovie::default()]), ..Collection::default() }]); app.populate_movie_collection_table().await; assert!(!app.data.radarr_data.collection_movies.items.is_empty()); } fn construct_app_unit() -> (App, mpsc::Receiver) { let (sync_network_tx, sync_network_rx) = mpsc::channel::(500); let mut app = App { network_tx: Some(sync_network_tx), tick_count: 1, ..App::default() }; app.data.radarr_data.prompt_confirm = true; (app, sync_network_rx) } } }