From 4962f3d5c37e4c97ec7cffd905255ced3648301c Mon Sep 17 00:00:00 2001 From: Dark-Alex-17 Date: Tue, 8 Aug 2023 10:50:05 -0600 Subject: [PATCH] Added tests for models --- src/app/radarr.rs | 896 +++++++++++++-------------- src/models/mod.rs | 403 +++++++++++- src/ui/radarr_ui/movie_details_ui.rs | 2 +- 3 files changed, 841 insertions(+), 460 deletions(-) diff --git a/src/app/radarr.rs b/src/app/radarr.rs index 4575bf9..c2a3afd 100644 --- a/src/app/radarr.rs +++ b/src/app/radarr.rs @@ -496,543 +496,543 @@ pub mod radarr_test_utils { } } -#[cfg(test)] -mod radarr_data_tests { - use pretty_assertions::assert_eq; - - use crate::app::radarr::radarr_test_utils::create_test_radarr_data; - - #[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_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_movie_selections() { - let mut radarr_data = create_test_radarr_data(); - - radarr_data.reset_add_movie_selections(); - - assert_add_movie_selections_reset!(radarr_data); - } -} - -#[cfg(test)] -mod active_radarr_block_tests { - use pretty_assertions::assert_eq; - - use crate::app::radarr::ActiveRadarrBlock; - - #[test] - fn test_next_add_prompt_block() { - let active_block = ActiveRadarrBlock::AddMovieSelectMonitor.next_add_prompt_block(); - - assert_eq!( - active_block, - ActiveRadarrBlock::AddMovieSelectMinimumAvailability - ); - - let active_block = active_block.next_add_prompt_block(); - - assert_eq!( - active_block, - ActiveRadarrBlock::AddMovieSelectQualityProfile - ); - - let active_block = active_block.next_add_prompt_block(); - - assert_eq!(active_block, ActiveRadarrBlock::AddMovieConfirmPrompt); - - let active_block = active_block.next_add_prompt_block(); - - assert_eq!(active_block, ActiveRadarrBlock::AddMovieSelectMonitor); - } - - #[test] - fn test_previous_add_prompt_block() { - let active_block = ActiveRadarrBlock::AddMovieSelectMonitor.previous_add_prompt_block(); - - assert_eq!(active_block, ActiveRadarrBlock::AddMovieConfirmPrompt); - - let active_block = active_block.previous_add_prompt_block(); - - assert_eq!( - active_block, - ActiveRadarrBlock::AddMovieSelectQualityProfile - ); - - let active_block = active_block.previous_add_prompt_block(); - - assert_eq!( - active_block, - ActiveRadarrBlock::AddMovieSelectMinimumAvailability - ); - - let active_block = active_block.previous_add_prompt_block(); - - assert_eq!(active_block, ActiveRadarrBlock::AddMovieSelectMonitor); - } -} - #[cfg(test)] mod tests { - use std::time::Duration; + mod radarr_data_tests { + use pretty_assertions::assert_eq; - use pretty_assertions::assert_eq; - use tokio::sync::mpsc; + use crate::app::radarr::radarr_test_utils::create_test_radarr_data; - 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; + #[test] + fn test_reset_movie_collection_table() { + let mut radarr_data = create_test_radarr_data(); - #[tokio::test] - async fn test_dispatch_by_collections_block() { - let (mut app, mut sync_network_rx) = construct_app_unit(); + radarr_data.reset_movie_collection_table(); - app - .dispatch_by_radarr_block(&ActiveRadarrBlock::Collections) - .await; + assert_movie_collection_table_reset!(radarr_data); + } - 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); + #[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_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_movie_selections() { + let mut radarr_data = create_test_radarr_data(); + + radarr_data.reset_add_movie_selections(); + + assert_add_movie_selections_reset!(radarr_data); + } } - #[tokio::test] - async fn test_dispatch_by_collection_details_block() { - let mut app = App::default(); + mod active_radarr_block_tests { + use pretty_assertions::assert_eq; - app.data.radarr_data.collections.set_items(vec![Collection { - movies: Some(vec![CollectionMovie::default()]), - ..Collection::default() - }]); + use crate::app::radarr::ActiveRadarrBlock; - app - .dispatch_by_radarr_block(&ActiveRadarrBlock::CollectionDetails) - .await; + #[test] + fn test_next_add_prompt_block() { + let active_block = ActiveRadarrBlock::AddMovieSelectMonitor.next_add_prompt_block(); - assert!(!app.is_loading); - assert!(!app.data.radarr_data.collection_movies.items.is_empty()); - assert_eq!(app.tick_count, 0); + assert_eq!( + active_block, + ActiveRadarrBlock::AddMovieSelectMinimumAvailability + ); + + let active_block = active_block.next_add_prompt_block(); + + assert_eq!( + active_block, + ActiveRadarrBlock::AddMovieSelectQualityProfile + ); + + let active_block = active_block.next_add_prompt_block(); + + assert_eq!(active_block, ActiveRadarrBlock::AddMovieConfirmPrompt); + + let active_block = active_block.next_add_prompt_block(); + + assert_eq!(active_block, ActiveRadarrBlock::AddMovieSelectMonitor); + } + + #[test] + fn test_previous_add_prompt_block() { + let active_block = ActiveRadarrBlock::AddMovieSelectMonitor.previous_add_prompt_block(); + + assert_eq!(active_block, ActiveRadarrBlock::AddMovieConfirmPrompt); + + let active_block = active_block.previous_add_prompt_block(); + + assert_eq!( + active_block, + ActiveRadarrBlock::AddMovieSelectQualityProfile + ); + + let active_block = active_block.previous_add_prompt_block(); + + assert_eq!( + active_block, + ActiveRadarrBlock::AddMovieSelectMinimumAvailability + ); + + let active_block = active_block.previous_add_prompt_block(); + + assert_eq!(active_block, ActiveRadarrBlock::AddMovieSelectMonitor); + } } - #[tokio::test] - async fn test_dispatch_by_downloads_block() { - let (mut app, mut sync_network_rx) = construct_app_unit(); + mod radarr_tests { + use std::time::Duration; - app - .dispatch_by_radarr_block(&ActiveRadarrBlock::Downloads) - .await; + use pretty_assertions::assert_eq; + use tokio::sync::mpsc; - 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); - } + 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_movies_block() { - let (mut app, mut sync_network_rx) = construct_app_unit(); + #[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::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; + app + .dispatch_by_radarr_block(&ActiveRadarrBlock::Collections) + .await; assert!(app.is_loading); assert_eq!( sync_network_rx.recv().await.unwrap(), - RadarrEvent::GetMovieCredits.into() + RadarrEvent::GetCollections.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(); + #[tokio::test] + async fn test_dispatch_by_collection_details_block() { + let mut app = App::default(); + + app.data.radarr_data.collections.set_items(vec![Collection { + movies: Some(vec![CollectionMovie::default()]), + ..Collection::default() + }]); - for active_radarr_block in &[ActiveRadarrBlock::Cast, ActiveRadarrBlock::Crew] { app - .data - .radarr_data - .movie_cast - .set_items(vec![Credit::default()]); + .dispatch_by_radarr_block(&ActiveRadarrBlock::CollectionDetails) + .await; - app.dispatch_by_radarr_block(active_radarr_block).await; + assert!(!app.is_loading); + assert!(!app.data.radarr_data.collection_movies.items.is_empty()); + assert_eq!(app.tick_count, 0); + } + + #[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::GetMovieCredits.into() + RadarrEvent::GetDownloads.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(); + #[tokio::test] + async fn test_dispatch_by_movies_block() { + 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()]); + .dispatch_by_radarr_block(&ActiveRadarrBlock::Movies) + .await; - app.dispatch_by_radarr_block(active_radarr_block).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::GetMovieCredits.into() + RadarrEvent::SearchNewMovie.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(); + #[tokio::test] + async fn test_dispatch_by_movie_details_block() { + let (mut app, mut sync_network_rx) = construct_app_unit(); - for active_radarr_block in &[ActiveRadarrBlock::Cast, ActiveRadarrBlock::Crew] { + 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_cast - .set_items(vec![Credit::default()]); - app - .data - .radarr_data - .movie_crew - .set_items(vec![Credit::default()]); + .movie_releases + .set_items(vec![Release::default()]); - app.dispatch_by_radarr_block(active_radarr_block).await; + 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() { - let (mut app, mut sync_network_rx) = construct_app_unit(); + #[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; + 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); - } + 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_movie_releases_non_empty() { - let mut app = App::default(); - app - .data - .radarr_data - .movie_releases - .set_items(vec![Release::default()]); + #[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 - .dispatch_by_radarr_block(&ActiveRadarrBlock::ManualSearch) - .await; + app.check_for_prompt_action().await; - assert!(!app.is_loading); - assert!(!app.data.radarr_data.prompt_confirm); - assert_eq!(app.tick_count, 0); - } + assert!(!app.data.radarr_data.prompt_confirm); + assert!(!app.should_refresh); + } - #[tokio::test] - async fn test_dispatch_by_manual_search_block_is_loading() { - let mut app = App { - is_loading: true, - ..App::default() - }; + #[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 - .dispatch_by_radarr_block(&ActiveRadarrBlock::ManualSearch) - .await; + app.check_for_prompt_action().await; - assert!(app.is_loading); - assert!(!app.data.radarr_data.prompt_confirm); - assert_eq!(app.tick_count, 0); - } + 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_check_for_prompt_action_no_prompt_confirm() { - let mut app = App::default(); - app.data.radarr_data.prompt_confirm = false; + #[tokio::test] + async fn test_radarr_on_tick_first_render() { + let (mut app, mut sync_network_rx) = construct_app_unit(); - app.check_for_prompt_action().await; + app.radarr_on_tick(ActiveRadarrBlock::Downloads, true).await; - assert!(!app.data.radarr_data.prompt_confirm); - assert!(!app.should_refresh); - } + assert_eq!( + sync_network_rx.recv().await.unwrap(), + RadarrEvent::GetQualityProfiles.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_check_for_prompt_action() { - let (mut app, mut sync_network_rx) = construct_app_unit(); - app.data.radarr_data.prompt_confirm_action = Some(RadarrEvent::GetStatus); + #[tokio::test] + async fn test_radarr_on_tick_not_routing() { + let mut app = App::default(); - app.check_for_prompt_action().await; + app + .radarr_on_tick(ActiveRadarrBlock::Downloads, false) + .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); - } + assert!(!app.is_routing); + } - #[tokio::test] - async fn test_radarr_on_tick_first_render() { - let (mut app, mut sync_network_rx) = construct_app_unit(); + #[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, true).await; + app + .radarr_on_tick(ActiveRadarrBlock::Downloads, false) + .await; - assert_eq!( - sync_network_rx.recv().await.unwrap(), - RadarrEvent::GetQualityProfiles.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); - } + 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(); + #[tokio::test] + async fn test_radarr_on_tick_network_tick_frequency() { + let (mut app, mut sync_network_rx) = construct_app_unit(); + app.network_tick_frequency = Duration::from_secs(0); - app - .radarr_on_tick(ActiveRadarrBlock::Downloads, false) - .await; + app + .radarr_on_tick(ActiveRadarrBlock::Downloads, false) + .await; - assert!(!app.is_routing); - } + 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_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!(app.is_loading); - 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.network_tick_frequency = Duration::from_secs(0); - - 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.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 { + #[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; + app.populate_movie_collection_table().await; - assert!(!app.data.radarr_data.collection_movies.items.is_empty()); - } + 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; + #[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, sync_network_rx) + 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) + } } } diff --git a/src/models/mod.rs b/src/models/mod.rs index bee6116..7220830 100644 --- a/src/models/mod.rs +++ b/src/models/mod.rs @@ -29,20 +29,12 @@ pub trait Scrollable { macro_rules! stateful_iterable { ($name:ident, $state:ty) => { + #[derive(Default)] pub struct $name { pub state: $state, pub items: Vec, } - impl Default for $name { - fn default() -> $name { - $name { - state: <$state>::default(), - items: Vec::new(), - } - } - } - impl Scrollable for $name { fn scroll_down(&mut self) { let selected_row = match self.state.selected() { @@ -147,7 +139,7 @@ impl ScrollableText { impl Scrollable for ScrollableText { fn scroll_down(&mut self) { - if self.offset < self.items.len() as u16 { + if self.offset < (self.items.len() - 1) as u16 { self.offset += 1; } } @@ -228,7 +220,7 @@ impl HorizontallyScrollableText { } } -#[derive(Clone)] +#[derive(Clone, PartialEq, Eq, Debug)] pub struct TabRoute { pub title: String, pub route: Route, @@ -275,3 +267,392 @@ impl TabState { } } } + +#[cfg(test)] +mod tests { + use std::cell::RefCell; + + use pretty_assertions::{assert_eq, assert_str_eq}; + + use crate::app::radarr::ActiveRadarrBlock; + use crate::models::{ + HorizontallyScrollableText, Scrollable, ScrollableText, StatefulTable, TabRoute, TabState, + }; + + #[test] + fn test_stateful_table_scroll() { + let mut stateful_table = create_test_stateful_table(); + + assert_eq!(stateful_table.state.selected(), Some(0)); + + stateful_table.scroll_down(); + + assert_eq!(stateful_table.state.selected(), Some(1)); + + stateful_table.scroll_down(); + + assert_eq!(stateful_table.state.selected(), Some(0)); + + stateful_table.scroll_up(); + + assert_eq!(stateful_table.state.selected(), Some(1)); + + stateful_table.scroll_up(); + + assert_eq!(stateful_table.state.selected(), Some(0)); + + stateful_table.scroll_to_bottom(); + + assert_eq!(stateful_table.state.selected(), Some(1)); + + stateful_table.scroll_to_top(); + + assert_eq!(stateful_table.state.selected(), Some(0)); + } + + #[test] + fn test_stateful_table_set_items() { + let items_vec = vec!["Test 1", "Test 2", "Test 3"]; + let mut stateful_table: StatefulTable<&str> = StatefulTable::default(); + + stateful_table.set_items(items_vec.clone()); + + assert_eq!(stateful_table.state.selected(), Some(0)); + + stateful_table.state.select(Some(1)); + stateful_table.set_items(items_vec.clone()); + + assert_eq!(stateful_table.state.selected(), Some(1)); + + stateful_table.state.select(Some(3)); + stateful_table.set_items(items_vec); + + assert_eq!(stateful_table.state.selected(), Some(2)); + } + + #[test] + fn test_stateful_table_current_selection() { + let mut stateful_table = create_test_stateful_table(); + + assert_str_eq!(stateful_table.current_selection(), &stateful_table.items[0]); + + stateful_table.state.select(Some(1)); + + assert_str_eq!(stateful_table.current_selection(), &stateful_table.items[1]); + } + + #[test] + fn test_stateful_table_current_selection_clone() { + let mut stateful_table = create_test_stateful_table(); + + assert_str_eq!( + stateful_table.current_selection_clone(), + stateful_table.items[0] + ); + + stateful_table.state.select(Some(1)); + + assert_str_eq!( + stateful_table.current_selection_clone(), + stateful_table.items[1] + ); + } + + #[test] + fn test_stateful_table_select_index() { + let mut stateful_table = create_test_stateful_table(); + + assert_eq!(stateful_table.state.selected(), Some(0)); + + stateful_table.select_index(Some(1)); + + assert_eq!(stateful_table.state.selected(), Some(1)); + + stateful_table.select_index(None); + + assert_eq!(stateful_table.state.selected(), None); + } + + #[test] + fn test_stateful_table_scroll_up() { + let mut stateful_table = create_test_stateful_table(); + + assert_eq!(stateful_table.state.selected(), Some(0)); + + stateful_table.scroll_up(); + + assert_eq!(stateful_table.state.selected(), Some(1)); + + stateful_table.scroll_up(); + + assert_eq!(stateful_table.state.selected(), Some(0)); + } + + #[test] + fn test_scrollable_text_with_string() { + let scrollable_text = ScrollableText::with_string("Test \n String \n".to_owned()); + + assert_eq!(scrollable_text.items.len(), 3); + assert_eq!(scrollable_text.items, vec!["Test ", " String ", ""]); + assert_eq!(scrollable_text.offset, 0); + } + + #[test] + fn test_scrollable_text_get_text() { + let test_text = "Test \nString"; + let scrollable_text = ScrollableText::with_string(test_text.to_owned()); + + assert_str_eq!(scrollable_text.get_text(), test_text); + } + + #[test] + fn test_scrollable_text_scroll() { + let mut scrollable_text = ScrollableText::with_string("Test \nString".to_owned()); + + scrollable_text.scroll_down(); + + assert_eq!(scrollable_text.offset, 1); + + scrollable_text.scroll_down(); + + assert_eq!(scrollable_text.offset, 1); + + scrollable_text.scroll_up(); + + assert_eq!(scrollable_text.offset, 0); + + scrollable_text.scroll_up(); + + assert_eq!(scrollable_text.offset, 0); + + scrollable_text.scroll_to_bottom(); + + assert_eq!(scrollable_text.offset, 1); + + scrollable_text.scroll_to_top(); + + assert_eq!(scrollable_text.offset, 0); + } + + #[test] + fn test_horizontally_scrollable_text_from() { + let test_text = "Test string"; + let horizontally_scrollable_text = HorizontallyScrollableText::from(test_text.to_owned()); + + assert_eq!(*horizontally_scrollable_text.offset.borrow(), 0); + assert_str_eq!( + horizontally_scrollable_text.text, + format!("{} ", test_text) + ); + } + + #[test] + fn test_horizontally_scrollable_text_to_string() { + let test_text = "Test string"; + let horizontally_scrollable_text = HorizontallyScrollableText::from(test_text.to_owned()); + + assert_str_eq!( + horizontally_scrollable_text.to_string(), + format!("{} ", test_text) + ); + + let horizontally_scrollable_text = HorizontallyScrollableText { + text: test_text.to_owned(), + offset: RefCell::new(test_text.len() - 1), + }; + + assert_str_eq!(horizontally_scrollable_text.to_string(), "g"); + + let horizontally_scrollable_text = HorizontallyScrollableText { + text: test_text.to_owned(), + offset: RefCell::new(test_text.len()), + }; + + assert!(horizontally_scrollable_text.to_string().is_empty()); + } + + #[test] + fn test_horizontally_scrollable_text_new() { + let test_text = "Test string"; + let horizontally_scrollable_text = HorizontallyScrollableText::new(test_text.to_owned()); + + assert_eq!(*horizontally_scrollable_text.offset.borrow(), 0); + assert_str_eq!( + horizontally_scrollable_text.text, + format!("{} ", test_text) + ); + } + + #[test] + fn test_horizontally_scrollable_text_scroll_text() { + let horizontally_scrollable_text = HorizontallyScrollableText::from("Test string".to_owned()); + + assert_eq!(*horizontally_scrollable_text.offset.borrow(), 0); + + for i in 1..horizontally_scrollable_text.text.len() { + horizontally_scrollable_text.scroll_text(); + + assert_eq!(*horizontally_scrollable_text.offset.borrow(), i); + } + + horizontally_scrollable_text.scroll_text(); + + assert_eq!(*horizontally_scrollable_text.offset.borrow(), 0); + } + + #[test] + fn test_horizontally_scrollable_text_reset_offset() { + let horizontally_scrollable_text = HorizontallyScrollableText { + text: "Test string".to_owned(), + offset: RefCell::new(1), + }; + + horizontally_scrollable_text.reset_offset(); + + assert_eq!(*horizontally_scrollable_text.offset.borrow(), 0); + } + + #[test] + fn test_horizontally_scrollable_text_scroll_or_reset() { + let width = 3; + let test_text = "Test string"; + let horizontally_scrollable_text = HorizontallyScrollableText::from(test_text.to_owned()); + + horizontally_scrollable_text.scroll_or_reset(width, true); + + assert_eq!(*horizontally_scrollable_text.offset.borrow(), 1); + + horizontally_scrollable_text.scroll_or_reset(width, false); + + assert_eq!(*horizontally_scrollable_text.offset.borrow(), 0); + + horizontally_scrollable_text.scroll_or_reset(width, true); + + assert_eq!(*horizontally_scrollable_text.offset.borrow(), 1); + + horizontally_scrollable_text.scroll_or_reset(test_text.len(), false); + + assert_eq!(*horizontally_scrollable_text.offset.borrow(), 0); + } + + #[test] + fn test_horizontally_scrollable_text_stationary_style() { + let test_text = "Test string"; + let horizontally_scrollable_text = HorizontallyScrollableText::from(test_text.to_owned()); + + assert_eq!(horizontally_scrollable_text.stationary_style(), test_text); + } + + #[test] + fn test_tab_state_new() { + let tab_state = TabState::new(create_test_tab_routes()); + + assert_eq!(tab_state.index, 0); + } + + #[test] + fn test_tab_state_set_index() { + let mut tab_state = TabState::new(create_test_tab_routes()); + + let result = tab_state.set_index(1); + + assert_eq!(result, &create_test_tab_routes()[1]); + assert_eq!(tab_state.index, 1); + } + + #[test] + fn test_tab_state_get_active_route() { + let second_tab = create_test_tab_routes()[1].clone().route; + let tab_state = TabState { + tabs: create_test_tab_routes(), + index: 1, + }; + + let active_route = tab_state.get_active_route(); + + assert_eq!(active_route, &second_tab); + } + + #[test] + fn test_tab_state_get_active_tab_help() { + let second_tab_help = create_test_tab_routes()[1].clone().help; + let tab_state = TabState { + tabs: create_test_tab_routes(), + index: 1, + }; + + let tab_help = tab_state.get_active_tab_help(); + + assert_str_eq!(tab_help, second_tab_help); + } + + #[test] + fn test_tab_state_get_active_tab_contextual_help() { + let second_tab_contextual_help = create_test_tab_routes()[1].clone().contextual_help.unwrap(); + let tab_state = TabState { + tabs: create_test_tab_routes(), + index: 1, + }; + + let tab_contextual_help = tab_state.get_active_tab_contextual_help(); + + assert!(tab_contextual_help.is_some()); + assert_str_eq!(tab_contextual_help.unwrap(), second_tab_contextual_help); + } + + #[test] + fn test_tab_state_next() { + let tab_routes = create_test_tab_routes(); + let mut tab_state = TabState::new(create_test_tab_routes()); + + assert_eq!(tab_state.get_active_route(), &tab_routes[0].route); + + tab_state.next(); + + assert_eq!(tab_state.get_active_route(), &tab_routes[1].route); + + tab_state.next(); + + assert_eq!(tab_state.get_active_route(), &tab_routes[0].route); + } + + #[test] + fn test_tab_state_previous() { + let tab_routes = create_test_tab_routes(); + let mut tab_state = TabState::new(create_test_tab_routes()); + + assert_eq!(tab_state.get_active_route(), &tab_routes[0].route); + + tab_state.previous(); + + assert_eq!(tab_state.get_active_route(), &tab_routes[1].route); + + tab_state.previous(); + + assert_eq!(tab_state.get_active_route(), &tab_routes[0].route); + } + + fn create_test_tab_routes() -> Vec { + vec![ + TabRoute { + title: "Test 1".to_owned(), + route: ActiveRadarrBlock::Movies.into(), + help: "Help for Test 1".to_owned(), + contextual_help: Some("Contextual Help for Test 1".to_owned()), + }, + TabRoute { + title: "Test 2".to_owned(), + route: ActiveRadarrBlock::Collections.into(), + help: "Help for Test 2".to_owned(), + contextual_help: Some("Contextual Help for Test 2".to_owned()), + }, + ] + } + + fn create_test_stateful_table() -> StatefulTable<&'static str> { + let mut stateful_table = StatefulTable::default(); + stateful_table.set_items(vec!["Test 1", "Test 2"]); + + stateful_table + } +} diff --git a/src/ui/radarr_ui/movie_details_ui.rs b/src/ui/radarr_ui/movie_details_ui.rs index 5001ef8..2ff0022 100644 --- a/src/ui/radarr_ui/movie_details_ui.rs +++ b/src/ui/radarr_ui/movie_details_ui.rs @@ -399,7 +399,7 @@ fn draw_movie_releases(f: &mut Frame<'_, B>, app: &mut App, content_ ); let size = convert_to_gb(size.as_u64().unwrap()); let rejected_str = if *rejected { "⛔" } else { "" }; - let mut peers = if seeders.is_none() || leechers.is_none() { + let peers = if seeders.is_none() || leechers.is_none() { Text::default() } else { let seeders = seeders.clone().unwrap().as_u64().unwrap();