From e50fb88bfcdc27237877a90794beb5962821810b Mon Sep 17 00:00:00 2001 From: Alex Clarke Date: Wed, 3 Dec 2025 15:23:07 -0700 Subject: [PATCH] refactor: Refactored to use more idiomatic let-else statements where applicable --- .../library/movie_details_handler.rs | 36 +- .../library/episode_details_handler.rs | 34 +- .../library/season_details_handler.rs | 25 +- .../radarr_blocklist_network_tests.rs | 21 +- .../radarr_collections_network_tests.rs | 21 +- .../radarr_downloads_network_tests.rs | 19 +- .../indexers/radarr_indexers_network_tests.rs | 133 +-- .../library/radarr_library_network_tests.rs | 279 +++--- .../radarr_network/radarr_network_tests.rs | 9 +- .../radarr_root_folders_network_tests.rs | 19 +- .../system/radarr_system_network_tests.rs | 171 ++-- .../sonarr_blocklist_network_tests.rs | 36 +- .../sonarr_downloads_network_tests.rs | 19 +- .../history/sonarr_history_network_tests.rs | 36 +- .../indexers/sonarr_indexers_network_tests.rs | 114 +-- .../episodes/sonarr_episodes_network_tests.rs | 800 +++++++++--------- .../seasons/sonarr_seasons_network_tests.rs | 177 ++-- .../series/sonarr_series_network_tests.rs | 260 +++--- .../sonarr_root_folders_network_tests.rs | 19 +- .../sonarr_network/sonarr_network_tests.rs | 12 +- .../system/sonarr_system_network_tests.rs | 181 ++-- src/ui/radarr_ui/blocklist/mod.rs | 9 +- src/ui/radarr_ui/collections/mod.rs | 13 +- src/ui/radarr_ui/downloads/mod.rs | 9 +- .../radarr_ui/indexers/indexer_settings_ui.rs | 9 +- .../indexers/test_all_indexers_ui.rs | 9 +- src/ui/radarr_ui/library/add_movie_ui.rs | 9 +- src/ui/radarr_ui/library/delete_movie_ui.rs | 9 +- src/ui/radarr_ui/library/edit_movie_ui.rs | 9 +- src/ui/radarr_ui/library/movie_details_ui.rs | 9 +- src/ui/radarr_ui/root_folders/mod.rs | 9 +- src/ui/radarr_ui/system/mod.rs | 9 +- src/ui/radarr_ui/system/system_details_ui.rs | 9 +- src/ui/sonarr_ui/indexers/edit_indexer_ui.rs | 9 +- .../sonarr_ui/indexers/indexer_settings_ui.rs | 9 +- src/ui/sonarr_ui/library/add_series_ui.rs | 9 +- src/ui/sonarr_ui/library/delete_series_ui.rs | 9 +- src/ui/sonarr_ui/library/edit_series_ui.rs | 9 +- .../sonarr_ui/library/episode_details_ui.rs | 9 +- src/ui/sonarr_ui/library/season_details_ui.rs | 10 +- src/ui/sonarr_ui/library/series_details_ui.rs | 13 +- src/ui/sonarr_ui/system/mod.rs | 9 +- src/ui/sonarr_ui/system/system_details_ui.rs | 9 +- 43 files changed, 1337 insertions(+), 1291 deletions(-) diff --git a/src/handlers/radarr_handlers/library/movie_details_handler.rs b/src/handlers/radarr_handlers/library/movie_details_handler.rs index 685a161..e76fdeb 100644 --- a/src/handlers/radarr_handlers/library/movie_details_handler.rs +++ b/src/handlers/radarr_handlers/library/movie_details_handler.rs @@ -158,27 +158,23 @@ impl<'a, 'b> KeyEventHandler<'a, 'b, ActiveRadarrBlock> for MovieDetailsHandler< } fn is_ready(&self) -> bool { - if let Some(movie_details_modal) = &self.app.data.radarr_data.movie_details_modal { - match self.active_radarr_block { - ActiveRadarrBlock::MovieDetails => { - !self.app.is_loading && !movie_details_modal.movie_details.is_empty() - } - ActiveRadarrBlock::MovieHistory => { - !self.app.is_loading && !movie_details_modal.movie_history.is_empty() - } - ActiveRadarrBlock::Cast => { - !self.app.is_loading && !movie_details_modal.movie_cast.is_empty() - } - ActiveRadarrBlock::Crew => { - !self.app.is_loading && !movie_details_modal.movie_crew.is_empty() - } - ActiveRadarrBlock::ManualSearch => { - !self.app.is_loading && !movie_details_modal.movie_releases.is_empty() - } - _ => !self.app.is_loading, + let Some(movie_details_modal) = &self.app.data.radarr_data.movie_details_modal else { + return false; + }; + + match self.active_radarr_block { + ActiveRadarrBlock::MovieDetails => { + !self.app.is_loading && !movie_details_modal.movie_details.is_empty() } - } else { - false + ActiveRadarrBlock::MovieHistory => { + !self.app.is_loading && !movie_details_modal.movie_history.is_empty() + } + ActiveRadarrBlock::Cast => !self.app.is_loading && !movie_details_modal.movie_cast.is_empty(), + ActiveRadarrBlock::Crew => !self.app.is_loading && !movie_details_modal.movie_crew.is_empty(), + ActiveRadarrBlock::ManualSearch => { + !self.app.is_loading && !movie_details_modal.movie_releases.is_empty() + } + _ => !self.app.is_loading, } } diff --git a/src/handlers/sonarr_handlers/library/episode_details_handler.rs b/src/handlers/sonarr_handlers/library/episode_details_handler.rs index e9b1ad8..a754419 100644 --- a/src/handlers/sonarr_handlers/library/episode_details_handler.rs +++ b/src/handlers/sonarr_handlers/library/episode_details_handler.rs @@ -110,23 +110,23 @@ impl<'a, 'b> KeyEventHandler<'a, 'b, ActiveSonarrBlock> for EpisodeDetailsHandle } fn is_ready(&self) -> bool { - !self.app.is_loading - && if let Some(season_details_modal) = self.app.data.sonarr_data.season_details_modal.as_ref() - { - if let Some(episode_details_modal) = &season_details_modal.episode_details_modal { - match self.active_sonarr_block { - ActiveSonarrBlock::EpisodeHistory => !episode_details_modal.episode_history.is_empty(), - ActiveSonarrBlock::ManualEpisodeSearch => { - !episode_details_modal.episode_releases.is_empty() - } - _ => true, - } - } else { - false - } - } else { - false - } + if self.app.is_loading { + return false; + } + + let Some(season_details_modal) = self.app.data.sonarr_data.season_details_modal.as_ref() else { + return false; + }; + + let Some(episode_details_modal) = &season_details_modal.episode_details_modal else { + return false; + }; + + match self.active_sonarr_block { + ActiveSonarrBlock::EpisodeHistory => !episode_details_modal.episode_history.is_empty(), + ActiveSonarrBlock::ManualEpisodeSearch => !episode_details_modal.episode_releases.is_empty(), + _ => true, + } } fn handle_scroll_up(&mut self) {} diff --git a/src/handlers/sonarr_handlers/library/season_details_handler.rs b/src/handlers/sonarr_handlers/library/season_details_handler.rs index 8cff217..3472996 100644 --- a/src/handlers/sonarr_handlers/library/season_details_handler.rs +++ b/src/handlers/sonarr_handlers/library/season_details_handler.rs @@ -162,17 +162,20 @@ impl<'a, 'b> KeyEventHandler<'a, 'b, ActiveSonarrBlock> for SeasonDetailsHandler } fn is_ready(&self) -> bool { - !self.app.is_loading - && if let Some(season_details_modal) = &self.app.data.sonarr_data.season_details_modal { - match self.active_sonarr_block { - ActiveSonarrBlock::SeasonDetails => !season_details_modal.episodes.is_empty(), - ActiveSonarrBlock::SeasonHistory => !season_details_modal.season_history.is_empty(), - ActiveSonarrBlock::ManualSeasonSearch => !season_details_modal.season_releases.is_empty(), - _ => true, - } - } else { - false - } + if self.app.is_loading { + return false; + } + + let Some(season_details_modal) = &self.app.data.sonarr_data.season_details_modal else { + return false; + }; + + match self.active_sonarr_block { + ActiveSonarrBlock::SeasonDetails => !season_details_modal.episodes.is_empty(), + ActiveSonarrBlock::SeasonHistory => !season_details_modal.season_history.is_empty(), + ActiveSonarrBlock::ManualSeasonSearch => !season_details_modal.season_releases.is_empty(), + _ => true, + } } fn handle_scroll_up(&mut self) {} diff --git a/src/network/radarr_network/blocklist/radarr_blocklist_network_tests.rs b/src/network/radarr_network/blocklist/radarr_blocklist_network_tests.rs index 2ee20e4..d74b5d0 100644 --- a/src/network/radarr_network/blocklist/radarr_blocklist_network_tests.rs +++ b/src/network/radarr_network/blocklist/radarr_blocklist_network_tests.rs @@ -195,19 +195,20 @@ mod tests { } let mut network = test_network(&app); - if let RadarrSerdeable::BlocklistResponse(blocklist) = network + let RadarrSerdeable::BlocklistResponse(blocklist) = network .handle_radarr_event(RadarrEvent::GetBlocklist) .await .unwrap() - { - mock.assert_async().await; - assert_eq!( - app.lock().await.data.radarr_data.blocklist.items, - expected_blocklist - ); - assert!(app.lock().await.data.radarr_data.blocklist.sort_asc); - assert_eq!(blocklist, response); - } + else { + panic!("Expected BlocklistResponse") + }; + mock.assert_async().await; + assert_eq!( + app.lock().await.data.radarr_data.blocklist.items, + expected_blocklist + ); + assert!(app.lock().await.data.radarr_data.blocklist.sort_asc); + assert_eq!(blocklist, response); } #[tokio::test] diff --git a/src/network/radarr_network/collections/radarr_collections_network_tests.rs b/src/network/radarr_network/collections/radarr_collections_network_tests.rs index 4439db7..6409f80 100644 --- a/src/network/radarr_network/collections/radarr_collections_network_tests.rs +++ b/src/network/radarr_network/collections/radarr_collections_network_tests.rs @@ -277,19 +277,20 @@ mod tests { } let mut network = test_network(&app); - if let RadarrSerdeable::Collections(collections) = network + let RadarrSerdeable::Collections(collections) = network .handle_radarr_event(RadarrEvent::GetCollections) .await .unwrap() - { - mock.assert_async().await; - assert_eq!( - app.lock().await.data.radarr_data.collections.items, - expected_collections - ); - assert!(app.lock().await.data.radarr_data.collections.sort_asc); - assert_eq!(collections, response); - } + else { + panic!("Expected Collections") + }; + mock.assert_async().await; + assert_eq!( + app.lock().await.data.radarr_data.collections.items, + expected_collections + ); + assert!(app.lock().await.data.radarr_data.collections.sort_asc); + assert_eq!(collections, response); } #[tokio::test] diff --git a/src/network/radarr_network/downloads/radarr_downloads_network_tests.rs b/src/network/radarr_network/downloads/radarr_downloads_network_tests.rs index b72c7bf..0bb6ad3 100644 --- a/src/network/radarr_network/downloads/radarr_downloads_network_tests.rs +++ b/src/network/radarr_network/downloads/radarr_downloads_network_tests.rs @@ -48,18 +48,19 @@ mod tests { .await; let mut network = test_network(&app); - if let RadarrSerdeable::DownloadsResponse(downloads) = network + let RadarrSerdeable::DownloadsResponse(downloads) = network .handle_radarr_event(RadarrEvent::GetDownloads(500)) .await .unwrap() - { - mock.assert_async().await; - pretty_assertions::assert_eq!( - app.lock().await.data.radarr_data.downloads.items, - downloads_response().records - ); - pretty_assertions::assert_eq!(downloads, response); - } + else { + panic!("Expected DownloadsResponse") + }; + mock.assert_async().await; + pretty_assertions::assert_eq!( + app.lock().await.data.radarr_data.downloads.items, + downloads_response().records + ); + pretty_assertions::assert_eq!(downloads, response); } #[tokio::test] diff --git a/src/network/radarr_network/indexers/radarr_indexers_network_tests.rs b/src/network/radarr_network/indexers/radarr_indexers_network_tests.rs index b02e789..4c0c228 100644 --- a/src/network/radarr_network/indexers/radarr_indexers_network_tests.rs +++ b/src/network/radarr_network/indexers/radarr_indexers_network_tests.rs @@ -623,18 +623,19 @@ mod tests { .await; let mut network = test_network(&app); - if let RadarrSerdeable::Indexers(indexers) = network + let RadarrSerdeable::Indexers(indexers) = network .handle_radarr_event(RadarrEvent::GetIndexers) .await .unwrap() - { - async_server.assert_async().await; - assert_eq!( - app.lock().await.data.radarr_data.indexers.items, - vec![indexer()] - ); - assert_eq!(indexers, response); - } + else { + panic!("Expected Indexers") + }; + async_server.assert_async().await; + assert_eq!( + app.lock().await.data.radarr_data.indexers.items, + vec![indexer()] + ); + assert_eq!(indexers, response); } #[tokio::test] @@ -658,18 +659,19 @@ mod tests { .await; let mut network = test_network(&app); - if let RadarrSerdeable::IndexerSettings(settings) = network + let RadarrSerdeable::IndexerSettings(settings) = network .handle_radarr_event(RadarrEvent::GetAllIndexerSettings) .await .unwrap() - { - async_server.assert_async().await; - assert_eq!( - app.lock().await.data.radarr_data.indexer_settings, - Some(indexer_settings()) - ); - assert_eq!(settings, response); - } + else { + panic!("Expected IndexerSettings") + }; + async_server.assert_async().await; + assert_eq!( + app.lock().await.data.radarr_data.indexer_settings, + Some(indexer_settings()) + ); + assert_eq!(settings, response); } #[tokio::test] @@ -755,19 +757,20 @@ mod tests { .await; let mut network = test_network(&app); - if let RadarrSerdeable::Value(value) = network + let RadarrSerdeable::Value(value) = network .handle_radarr_event(RadarrEvent::TestIndexer(1)) .await .unwrap() - { - async_details_server.assert_async().await; - async_test_server.assert_async().await; - assert_eq!( - app.lock().await.data.radarr_data.indexer_test_errors, - Some("\"test failure\"".to_owned()) - ); - assert_eq!(value, response_json) - } + else { + panic!("Expected Value") + }; + async_details_server.assert_async().await; + async_test_server.assert_async().await; + assert_eq!( + app.lock().await.data.radarr_data.indexer_test_errors, + Some("\"test failure\"".to_owned()) + ); + assert_eq!(value, response_json); } #[tokio::test] @@ -812,19 +815,20 @@ mod tests { .await; let mut network = test_network(&app); - if let RadarrSerdeable::Value(value) = network + let RadarrSerdeable::Value(value) = network .handle_radarr_event(RadarrEvent::TestIndexer(1)) .await .unwrap() - { - async_details_server.assert_async().await; - async_test_server.assert_async().await; - assert_eq!( - app.lock().await.data.radarr_data.indexer_test_errors, - Some(String::new()) - ); - assert_eq!(value, json!({})); - } + else { + panic!("Expected Value") + }; + async_details_server.assert_async().await; + async_test_server.assert_async().await; + assert_eq!( + app.lock().await.data.radarr_data.indexer_test_errors, + Some(String::new()) + ); + assert_eq!(value, json!({})); } #[tokio::test] @@ -890,34 +894,35 @@ mod tests { .set_items(indexers); let mut network = test_network(&app); - if let RadarrSerdeable::IndexerTestResults(results) = network + let RadarrSerdeable::IndexerTestResults(results) = network .handle_radarr_event(RadarrEvent::TestAllIndexers) .await .unwrap() - { - async_server.assert_async().await; - assert!( - app - .lock() - .await - .data - .radarr_data - .indexer_test_all_results - .is_some() - ); - assert_eq!( - app - .lock() - .await - .data - .radarr_data - .indexer_test_all_results - .as_ref() - .unwrap() - .items, - indexer_test_results_modal_items - ); - assert_eq!(results, response); - } + else { + panic!("Expected IndexerTestResults") + }; + async_server.assert_async().await; + assert!( + app + .lock() + .await + .data + .radarr_data + .indexer_test_all_results + .is_some() + ); + assert_eq!( + app + .lock() + .await + .data + .radarr_data + .indexer_test_all_results + .as_ref() + .unwrap() + .items, + indexer_test_results_modal_items + ); + assert_eq!(results, response); } } diff --git a/src/network/radarr_network/library/radarr_library_network_tests.rs b/src/network/radarr_network/library/radarr_library_network_tests.rs index e16e8c3..d56806e 100644 --- a/src/network/radarr_network/library/radarr_library_network_tests.rs +++ b/src/network/radarr_network/library/radarr_library_network_tests.rs @@ -382,19 +382,20 @@ mod tests { app_arc.lock().await.data.radarr_data.movie_details_modal = Some(MovieDetailsModal::default()); let mut network = test_network(&app_arc); - if let RadarrSerdeable::Credits(credits) = network + let RadarrSerdeable::Credits(credits) = network .handle_radarr_event(RadarrEvent::GetMovieCredits(1)) .await .unwrap() - { - let app = app_arc.lock().await; - let movie_details_modal = app.data.radarr_data.movie_details_modal.as_ref().unwrap(); + else { + panic!("Expected Credits") + }; + let app = app_arc.lock().await; + let movie_details_modal = app.data.radarr_data.movie_details_modal.as_ref().unwrap(); - async_server.assert_async().await; - assert_eq!(movie_details_modal.movie_cast.items, vec![cast_credit()]); - assert_eq!(movie_details_modal.movie_crew.items, vec![crew_credit()]); - assert_eq!(credits, response); - } + async_server.assert_async().await; + assert_eq!(movie_details_modal.movie_cast.items, vec![cast_credit()]); + assert_eq!(movie_details_modal.movie_crew.items, vec![crew_credit()]); + assert_eq!(credits, response); } #[tokio::test] @@ -570,77 +571,78 @@ mod tests { BiMap::from_iter([(2222, "HD - 1080p".to_owned())]); let mut network = test_network(&app_arc); - if let RadarrSerdeable::Movie(movie) = network + let RadarrSerdeable::Movie(movie) = network .handle_radarr_event(RadarrEvent::GetMovieDetails(1)) .await .unwrap() - { - async_server.assert_async().await; - assert!( - app_arc - .lock() - .await - .data - .radarr_data - .movie_details_modal - .is_some() - ); - assert_eq!(movie, response); + else { + panic!("Expected Movie") + }; + async_server.assert_async().await; + assert!( + app_arc + .lock() + .await + .data + .radarr_data + .movie_details_modal + .is_some() + ); + assert_eq!(movie, response); - let app = app_arc.lock().await; - let movie_details_modal = app.data.radarr_data.movie_details_modal.as_ref().unwrap(); - assert_str_eq!( - movie_details_modal.movie_details.get_text(), - formatdoc!( - "Title: Test - Year: 2023 - Runtime: 2h 0m - Rating: R - Collection: Test Collection - Status: Downloaded - Description: Blah blah blah - TMDB: 99% - IMDB: 9.9 - Rotten Tomatoes: - Quality Profile: HD - 1080p - Size: 3.30 GB - Path: /nfs/movies - Studio: 21st Century Alex - Genres: cool, family, fun" - ) - ); - assert_str_eq!( - movie_details_modal.file_details, - formatdoc!( - "Relative Path: Test.mkv - Absolute Path: /nfs/movies/Test.mkv + let app = app_arc.lock().await; + let movie_details_modal = app.data.radarr_data.movie_details_modal.as_ref().unwrap(); + assert_str_eq!( + movie_details_modal.movie_details.get_text(), + formatdoc!( + "Title: Test + Year: 2023 + Runtime: 2h 0m + Rating: R + Collection: Test Collection + Status: Downloaded + Description: Blah blah blah + TMDB: 99% + IMDB: 9.9 + Rotten Tomatoes: + Quality Profile: HD - 1080p Size: 3.30 GB - Date Added: 2022-12-30 07:37:56 UTC" - ) - ); - assert_str_eq!( - movie_details_modal.audio_details, - formatdoc!( - "Bitrate: 0 - Channels: 7.1 - Codec: AAC - Languages: eng - Stream Count: 1" - ) - ); - assert_str_eq!( - movie_details_modal.video_details, - formatdoc!( - "Bit Depth: 10 - Bitrate: 0 - Codec: x265 - FPS: 23.976 - Resolution: 1920x804 - Scan Type: Progressive - Runtime: 2:00:00" - ) - ); - } + Path: /nfs/movies + Studio: 21st Century Alex + Genres: cool, family, fun" + ) + ); + assert_str_eq!( + movie_details_modal.file_details, + formatdoc!( + "Relative Path: Test.mkv + Absolute Path: /nfs/movies/Test.mkv + Size: 3.30 GB + Date Added: 2022-12-30 07:37:56 UTC" + ) + ); + assert_str_eq!( + movie_details_modal.audio_details, + formatdoc!( + "Bitrate: 0 + Channels: 7.1 + Codec: AAC + Languages: eng + Stream Count: 1" + ) + ); + assert_str_eq!( + movie_details_modal.video_details, + formatdoc!( + "Bit Depth: 10 + Bitrate: 0 + Codec: x265 + FPS: 23.976 + Resolution: 1920x804 + Scan Type: Progressive + Runtime: 2:00:00" + ) + ); } #[tokio::test] @@ -741,27 +743,28 @@ mod tests { app_arc.lock().await.data.radarr_data.movie_details_modal = Some(MovieDetailsModal::default()); let mut network = test_network(&app_arc); - if let RadarrSerdeable::MovieHistoryItems(history) = network + let RadarrSerdeable::MovieHistoryItems(history) = network .handle_radarr_event(RadarrEvent::GetMovieHistory(1)) .await .unwrap() - { - async_server.assert_async().await; - assert_eq!( - app_arc - .lock() - .await - .data - .radarr_data - .movie_details_modal - .as_ref() - .unwrap() - .movie_history - .items, - vec![movie_history_item()] - ); - assert_eq!(history, response); - } + else { + panic!("Expected MovieHistoryItems") + }; + async_server.assert_async().await; + assert_eq!( + app_arc + .lock() + .await + .data + .radarr_data + .movie_details_modal + .as_ref() + .unwrap() + .movie_history + .items, + vec![movie_history_item()] + ); + assert_eq!(history, response); } #[tokio::test] @@ -828,27 +831,28 @@ mod tests { app_arc.lock().await.data.radarr_data.movie_details_modal = Some(MovieDetailsModal::default()); let mut network = test_network(&app_arc); - if let RadarrSerdeable::Releases(releases_vec) = network + let RadarrSerdeable::Releases(releases_vec) = network .handle_radarr_event(RadarrEvent::GetReleases(1)) .await .unwrap() - { - async_server.assert_async().await; - assert_eq!( - app_arc - .lock() - .await - .data - .radarr_data - .movie_details_modal - .as_ref() - .unwrap() - .movie_releases - .items, - vec![release()] - ); - assert_eq!(releases_vec, vec![release()]); - } + else { + panic!("Expected Releases") + }; + async_server.assert_async().await; + assert_eq!( + app_arc + .lock() + .await + .data + .radarr_data + .movie_details_modal + .as_ref() + .unwrap() + .movie_releases + .items, + vec![release()] + ); + assert_eq!(releases_vec, vec![release()]); } #[tokio::test] @@ -928,35 +932,36 @@ mod tests { .await; let mut network = test_network(&app_arc); - if let RadarrSerdeable::AddMovieSearchResults(add_movie_search_results) = network + let RadarrSerdeable::AddMovieSearchResults(add_movie_search_results) = network .handle_radarr_event(RadarrEvent::SearchNewMovie("test term".into())) .await .unwrap() - { - async_server.assert_async().await; - assert!( - app_arc - .lock() - .await - .data - .radarr_data - .add_searched_movies - .is_some() - ); - assert_eq!( - app_arc - .lock() - .await - .data - .radarr_data - .add_searched_movies - .as_ref() - .unwrap() - .items, - vec![add_movie_search_result()] - ); - assert_eq!(add_movie_search_results, vec![add_movie_search_result()]); - } + else { + panic!("Expected AddMovieSearchResults") + }; + async_server.assert_async().await; + assert!( + app_arc + .lock() + .await + .data + .radarr_data + .add_searched_movies + .is_some() + ); + assert_eq!( + app_arc + .lock() + .await + .data + .radarr_data + .add_searched_movies + .as_ref() + .unwrap() + .items, + vec![add_movie_search_result()] + ); + assert_eq!(add_movie_search_results, vec![add_movie_search_result()]); } #[tokio::test] diff --git a/src/network/radarr_network/radarr_network_tests.rs b/src/network/radarr_network/radarr_network_tests.rs index c5af96e..cfa10b0 100644 --- a/src/network/radarr_network/radarr_network_tests.rs +++ b/src/network/radarr_network/radarr_network_tests.rs @@ -194,8 +194,9 @@ mod test { mock.assert_async().await; let RadarrSerdeable::QualityProfiles(quality_profiles) = result.unwrap() else { - panic!("Expected QualityProfiles variant"); + panic!("Expected QualityProfiles"); }; + assert_eq!(quality_profiles, expected); assert_eq!( app.lock().await.data.radarr_data.quality_profile_map, @@ -225,8 +226,9 @@ mod test { mock.assert_async().await; let RadarrSerdeable::Tags(tags) = result.unwrap() else { - panic!("Expected Tags variant"); + panic!("Expected Tags"); }; + assert_eq!(tags, expected); assert_eq!( app.lock().await.data.radarr_data.tags_map, @@ -259,8 +261,9 @@ mod test { mock.assert_async().await; let RadarrSerdeable::Tag(tag) = result.unwrap() else { - panic!("Expected Tag variant"); + panic!("Expected Tag"); }; + assert_eq!(tag, expected); assert_eq!( app.lock().await.data.radarr_data.tags_map, diff --git a/src/network/radarr_network/root_folders/radarr_root_folders_network_tests.rs b/src/network/radarr_network/root_folders/radarr_root_folders_network_tests.rs index 0c03765..f323d45 100644 --- a/src/network/radarr_network/root_folders/radarr_root_folders_network_tests.rs +++ b/src/network/radarr_network/root_folders/radarr_root_folders_network_tests.rs @@ -65,17 +65,18 @@ mod tests { .await; let mut network = test_network(&app); - if let RadarrSerdeable::RootFolders(root_folders) = network + let RadarrSerdeable::RootFolders(root_folders) = network .handle_radarr_event(RadarrEvent::GetRootFolders) .await .unwrap() - { - mock.assert_async().await; - assert_eq!( - app.lock().await.data.radarr_data.root_folders.items, - vec![root_folder()] - ); - assert_eq!(root_folders, response); - } + else { + panic!("Expected RootFolders") + }; + mock.assert_async().await; + assert_eq!( + app.lock().await.data.radarr_data.root_folders.items, + vec![root_folder()] + ); + assert_eq!(root_folders, response); } } diff --git a/src/network/radarr_network/system/radarr_system_network_tests.rs b/src/network/radarr_network/system/radarr_system_network_tests.rs index 6936776..c6a9cfd 100644 --- a/src/network/radarr_network/system/radarr_system_network_tests.rs +++ b/src/network/radarr_network/system/radarr_system_network_tests.rs @@ -39,18 +39,19 @@ mod tests { }, ]; - if let RadarrSerdeable::DiskSpaces(disk_space) = network + let RadarrSerdeable::DiskSpaces(disk_space) = network .handle_radarr_event(RadarrEvent::GetDiskSpace) .await .unwrap() - { - mock.assert_async().await; - assert_eq!( - app.lock().await.data.radarr_data.disk_space_vec, - disk_space_vec - ); - assert_eq!(disk_space, disk_space_vec); - } + else { + panic!("Expected DiskSpaces") + }; + mock.assert_async().await; + assert_eq!( + app.lock().await.data.radarr_data.disk_space_vec, + disk_space_vec + ); + assert_eq!(disk_space, disk_space_vec); } #[tokio::test] @@ -73,14 +74,15 @@ mod tests { .await; let mut network = test_network(&app); - if let RadarrSerdeable::HostConfig(host_config) = network + let RadarrSerdeable::HostConfig(host_config) = network .handle_radarr_event(RadarrEvent::GetHostConfig) .await .unwrap() - { - mock.assert_async().await; - assert_eq!(host_config, response); - } + else { + panic!("Expected HostConfig") + }; + mock.assert_async().await; + assert_eq!(host_config, response); } #[tokio::test] @@ -123,26 +125,27 @@ mod tests { .await; let mut network = test_network(&app); - if let RadarrSerdeable::LogResponse(logs) = network + let RadarrSerdeable::LogResponse(logs) = network .handle_radarr_event(RadarrEvent::GetLogs(500)) .await .unwrap() - { - mock.assert_async().await; - assert_eq!(app.lock().await.data.radarr_data.logs.items, expected_logs); - assert!( - app - .lock() - .await - .data - .radarr_data - .logs - .current_selection() - .text - .contains("INFO") - ); - assert_eq!(logs, response); - } + else { + panic!("Expected LogResponse") + }; + mock.assert_async().await; + assert_eq!(app.lock().await.data.radarr_data.logs.items, expected_logs); + assert!( + app + .lock() + .await + .data + .radarr_data + .logs + .current_selection() + .text + .contains("INFO") + ); + assert_eq!(logs, response); } #[tokio::test] @@ -176,18 +179,19 @@ mod tests { .await; let mut network = test_network(&app); - if let RadarrSerdeable::QueueEvents(events) = network + let RadarrSerdeable::QueueEvents(events) = network .handle_radarr_event(RadarrEvent::GetQueuedEvents) .await .unwrap() - { - mock.assert_async().await; - assert_eq!( - app.lock().await.data.radarr_data.queued_events.items, - vec![expected_event] - ); - assert_eq!(events, response); - } + else { + panic!("Expected QueueEvents") + }; + mock.assert_async().await; + assert_eq!( + app.lock().await.data.radarr_data.queued_events.items, + vec![expected_event] + ); + assert_eq!(events, response); } #[tokio::test] @@ -208,14 +212,15 @@ mod tests { .await; let mut network = test_network(&app); - if let RadarrSerdeable::SecurityConfig(security_config) = network + let RadarrSerdeable::SecurityConfig(security_config) = network .handle_radarr_event(RadarrEvent::GetSecurityConfig) .await .unwrap() - { - mock.assert_async().await; - assert_eq!(security_config, response); - } + else { + panic!("Expected SecurityConfig") + }; + mock.assert_async().await; + assert_eq!(security_config, response); } #[tokio::test] @@ -230,22 +235,23 @@ mod tests { let mut network = test_network(&app); let date_time = DateTime::from(DateTime::parse_from_rfc3339("2023-02-25T20:16:43Z").unwrap()); - if let RadarrSerdeable::SystemStatus(status) = network + let RadarrSerdeable::SystemStatus(status) = network .handle_radarr_event(RadarrEvent::GetStatus) .await .unwrap() - { - async_server.assert_async().await; - assert_str_eq!(app.lock().await.data.radarr_data.version, "v1"); - assert_eq!(app.lock().await.data.radarr_data.start_time, date_time); - assert_eq!( - status, - SystemStatus { - version: "v1".to_owned(), - start_time: date_time - } - ); - } + else { + panic!("Expected SystemStatus") + }; + async_server.assert_async().await; + assert_str_eq!(app.lock().await.data.radarr_data.version, "v1"); + assert_eq!(app.lock().await.data.radarr_data.start_time, date_time); + assert_eq!( + status, + SystemStatus { + version: "v1".to_owned(), + start_time: date_time + } + ); } #[tokio::test] @@ -323,18 +329,19 @@ mod tests { .await; let mut network = test_network(&app); - if let RadarrSerdeable::Updates(updates) = network + let RadarrSerdeable::Updates(updates) = network .handle_radarr_event(RadarrEvent::GetUpdates) .await .unwrap() - { - async_server.assert_async().await; - assert_str_eq!( - app.lock().await.data.radarr_data.updates.get_text(), - expected_text.get_text() - ); - assert_eq!(updates, response); - } + else { + panic!("Expected Updates") + }; + async_server.assert_async().await; + assert_str_eq!( + app.lock().await.data.radarr_data.updates.get_text(), + expected_text.get_text() + ); + assert_eq!(updates, response); } #[tokio::test] @@ -381,18 +388,19 @@ mod tests { .await; let mut network = test_network(&app); - if let RadarrSerdeable::Tasks(tasks) = network + let RadarrSerdeable::Tasks(tasks) = network .handle_radarr_event(RadarrEvent::GetTasks) .await .unwrap() - { - async_server.assert_async().await; - assert_eq!( - app.lock().await.data.radarr_data.tasks.items, - expected_tasks - ); - assert_eq!(tasks, response); - } + else { + panic!("Expected Tasks") + }; + async_server.assert_async().await; + assert_eq!( + app.lock().await.data.radarr_data.tasks.items, + expected_tasks + ); + assert_eq!(tasks, response); } #[tokio::test] @@ -409,15 +417,16 @@ mod tests { .await; let mut network = test_network(&app); - if let RadarrSerdeable::Value(value) = network + let RadarrSerdeable::Value(value) = network .handle_radarr_event(RadarrEvent::StartTask( RadarrTaskName::ApplicationCheckUpdate, )) .await .unwrap() - { - async_server.assert_async().await; - assert_eq!(value, response); - } + else { + panic!("Expected Value") + }; + async_server.assert_async().await; + assert_eq!(value, response); } } diff --git a/src/network/sonarr_network/blocklist/sonarr_blocklist_network_tests.rs b/src/network/sonarr_network/blocklist/sonarr_blocklist_network_tests.rs index 72afc8e..5b818cc 100644 --- a/src/network/sonarr_network/blocklist/sonarr_blocklist_network_tests.rs +++ b/src/network/sonarr_network/blocklist/sonarr_blocklist_network_tests.rs @@ -163,19 +163,20 @@ mod tests { app.lock().await.server_tabs.next(); let mut network = test_network(&app); - if let SonarrSerdeable::BlocklistResponse(blocklist) = network + let SonarrSerdeable::BlocklistResponse(blocklist) = network .handle_sonarr_event(SonarrEvent::GetBlocklist) .await .unwrap() - { - mock.assert_async().await; - assert_eq!( - app.lock().await.data.sonarr_data.blocklist.items, - expected_blocklist - ); - assert!(app.lock().await.data.sonarr_data.blocklist.sort_asc); - assert_eq!(blocklist, response); - } + else { + panic!("Expected BlocklistResponse") + }; + mock.assert_async().await; + assert_eq!( + app.lock().await.data.sonarr_data.blocklist.items, + expected_blocklist + ); + assert!(app.lock().await.data.sonarr_data.blocklist.sort_asc); + assert_eq!(blocklist, response); } #[tokio::test] @@ -233,15 +234,16 @@ mod tests { app.lock().await.server_tabs.next(); let mut network = test_network(&app); - if let SonarrSerdeable::BlocklistResponse(blocklist) = network + let SonarrSerdeable::BlocklistResponse(blocklist) = network .handle_sonarr_event(SonarrEvent::GetBlocklist) .await .unwrap() - { - mock.assert_async().await; - assert!(app.lock().await.data.sonarr_data.blocklist.is_empty()); - assert!(app.lock().await.data.sonarr_data.blocklist.sort_asc); - assert_eq!(blocklist, response); - } + else { + panic!("Expected BlocklistResponse") + }; + mock.assert_async().await; + assert!(app.lock().await.data.sonarr_data.blocklist.is_empty()); + assert!(app.lock().await.data.sonarr_data.blocklist.sort_asc); + assert_eq!(blocklist, response); } } diff --git a/src/network/sonarr_network/downloads/sonarr_downloads_network_tests.rs b/src/network/sonarr_network/downloads/sonarr_downloads_network_tests.rs index a664ab7..3a74f39 100644 --- a/src/network/sonarr_network/downloads/sonarr_downloads_network_tests.rs +++ b/src/network/sonarr_network/downloads/sonarr_downloads_network_tests.rs @@ -60,18 +60,19 @@ mod tests { app.lock().await.server_tabs.next(); let mut network = test_network(&app); - if let SonarrSerdeable::DownloadsResponse(downloads) = network + let SonarrSerdeable::DownloadsResponse(downloads) = network .handle_sonarr_event(SonarrEvent::GetDownloads(500)) .await .unwrap() - { - mock.assert_async().await; - assert_eq!( - app.lock().await.data.sonarr_data.downloads.items, - downloads_response().records - ); - assert_eq!(downloads, response); - } + else { + panic!("Expected DownloadsResponse") + }; + mock.assert_async().await; + assert_eq!( + app.lock().await.data.sonarr_data.downloads.items, + downloads_response().records + ); + assert_eq!(downloads, response); } #[tokio::test] diff --git a/src/network/sonarr_network/history/sonarr_history_network_tests.rs b/src/network/sonarr_network/history/sonarr_history_network_tests.rs index 04803c6..7bb1dae 100644 --- a/src/network/sonarr_network/history/sonarr_history_network_tests.rs +++ b/src/network/sonarr_network/history/sonarr_history_network_tests.rs @@ -84,19 +84,20 @@ mod tests { app.lock().await.server_tabs.next(); let mut network = test_network(&app); - if let SonarrSerdeable::SonarrHistoryWrapper(history) = network + let SonarrSerdeable::SonarrHistoryWrapper(history) = network .handle_sonarr_event(SonarrEvent::GetHistory(500)) .await .unwrap() - { - mock.assert_async().await; - assert_eq!( - app.lock().await.data.sonarr_data.history.items, - expected_history_items - ); - assert!(app.lock().await.data.sonarr_data.history.sort_asc); - assert_eq!(history, response); - } + else { + panic!("Expected SonarrHistoryWrapper") + }; + mock.assert_async().await; + assert_eq!( + app.lock().await.data.sonarr_data.history.items, + expected_history_items + ); + assert!(app.lock().await.data.sonarr_data.history.sort_asc); + assert_eq!(history, response); } #[tokio::test] @@ -158,16 +159,17 @@ mod tests { app.lock().await.server_tabs.next(); let mut network = test_network(&app); - if let SonarrSerdeable::SonarrHistoryWrapper(history) = network + let SonarrSerdeable::SonarrHistoryWrapper(history) = network .handle_sonarr_event(SonarrEvent::GetHistory(500)) .await .unwrap() - { - mock.assert_async().await; - assert!(app.lock().await.data.sonarr_data.history.is_empty()); - assert!(app.lock().await.data.sonarr_data.history.sort_asc); - assert_eq!(history, response); - } + else { + panic!("Expected SonarrHistoryWrapper") + }; + mock.assert_async().await; + assert!(app.lock().await.data.sonarr_data.history.is_empty()); + assert!(app.lock().await.data.sonarr_data.history.sort_asc); + assert_eq!(history, response); } #[tokio::test] diff --git a/src/network/sonarr_network/indexers/sonarr_indexers_network_tests.rs b/src/network/sonarr_network/indexers/sonarr_indexers_network_tests.rs index 38330ae..3bd86bd 100644 --- a/src/network/sonarr_network/indexers/sonarr_indexers_network_tests.rs +++ b/src/network/sonarr_network/indexers/sonarr_indexers_network_tests.rs @@ -635,18 +635,19 @@ mod tests { app.lock().await.server_tabs.next(); let mut network = test_network(&app); - if let SonarrSerdeable::Indexers(indexers) = network + let SonarrSerdeable::Indexers(indexers) = network .handle_sonarr_event(SonarrEvent::GetIndexers) .await .unwrap() - { - async_server.assert_async().await; - assert_eq!( - app.lock().await.data.sonarr_data.indexers.items, - vec![indexer()] - ); - assert_eq!(indexers, response); - } + else { + panic!("Expected Indexers") + }; + async_server.assert_async().await; + assert_eq!( + app.lock().await.data.sonarr_data.indexers.items, + vec![indexer()] + ); + assert_eq!(indexers, response); } #[tokio::test] @@ -706,19 +707,20 @@ mod tests { app.lock().await.server_tabs.next(); let mut network = test_network(&app); - if let SonarrSerdeable::Value(value) = network + let SonarrSerdeable::Value(value) = network .handle_sonarr_event(SonarrEvent::TestIndexer(1)) .await .unwrap() - { - async_details_server.assert_async().await; - async_test_server.assert_async().await; - assert_eq!( - app.lock().await.data.sonarr_data.indexer_test_errors, - Some("\"test failure\"".to_owned()) - ); - assert_eq!(value, response_json) - } + else { + panic!("Expected Value") + }; + async_details_server.assert_async().await; + async_test_server.assert_async().await; + assert_eq!( + app.lock().await.data.sonarr_data.indexer_test_errors, + Some("\"test failure\"".to_owned()) + ); + assert_eq!(value, response_json); } #[tokio::test] @@ -771,19 +773,20 @@ mod tests { app.lock().await.server_tabs.next(); let mut network = test_network(&app); - if let SonarrSerdeable::Value(value) = network + let SonarrSerdeable::Value(value) = network .handle_sonarr_event(SonarrEvent::TestIndexer(1)) .await .unwrap() - { - async_details_server.assert_async().await; - async_test_server.assert_async().await; - assert_eq!( - app.lock().await.data.sonarr_data.indexer_test_errors, - Some(String::new()) - ); - assert_eq!(value, json!({})); - } + else { + panic!("Expected Value") + }; + async_details_server.assert_async().await; + async_test_server.assert_async().await; + assert_eq!( + app.lock().await.data.sonarr_data.indexer_test_errors, + Some(String::new()) + ); + assert_eq!(value, json!({})); } #[tokio::test] @@ -850,34 +853,35 @@ mod tests { app.lock().await.server_tabs.next(); let mut network = test_network(&app); - if let SonarrSerdeable::IndexerTestResults(results) = network + let SonarrSerdeable::IndexerTestResults(results) = network .handle_sonarr_event(SonarrEvent::TestAllIndexers) .await .unwrap() - { - async_server.assert_async().await; - assert!( - app - .lock() - .await - .data - .sonarr_data - .indexer_test_all_results - .is_some() - ); - assert_eq!( - app - .lock() - .await - .data - .sonarr_data - .indexer_test_all_results - .as_ref() - .unwrap() - .items, - indexer_test_results_modal_items - ); - assert_eq!(results, response); - } + else { + panic!("Expected IndexerTestResults") + }; + async_server.assert_async().await; + assert!( + app + .lock() + .await + .data + .sonarr_data + .indexer_test_all_results + .is_some() + ); + assert_eq!( + app + .lock() + .await + .data + .sonarr_data + .indexer_test_all_results + .as_ref() + .unwrap() + .items, + indexer_test_results_modal_items + ); + assert_eq!(results, response); } } diff --git a/src/network/sonarr_network/library/episodes/sonarr_episodes_network_tests.rs b/src/network/sonarr_network/library/episodes/sonarr_episodes_network_tests.rs index 74ca0af..cd4f536 100644 --- a/src/network/sonarr_network/library/episodes/sonarr_episodes_network_tests.rs +++ b/src/network/sonarr_network/library/episodes/sonarr_episodes_network_tests.rs @@ -253,27 +253,28 @@ mod tests { app_arc.lock().await.server_tabs.next(); let mut network = test_network(&app_arc); - if let SonarrSerdeable::Episodes(episodes) = network + let SonarrSerdeable::Episodes(episodes) = network .handle_sonarr_event(SonarrEvent::GetEpisodes(1)) .await .unwrap() - { - async_server.assert_async().await; - assert_eq!( - app_arc - .lock() - .await - .data - .sonarr_data - .season_details_modal - .as_ref() - .unwrap() - .episodes - .items, - vec![episode()] - ); - assert_eq!(episodes, vec![episode()]); - } + else { + panic!("Expected Episodes") + }; + async_server.assert_async().await; + assert_eq!( + app_arc + .lock() + .await + .data + .sonarr_data + .season_details_modal + .as_ref() + .unwrap() + .episodes + .items, + vec![episode()] + ); + assert_eq!(episodes, vec![episode()]); } #[tokio::test] @@ -353,38 +354,39 @@ mod tests { app_arc.lock().await.server_tabs.next(); let mut network = test_network(&app_arc); - if let SonarrSerdeable::Episodes(episodes) = network + let SonarrSerdeable::Episodes(episodes) = network .handle_sonarr_event(SonarrEvent::GetEpisodes(1)) .await .unwrap() - { - async_server.assert_async().await; - assert!( - app_arc - .lock() - .await - .data - .sonarr_data - .season_details_modal - .as_ref() - .unwrap() - .episodes - .is_empty() - ); - assert!( - app_arc - .lock() - .await - .data - .sonarr_data - .season_details_modal - .as_ref() - .unwrap() - .episodes - .sort_asc - ); - assert_eq!(episodes, expected_episodes); - } + else { + panic!("Expected Episodes") + }; + async_server.assert_async().await; + assert!( + app_arc + .lock() + .await + .data + .sonarr_data + .season_details_modal + .as_ref() + .unwrap() + .episodes + .is_empty() + ); + assert!( + app_arc + .lock() + .await + .data + .sonarr_data + .season_details_modal + .as_ref() + .unwrap() + .episodes + .sort_asc + ); + assert_eq!(episodes, expected_episodes); } #[tokio::test] @@ -409,27 +411,28 @@ mod tests { app_arc.lock().await.server_tabs.next(); let mut network = test_network(&app_arc); - if let SonarrSerdeable::EpisodeFiles(episode_files) = network + let SonarrSerdeable::EpisodeFiles(episode_files) = network .handle_sonarr_event(SonarrEvent::GetEpisodeFiles(1)) .await .unwrap() - { - async_server.assert_async().await; - assert_eq!( - app_arc - .lock() - .await - .data - .sonarr_data - .season_details_modal - .as_ref() - .unwrap() - .episode_files - .items, - vec![episode_file()] - ); - assert_eq!(episode_files, vec![episode_file()]); - } + else { + panic!("Expected EpisodeFiles") + }; + async_server.assert_async().await; + assert_eq!( + app_arc + .lock() + .await + .data + .sonarr_data + .season_details_modal + .as_ref() + .unwrap() + .episode_files + .items, + vec![episode_file()] + ); + assert_eq!(episode_files, vec![episode_file()]); } #[tokio::test] @@ -452,36 +455,37 @@ mod tests { app_arc.lock().await.server_tabs.next(); let mut network = test_network(&app_arc); - if let SonarrSerdeable::EpisodeFiles(episode_files) = network + let SonarrSerdeable::EpisodeFiles(episode_files) = network .handle_sonarr_event(SonarrEvent::GetEpisodeFiles(1)) .await .unwrap() - { - async_server.assert_async().await; - assert!( - app_arc - .lock() - .await - .data - .sonarr_data - .season_details_modal - .is_some() - ); - assert_eq!( - app_arc - .lock() - .await - .data - .sonarr_data - .season_details_modal - .as_ref() - .unwrap() - .episode_files - .items, - vec![episode_file()] - ); - assert_eq!(episode_files, vec![episode_file()]); - } + else { + panic!("Expected EpisodeFiles") + }; + async_server.assert_async().await; + assert!( + app_arc + .lock() + .await + .data + .sonarr_data + .season_details_modal + .is_some() + ); + assert_eq!( + app_arc + .lock() + .await + .data + .sonarr_data + .season_details_modal + .as_ref() + .unwrap() + .episode_files + .items, + vec![episode_file()] + ); + assert_eq!(episode_files, vec![episode_file()]); } #[tokio::test] @@ -569,45 +573,46 @@ mod tests { app_arc.lock().await.server_tabs.next(); let mut network = test_network(&app_arc); - if let SonarrSerdeable::SonarrHistoryWrapper(history) = network + let SonarrSerdeable::SonarrHistoryWrapper(history) = network .handle_sonarr_event(SonarrEvent::GetEpisodeHistory(1)) .await .unwrap() - { - async_server.assert_async().await; - assert_eq!( - app_arc - .lock() - .await - .data - .sonarr_data - .season_details_modal - .as_ref() - .unwrap() - .episode_details_modal - .as_ref() - .unwrap() - .episode_history - .items, - expected_history_items - ); - assert!( - app_arc - .lock() - .await - .data - .sonarr_data - .season_details_modal - .as_ref() - .unwrap() - .episode_details_modal - .as_ref() - .unwrap() - .episode_history - .sort_asc - ); - assert_eq!(history, response); - } + else { + panic!("Expected SonarrHistoryWrapper") + }; + async_server.assert_async().await; + assert_eq!( + app_arc + .lock() + .await + .data + .sonarr_data + .season_details_modal + .as_ref() + .unwrap() + .episode_details_modal + .as_ref() + .unwrap() + .episode_history + .items, + expected_history_items + ); + assert!( + app_arc + .lock() + .await + .data + .sonarr_data + .season_details_modal + .as_ref() + .unwrap() + .episode_details_modal + .as_ref() + .unwrap() + .episode_history + .sort_asc + ); + assert_eq!(history, response); } #[tokio::test] @@ -673,45 +678,46 @@ mod tests { app_arc.lock().await.server_tabs.next(); let mut network = test_network(&app_arc); - if let SonarrSerdeable::SonarrHistoryWrapper(history) = network + let SonarrSerdeable::SonarrHistoryWrapper(history) = network .handle_sonarr_event(SonarrEvent::GetEpisodeHistory(1)) .await .unwrap() - { - async_server.assert_async().await; - assert_eq!( - app_arc - .lock() - .await - .data - .sonarr_data - .season_details_modal - .as_ref() - .unwrap() - .episode_details_modal - .as_ref() - .unwrap() - .episode_history - .items, - expected_history_items - ); - assert!( - !app_arc - .lock() - .await - .data - .sonarr_data - .season_details_modal - .as_ref() - .unwrap() - .episode_details_modal - .as_ref() - .unwrap() - .episode_history - .sort_asc - ); - assert_eq!(history, response); - } + else { + panic!("Expected SonarrHistoryWrapper") + }; + async_server.assert_async().await; + assert_eq!( + app_arc + .lock() + .await + .data + .sonarr_data + .season_details_modal + .as_ref() + .unwrap() + .episode_details_modal + .as_ref() + .unwrap() + .episode_history + .items, + expected_history_items + ); + assert!( + !app_arc + .lock() + .await + .data + .sonarr_data + .season_details_modal + .as_ref() + .unwrap() + .episode_details_modal + .as_ref() + .unwrap() + .episode_history + .sort_asc + ); + assert_eq!(history, response); } #[tokio::test] @@ -765,45 +771,46 @@ mod tests { app_arc.lock().await.server_tabs.next(); let mut network = test_network(&app_arc); - if let SonarrSerdeable::SonarrHistoryWrapper(history) = network + let SonarrSerdeable::SonarrHistoryWrapper(history) = network .handle_sonarr_event(SonarrEvent::GetEpisodeHistory(1)) .await .unwrap() - { - async_server.assert_async().await; - assert_eq!( - app_arc - .lock() - .await - .data - .sonarr_data - .season_details_modal - .as_ref() - .unwrap() - .episode_details_modal - .as_ref() - .unwrap() - .episode_history - .items, - expected_history_items - ); - assert!( - !app_arc - .lock() - .await - .data - .sonarr_data - .season_details_modal - .as_ref() - .unwrap() - .episode_details_modal - .as_ref() - .unwrap() - .episode_history - .sort_asc - ); - assert_eq!(history, response); - } + else { + panic!("Expected SonarrHistoryWrapper") + }; + async_server.assert_async().await; + assert_eq!( + app_arc + .lock() + .await + .data + .sonarr_data + .season_details_modal + .as_ref() + .unwrap() + .episode_details_modal + .as_ref() + .unwrap() + .episode_history + .items, + expected_history_items + ); + assert!( + !app_arc + .lock() + .await + .data + .sonarr_data + .season_details_modal + .as_ref() + .unwrap() + .episode_details_modal + .as_ref() + .unwrap() + .episode_history + .sort_asc + ); + assert_eq!(history, response); } #[tokio::test] @@ -827,44 +834,30 @@ mod tests { app_arc.lock().await.server_tabs.next(); let mut network = test_network(&app_arc); - if let SonarrSerdeable::Episode(episode) = network + let SonarrSerdeable::Episode(episode) = network .handle_sonarr_event(SonarrEvent::GetEpisodeDetails(1)) .await .unwrap() - { - async_server.assert_async().await; - assert!( - app_arc - .lock() - .await - .data - .sonarr_data - .season_details_modal - .as_ref() - .unwrap() - .episode_details_modal - .is_some() - ); - assert_eq!( - app_arc - .lock() - .await - .data - .sonarr_data - .season_details_modal - .as_ref() - .unwrap() - .episode_details_modal - .as_ref() - .unwrap() - .episode_details_tabs - .get_active_route(), - ActiveSonarrBlock::EpisodeHistory.into() - ); - assert_eq!(episode, response); - - let app = app_arc.lock().await; - let episode_details_modal = app + else { + panic!("Expected Episode") + }; + async_server.assert_async().await; + assert!( + app_arc + .lock() + .await + .data + .sonarr_data + .season_details_modal + .as_ref() + .unwrap() + .episode_details_modal + .is_some() + ); + assert_eq!( + app_arc + .lock() + .await .data .sonarr_data .season_details_modal @@ -872,52 +865,67 @@ mod tests { .unwrap() .episode_details_modal .as_ref() - .unwrap(); - assert_str_eq!( - episode_details_modal.episode_details.get_text(), - formatdoc!( - "Title: Something cool - Season: 1 - Episode Number: 1 - Air Date: 2024-02-10 07:28:45 UTC - Status: Downloaded - Description: Okay so this one time at band camp..." - ) - ); - assert_str_eq!( - episode_details_modal.file_details, - formatdoc!( - "Relative Path: /season 1/episode 1.mkv - Absolute Path: /nfs/tv/series/season 1/episode 1.mkv - Size: 3.30 GB - Language: English - Date Added: 2024-02-10 07:28:45 UTC" - ) - ); - assert_str_eq!( - episode_details_modal.audio_details, - formatdoc!( - "Bitrate: 0 - Channels: 7.1 - Codec: AAC - Languages: eng - Stream Count: 1" - ) - ); - assert_str_eq!( - episode_details_modal.video_details, - formatdoc!( - "Bit Depth: 10 - Bitrate: 0 - Codec: x265 - FPS: 23.976 - Resolution: 1920x1080 - Scan Type: Progressive - Runtime: 23:51 - Subtitles: English" - ) - ); - } + .unwrap() + .episode_details_tabs + .get_active_route(), + ActiveSonarrBlock::EpisodeHistory.into() + ); + assert_eq!(episode, response); + + let app = app_arc.lock().await; + let episode_details_modal = app + .data + .sonarr_data + .season_details_modal + .as_ref() + .unwrap() + .episode_details_modal + .as_ref() + .unwrap(); + assert_str_eq!( + episode_details_modal.episode_details.get_text(), + formatdoc!( + "Title: Something cool + Season: 1 + Episode Number: 1 + Air Date: 2024-02-10 07:28:45 UTC + Status: Downloaded + Description: Okay so this one time at band camp..." + ) + ); + assert_str_eq!( + episode_details_modal.file_details, + formatdoc!( + "Relative Path: /season 1/episode 1.mkv + Absolute Path: /nfs/tv/series/season 1/episode 1.mkv + Size: 3.30 GB + Language: English + Date Added: 2024-02-10 07:28:45 UTC" + ) + ); + assert_str_eq!( + episode_details_modal.audio_details, + formatdoc!( + "Bitrate: 0 + Channels: 7.1 + Codec: AAC + Languages: eng + Stream Count: 1" + ) + ); + assert_str_eq!( + episode_details_modal.video_details, + formatdoc!( + "Bit Depth: 10 + Bitrate: 0 + Codec: x265 + FPS: 23.976 + Resolution: 1920x1080 + Scan Type: Progressive + Runtime: 23:51 + Subtitles: English" + ) + ); } #[tokio::test] @@ -938,81 +946,82 @@ mod tests { app_arc.lock().await.server_tabs.next(); let mut network = test_network(&app_arc); - if let SonarrSerdeable::Episode(episode) = network + let SonarrSerdeable::Episode(episode) = network .handle_sonarr_event(SonarrEvent::GetEpisodeDetails(1)) .await .unwrap() - { - async_server.assert_async().await; - assert!( - app_arc - .lock() - .await - .data - .sonarr_data - .season_details_modal - .as_ref() - .unwrap() - .episode_details_modal - .is_some() - ); - assert_eq!(episode, response); - - let app = app_arc.lock().await; - let episode_details_modal = app + else { + panic!("Expected Episode") + }; + async_server.assert_async().await; + assert!( + app_arc + .lock() + .await .data .sonarr_data .season_details_modal .as_ref() .unwrap() .episode_details_modal - .as_ref() - .unwrap(); - assert_str_eq!( - episode_details_modal.episode_details.get_text(), - formatdoc!( - "Title: Something cool - Season: 1 - Episode Number: 1 - Air Date: 2024-02-10 07:28:45 UTC - Status: Downloaded - Description: Okay so this one time at band camp..." - ) - ); - assert_str_eq!( - episode_details_modal.file_details, - formatdoc!( - "Relative Path: /season 1/episode 1.mkv - Absolute Path: /nfs/tv/series/season 1/episode 1.mkv - Size: 3.30 GB - Language: English - Date Added: 2024-02-10 07:28:45 UTC" - ) - ); - assert_str_eq!( - episode_details_modal.audio_details, - formatdoc!( - "Bitrate: 0 - Channels: 7.1 - Codec: AAC - Languages: eng - Stream Count: 1" - ) - ); - assert_str_eq!( - episode_details_modal.video_details, - formatdoc!( - "Bit Depth: 10 - Bitrate: 0 - Codec: x265 - FPS: 23.976 - Resolution: 1920x1080 - Scan Type: Progressive - Runtime: 23:51 - Subtitles: English" - ) - ); - } + .is_some() + ); + assert_eq!(episode, response); + + let app = app_arc.lock().await; + let episode_details_modal = app + .data + .sonarr_data + .season_details_modal + .as_ref() + .unwrap() + .episode_details_modal + .as_ref() + .unwrap(); + assert_str_eq!( + episode_details_modal.episode_details.get_text(), + formatdoc!( + "Title: Something cool + Season: 1 + Episode Number: 1 + Air Date: 2024-02-10 07:28:45 UTC + Status: Downloaded + Description: Okay so this one time at band camp..." + ) + ); + assert_str_eq!( + episode_details_modal.file_details, + formatdoc!( + "Relative Path: /season 1/episode 1.mkv + Absolute Path: /nfs/tv/series/season 1/episode 1.mkv + Size: 3.30 GB + Language: English + Date Added: 2024-02-10 07:28:45 UTC" + ) + ); + assert_str_eq!( + episode_details_modal.audio_details, + formatdoc!( + "Bitrate: 0 + Channels: 7.1 + Codec: AAC + Languages: eng + Stream Count: 1" + ) + ); + assert_str_eq!( + episode_details_modal.video_details, + formatdoc!( + "Bit Depth: 10 + Bitrate: 0 + Codec: x265 + FPS: 23.976 + Resolution: 1920x1080 + Scan Type: Progressive + Runtime: 23:51 + Subtitles: English" + ) + ); } #[tokio::test] @@ -1027,14 +1036,15 @@ mod tests { app_arc.lock().await.server_tabs.next(); let mut network = test_network(&app_arc); - if let SonarrSerdeable::Episode(episode) = network + let SonarrSerdeable::Episode(episode) = network .handle_sonarr_event(SonarrEvent::GetEpisodeDetails(1)) .await .unwrap() - { - async_server.assert_async().await; - assert_eq!(episode, response); - } + else { + panic!("Expected Episode") + }; + async_server.assert_async().await; + assert_eq!(episode, response); } #[tokio::test] @@ -1092,30 +1102,31 @@ mod tests { app_arc.lock().await.server_tabs.next(); let mut network = test_network(&app_arc); - if let SonarrSerdeable::Releases(releases_vec) = network + let SonarrSerdeable::Releases(releases_vec) = network .handle_sonarr_event(SonarrEvent::GetEpisodeReleases(1)) .await .unwrap() - { - async_server.assert_async().await; - assert_eq!( - app_arc - .lock() - .await - .data - .sonarr_data - .season_details_modal - .as_ref() - .unwrap() - .episode_details_modal - .as_ref() - .unwrap() - .episode_releases - .items, - vec![release()] - ); - assert_eq!(releases_vec, vec![release()]); - } + else { + panic!("Expected Releases") + }; + async_server.assert_async().await; + assert_eq!( + app_arc + .lock() + .await + .data + .sonarr_data + .season_details_modal + .as_ref() + .unwrap() + .episode_details_modal + .as_ref() + .unwrap() + .episode_releases + .items, + vec![release()] + ); + assert_eq!(releases_vec, vec![release()]); } #[tokio::test] @@ -1146,30 +1157,31 @@ mod tests { app_arc.lock().await.server_tabs.next(); let mut network = test_network(&app_arc); - if let SonarrSerdeable::Releases(releases_vec) = network + let SonarrSerdeable::Releases(releases_vec) = network .handle_sonarr_event(SonarrEvent::GetEpisodeReleases(1)) .await .unwrap() - { - async_server.assert_async().await; - assert_eq!( - app_arc - .lock() - .await - .data - .sonarr_data - .season_details_modal - .as_ref() - .unwrap() - .episode_details_modal - .as_ref() - .unwrap() - .episode_releases - .items, - vec![release()] - ); - assert_eq!(releases_vec, vec![release()]); - } + else { + panic!("Expected Releases") + }; + async_server.assert_async().await; + assert_eq!( + app_arc + .lock() + .await + .data + .sonarr_data + .season_details_modal + .as_ref() + .unwrap() + .episode_details_modal + .as_ref() + .unwrap() + .episode_releases + .items, + vec![release()] + ); + assert_eq!(releases_vec, vec![release()]); } #[tokio::test] diff --git a/src/network/sonarr_network/library/seasons/sonarr_seasons_network_tests.rs b/src/network/sonarr_network/library/seasons/sonarr_seasons_network_tests.rs index 69db1ac..25fb1f1 100644 --- a/src/network/sonarr_network/library/seasons/sonarr_seasons_network_tests.rs +++ b/src/network/sonarr_network/library/seasons/sonarr_seasons_network_tests.rs @@ -136,27 +136,28 @@ mod tests { app.lock().await.server_tabs.next(); let mut network = test_network(&app); - if let SonarrSerdeable::Releases(releases_vec) = network + let SonarrSerdeable::Releases(releases_vec) = network .handle_sonarr_event(SonarrEvent::GetSeasonReleases((1, 1))) .await .unwrap() - { - mock.assert_async().await; - assert_eq!( - app - .lock() - .await - .data - .sonarr_data - .season_details_modal - .as_ref() - .unwrap() - .season_releases - .items, - vec![expected_filtered_sonarr_release] - ); - assert_eq!(releases_vec, expected_raw_sonarr_releases); - } + else { + panic!("Expected Releases") + }; + mock.assert_async().await; + assert_eq!( + app + .lock() + .await + .data + .sonarr_data + .season_details_modal + .as_ref() + .unwrap() + .season_releases + .items, + vec![expected_filtered_sonarr_release] + ); + assert_eq!(releases_vec, expected_raw_sonarr_releases); } #[tokio::test] @@ -319,39 +320,40 @@ mod tests { app.lock().await.server_tabs.next(); let mut network = test_network(&app); - if let SonarrSerdeable::SonarrHistoryItems(history) = network + let SonarrSerdeable::SonarrHistoryItems(history) = network .handle_sonarr_event(SonarrEvent::GetSeasonHistory((1, 1))) .await .unwrap() - { - mock.assert_async().await; - assert_eq!( - app - .lock() - .await - .data - .sonarr_data - .season_details_modal - .as_ref() - .unwrap() - .season_history - .items, - expected_history_items - ); - assert!( - app - .lock() - .await - .data - .sonarr_data - .season_details_modal - .as_ref() - .unwrap() - .season_history - .sort_asc - ); - assert_eq!(history, response); - } + else { + panic!("Expected SonarrHistoryItems") + }; + mock.assert_async().await; + assert_eq!( + app + .lock() + .await + .data + .sonarr_data + .season_details_modal + .as_ref() + .unwrap() + .season_history + .items, + expected_history_items + ); + assert!( + app + .lock() + .await + .data + .sonarr_data + .season_details_modal + .as_ref() + .unwrap() + .season_history + .sort_asc + ); + assert_eq!(history, response); } #[tokio::test] @@ -419,48 +421,49 @@ mod tests { app.lock().await.server_tabs.next(); let mut network = test_network(&app); - if let SonarrSerdeable::SonarrHistoryItems(history) = network + let SonarrSerdeable::SonarrHistoryItems(history) = network .handle_sonarr_event(SonarrEvent::GetSeasonHistory((1, 1))) .await .unwrap() - { - mock.assert_async().await; - assert!( - app - .lock() - .await - .data - .sonarr_data - .season_details_modal - .is_some() - ); - assert_eq!( - app - .lock() - .await - .data - .sonarr_data - .season_details_modal - .as_ref() - .unwrap() - .season_history - .items, - expected_history_items - ); - assert!( - !app - .lock() - .await - .data - .sonarr_data - .season_details_modal - .as_ref() - .unwrap() - .season_history - .sort_asc - ); - assert_eq!(history, response); - } + else { + panic!("Expected SonarrHistoryItems") + }; + mock.assert_async().await; + assert!( + app + .lock() + .await + .data + .sonarr_data + .season_details_modal + .is_some() + ); + assert_eq!( + app + .lock() + .await + .data + .sonarr_data + .season_details_modal + .as_ref() + .unwrap() + .season_history + .items, + expected_history_items + ); + assert!( + !app + .lock() + .await + .data + .sonarr_data + .season_details_modal + .as_ref() + .unwrap() + .season_history + .sort_asc + ); + assert_eq!(history, response); } #[tokio::test] diff --git a/src/network/sonarr_network/library/series/sonarr_series_network_tests.rs b/src/network/sonarr_network/library/series/sonarr_series_network_tests.rs index e1f5f31..fabd110 100644 --- a/src/network/sonarr_network/library/series/sonarr_series_network_tests.rs +++ b/src/network/sonarr_network/library/series/sonarr_series_network_tests.rs @@ -409,14 +409,15 @@ mod tests { app.lock().await.server_tabs.next(); let mut network = test_network(&app); - if let SonarrSerdeable::Series(series) = network + let SonarrSerdeable::Series(series) = network .handle_sonarr_event(SonarrEvent::GetSeriesDetails(1)) .await .unwrap() - { - async_server.assert_async().await; - assert_eq!(series, expected_series); - } + else { + panic!("Expected Series") + }; + async_server.assert_async().await; + assert_eq!(series, expected_series); } #[rstest] @@ -500,38 +501,39 @@ mod tests { app.lock().await.server_tabs.next(); let mut network = test_network(&app); - if let SonarrSerdeable::SonarrHistoryItems(history_items) = network + let SonarrSerdeable::SonarrHistoryItems(history_items) = network .handle_sonarr_event(SonarrEvent::GetSeriesHistory(1)) .await .unwrap() - { - async_server.assert_async().await; - assert!(app.lock().await.data.sonarr_data.series_history.is_some()); - assert_eq!( - app - .lock() - .await - .data - .sonarr_data - .series_history - .as_ref() - .unwrap() - .items, - expected_history_items - ); - assert!( - app - .lock() - .await - .data - .sonarr_data - .series_history - .as_ref() - .unwrap() - .sort_asc - ); - assert_eq!(history_items, response); - } + else { + panic!("Expected SonarrHistoryItems") + }; + async_server.assert_async().await; + assert!(app.lock().await.data.sonarr_data.series_history.is_some()); + assert_eq!( + app + .lock() + .await + .data + .sonarr_data + .series_history + .as_ref() + .unwrap() + .items, + expected_history_items + ); + assert!( + app + .lock() + .await + .data + .sonarr_data + .series_history + .as_ref() + .unwrap() + .sort_asc + ); + assert_eq!(history_items, response); } #[tokio::test] @@ -592,38 +594,39 @@ mod tests { app.lock().await.server_tabs.next(); let mut network = test_network(&app); - if let SonarrSerdeable::SonarrHistoryItems(history_items) = network + let SonarrSerdeable::SonarrHistoryItems(history_items) = network .handle_sonarr_event(SonarrEvent::GetSeriesHistory(1)) .await .unwrap() - { - async_server.assert_async().await; - assert!(app.lock().await.data.sonarr_data.series_history.is_some()); - assert_eq!( - app - .lock() - .await - .data - .sonarr_data - .series_history - .as_ref() - .unwrap() - .items, - expected_history_items - ); - assert!( - !app - .lock() - .await - .data - .sonarr_data - .series_history - .as_ref() - .unwrap() - .sort_asc - ); - assert_eq!(history_items, response); - } + else { + panic!("Expected SonarrHistoryItems") + }; + async_server.assert_async().await; + assert!(app.lock().await.data.sonarr_data.series_history.is_some()); + assert_eq!( + app + .lock() + .await + .data + .sonarr_data + .series_history + .as_ref() + .unwrap() + .items, + expected_history_items + ); + assert!( + !app + .lock() + .await + .data + .sonarr_data + .series_history + .as_ref() + .unwrap() + .sort_asc + ); + assert_eq!(history_items, response); } #[tokio::test] @@ -690,37 +693,38 @@ mod tests { app.lock().await.server_tabs.next(); let mut network = test_network(&app); - if let SonarrSerdeable::SonarrHistoryItems(history_items) = network + let SonarrSerdeable::SonarrHistoryItems(history_items) = network .handle_sonarr_event(SonarrEvent::GetSeriesHistory(1)) .await .unwrap() - { - async_server.assert_async().await; - assert!(app.lock().await.data.sonarr_data.series_history.is_some()); - assert!( - app - .lock() - .await - .data - .sonarr_data - .series_history - .as_ref() - .unwrap() - .is_empty() - ); - assert!( - app - .lock() - .await - .data - .sonarr_data - .series_history - .as_ref() - .unwrap() - .sort_asc - ); - assert_eq!(history_items, response); - } + else { + panic!("Expected SonarrHistoryItems") + }; + async_server.assert_async().await; + assert!(app.lock().await.data.sonarr_data.series_history.is_some()); + assert!( + app + .lock() + .await + .data + .sonarr_data + .series_history + .as_ref() + .unwrap() + .is_empty() + ); + assert!( + app + .lock() + .await + .data + .sonarr_data + .series_history + .as_ref() + .unwrap() + .sort_asc + ); + assert_eq!(history_items, response); } #[rstest] @@ -784,19 +788,20 @@ mod tests { app.lock().await.server_tabs.next(); let mut network = test_network(&app); - if let SonarrSerdeable::SeriesVec(series) = network + let SonarrSerdeable::SeriesVec(series) = network .handle_sonarr_event(SonarrEvent::ListSeries) .await .unwrap() - { - async_server.assert_async().await; - assert_eq!( - app.lock().await.data.sonarr_data.series.items, - expected_sorted_series - ); - assert!(app.lock().await.data.sonarr_data.series.sort_asc); - assert_eq!(series, expected_series); - } + else { + panic!("Expected SeriesVec") + }; + async_server.assert_async().await; + assert_eq!( + app.lock().await.data.sonarr_data.series.items, + expected_sorted_series + ); + assert!(app.lock().await.data.sonarr_data.series.sort_asc); + assert_eq!(series, expected_series); } #[tokio::test] @@ -872,35 +877,36 @@ mod tests { app.lock().await.server_tabs.next(); let mut network = test_network(&app); - if let SonarrSerdeable::AddSeriesSearchResults(add_series_search_results) = network + let SonarrSerdeable::AddSeriesSearchResults(add_series_search_results) = network .handle_sonarr_event(SonarrEvent::SearchNewSeries("test term".into())) .await .unwrap() - { - async_server.assert_async().await; - assert!( - app - .lock() - .await - .data - .sonarr_data - .add_searched_series - .is_some() - ); - assert_eq!( - app - .lock() - .await - .data - .sonarr_data - .add_searched_series - .as_ref() - .unwrap() - .items, - vec![add_series_search_result()] - ); - assert_eq!(add_series_search_results, vec![add_series_search_result()]); - } + else { + panic!("Expected AddSeriesSearchResults") + }; + async_server.assert_async().await; + assert!( + app + .lock() + .await + .data + .sonarr_data + .add_searched_series + .is_some() + ); + assert_eq!( + app + .lock() + .await + .data + .sonarr_data + .add_searched_series + .as_ref() + .unwrap() + .items, + vec![add_series_search_result()] + ); + assert_eq!(add_series_search_results, vec![add_series_search_result()]); } #[tokio::test] diff --git a/src/network/sonarr_network/root_folders/sonarr_root_folders_network_tests.rs b/src/network/sonarr_network/root_folders/sonarr_root_folders_network_tests.rs index 9cdb416..cd77d8e 100644 --- a/src/network/sonarr_network/root_folders/sonarr_root_folders_network_tests.rs +++ b/src/network/sonarr_network/root_folders/sonarr_root_folders_network_tests.rs @@ -71,17 +71,18 @@ mod tests { app.lock().await.server_tabs.next(); let mut network = test_network(&app); - if let SonarrSerdeable::RootFolders(root_folders) = network + let SonarrSerdeable::RootFolders(root_folders) = network .handle_sonarr_event(SonarrEvent::GetRootFolders) .await .unwrap() - { - mock.assert_async().await; - assert_eq!( - app.lock().await.data.sonarr_data.root_folders.items, - vec![root_folder()] - ); - assert_eq!(root_folders, response); - } + else { + panic!("Expected RootFolders") + }; + mock.assert_async().await; + assert_eq!( + app.lock().await.data.sonarr_data.root_folders.items, + vec![root_folder()] + ); + assert_eq!(root_folders, response); } } diff --git a/src/network/sonarr_network/sonarr_network_tests.rs b/src/network/sonarr_network/sonarr_network_tests.rs index 87bdb62..87aa4ce 100644 --- a/src/network/sonarr_network/sonarr_network_tests.rs +++ b/src/network/sonarr_network/sonarr_network_tests.rs @@ -212,8 +212,9 @@ mod test { mock.assert_async().await; let SonarrSerdeable::Tag(tag) = result.unwrap() else { - panic!("Expected Tag variant"); + panic!("Expected Tag"); }; + assert_eq!(tag, expected); assert_eq!( app.lock().await.data.sonarr_data.tags_map, @@ -278,8 +279,9 @@ mod test { mock.assert_async().await; let SonarrSerdeable::LanguageProfiles(language_profiles) = result.unwrap() else { - panic!("Expected the LanguageProfiles variant") + panic!("Expected LanguageProfiles") }; + assert_eq!( app.lock().await.data.sonarr_data.language_profiles_map, BiMap::from_iter([(2222i64, "English".to_owned())]) @@ -309,8 +311,9 @@ mod test { mock.assert_async().await; let SonarrSerdeable::QualityProfiles(quality_profiles) = result.unwrap() else { - panic!("Expected the QualityProfiles variant") + panic!("Expected QualityProfiles") }; + assert_eq!( app.lock().await.data.sonarr_data.quality_profile_map, BiMap::from_iter([(2222i64, "HD - 1080p".to_owned())]) @@ -337,8 +340,9 @@ mod test { mock.assert_async().await; let SonarrSerdeable::Tags(tags) = result.unwrap() else { - panic!("Expected the Tag variant") + panic!("Expected Tags") }; + mock.assert_async().await; assert_eq!( app.lock().await.data.sonarr_data.tags_map, diff --git a/src/network/sonarr_network/system/sonarr_system_network_tests.rs b/src/network/sonarr_network/system/sonarr_system_network_tests.rs index 0e001c5..99c3f58 100644 --- a/src/network/sonarr_network/system/sonarr_system_network_tests.rs +++ b/src/network/sonarr_network/system/sonarr_system_network_tests.rs @@ -33,14 +33,15 @@ mod tests { app.lock().await.server_tabs.next(); let mut network = test_network(&app); - if let SonarrSerdeable::HostConfig(host_config) = network + let SonarrSerdeable::HostConfig(host_config) = network .handle_sonarr_event(SonarrEvent::GetHostConfig) .await .unwrap() - { - mock.assert_async().await; - assert_eq!(host_config, response); - } + else { + panic!("Expected HostConfig") + }; + mock.assert_async().await; + assert_eq!(host_config, response); } #[tokio::test] @@ -84,26 +85,27 @@ mod tests { app.lock().await.server_tabs.next(); let mut network = test_network(&app); - if let SonarrSerdeable::LogResponse(logs) = network + let SonarrSerdeable::LogResponse(logs) = network .handle_sonarr_event(SonarrEvent::GetLogs(500)) .await .unwrap() - { - mock.assert_async().await; - assert_eq!(app.lock().await.data.sonarr_data.logs.items, expected_logs); - assert!( - app - .lock() - .await - .data - .sonarr_data - .logs - .current_selection() - .text - .contains("INFO") - ); - assert_eq!(logs, response); - } + else { + panic!("Expected LogResponse") + }; + mock.assert_async().await; + assert_eq!(app.lock().await.data.sonarr_data.logs.items, expected_logs); + assert!( + app + .lock() + .await + .data + .sonarr_data + .logs + .current_selection() + .text + .contains("INFO") + ); + assert_eq!(logs, response); } #[tokio::test] @@ -134,18 +136,19 @@ mod tests { }, ]; - if let SonarrSerdeable::DiskSpaces(disk_space) = network + let SonarrSerdeable::DiskSpaces(disk_space) = network .handle_sonarr_event(SonarrEvent::GetDiskSpace) .await .unwrap() - { - mock.assert_async().await; - assert_eq!( - app.lock().await.data.sonarr_data.disk_space_vec, - disk_space_vec - ); - assert_eq!(disk_space, disk_space_vec); - } + else { + panic!("Expected DiskSpaces") + }; + mock.assert_async().await; + assert_eq!( + app.lock().await.data.sonarr_data.disk_space_vec, + disk_space_vec + ); + assert_eq!(disk_space, disk_space_vec); } #[tokio::test] @@ -180,18 +183,19 @@ mod tests { app.lock().await.server_tabs.next(); let mut network = test_network(&app); - if let SonarrSerdeable::QueueEvents(events) = network + let SonarrSerdeable::QueueEvents(events) = network .handle_sonarr_event(SonarrEvent::GetQueuedEvents) .await .unwrap() - { - mock.assert_async().await; - assert_eq!( - app.lock().await.data.sonarr_data.queued_events.items, - vec![expected_event] - ); - assert_eq!(events, response); - } + else { + panic!("Expected QueueEvents") + }; + mock.assert_async().await; + assert_eq!( + app.lock().await.data.sonarr_data.queued_events.items, + vec![expected_event] + ); + assert_eq!(events, response); } #[tokio::test] @@ -213,14 +217,15 @@ mod tests { app.lock().await.server_tabs.next(); let mut network = test_network(&app); - if let SonarrSerdeable::SecurityConfig(security_config) = network + let SonarrSerdeable::SecurityConfig(security_config) = network .handle_sonarr_event(SonarrEvent::GetSecurityConfig) .await .unwrap() - { - mock.assert_async().await; - assert_eq!(security_config, response); - } + else { + panic!("Expected SecurityConfig") + }; + mock.assert_async().await; + assert_eq!(security_config, response); } #[tokio::test] @@ -236,22 +241,23 @@ mod tests { let mut network = test_network(&app); let date_time = DateTime::from(DateTime::parse_from_rfc3339("2023-02-25T20:16:43Z").unwrap()); - if let SonarrSerdeable::SystemStatus(status) = network + let SonarrSerdeable::SystemStatus(status) = network .handle_sonarr_event(SonarrEvent::GetStatus) .await .unwrap() - { - mock.assert_async().await; - assert_str_eq!(app.lock().await.data.sonarr_data.version, "v1"); - assert_eq!(app.lock().await.data.sonarr_data.start_time, date_time); - assert_eq!( - status, - SystemStatus { - version: "v1".to_owned(), - start_time: date_time - } - ); - } + else { + panic!("Expected SystemStatus") + }; + mock.assert_async().await; + assert_str_eq!(app.lock().await.data.sonarr_data.version, "v1"); + assert_eq!(app.lock().await.data.sonarr_data.start_time, date_time); + assert_eq!( + status, + SystemStatus { + version: "v1".to_owned(), + start_time: date_time + } + ); } #[tokio::test] @@ -295,18 +301,19 @@ mod tests { app.lock().await.server_tabs.next(); let mut network = test_network(&app); - if let SonarrSerdeable::Tasks(tasks) = network + let SonarrSerdeable::Tasks(tasks) = network .handle_sonarr_event(SonarrEvent::GetTasks) .await .unwrap() - { - mock.assert_async().await; - assert_eq!( - app.lock().await.data.sonarr_data.tasks.items, - expected_tasks - ); - assert_eq!(tasks, response); - } + else { + panic!("Expected Tasks") + }; + mock.assert_async().await; + assert_eq!( + app.lock().await.data.sonarr_data.tasks.items, + expected_tasks + ); + assert_eq!(tasks, response); } #[tokio::test] @@ -385,25 +392,26 @@ mod tests { app.lock().await.server_tabs.next(); let mut network = test_network(&app); - if let SonarrSerdeable::Updates(updates) = network + let SonarrSerdeable::Updates(updates) = network .handle_sonarr_event(SonarrEvent::GetUpdates) .await .unwrap() - { - mock.assert_async().await; - let actual_text = app.lock().await.data.sonarr_data.updates.get_text(); - let expected = expected_text.get_text(); + else { + panic!("Expected Updates") + }; + mock.assert_async().await; + let actual_text = app.lock().await.data.sonarr_data.updates.get_text(); + let expected = expected_text.get_text(); - // Trim trailing whitespace from each line for comparison - let actual_trimmed: Vec<&str> = actual_text.lines().map(|l| l.trim_end()).collect(); - let expected_trimmed: Vec<&str> = expected.lines().map(|l| l.trim_end()).collect(); + // Trim trailing whitespace from each line for comparison + let actual_trimmed: Vec<&str> = actual_text.lines().map(|l| l.trim_end()).collect(); + let expected_trimmed: Vec<&str> = expected.lines().map(|l| l.trim_end()).collect(); - assert_eq!( - actual_trimmed, expected_trimmed, - "Updates text mismatch (after trimming trailing whitespace)" - ); - assert_eq!(updates, response); - } + assert_eq!( + actual_trimmed, expected_trimmed, + "Updates text mismatch (after trimming trailing whitespace)" + ); + assert_eq!(updates, response); } #[tokio::test] @@ -431,15 +439,16 @@ mod tests { app.lock().await.server_tabs.next(); let mut network = test_network(&app); - if let SonarrSerdeable::Value(value) = network + let SonarrSerdeable::Value(value) = network .handle_sonarr_event(SonarrEvent::StartTask( SonarrTaskName::ApplicationUpdateCheck, )) .await .unwrap() - { - mock.assert_async().await; - assert_eq!(value, response); - } + else { + panic!("Expected Value") + }; + mock.assert_async().await; + assert_eq!(value, response); } } diff --git a/src/ui/radarr_ui/blocklist/mod.rs b/src/ui/radarr_ui/blocklist/mod.rs index 1f1179a..f547564 100644 --- a/src/ui/radarr_ui/blocklist/mod.rs +++ b/src/ui/radarr_ui/blocklist/mod.rs @@ -23,11 +23,10 @@ pub(super) struct BlocklistUi; impl DrawUi for BlocklistUi { fn accepts(route: Route) -> bool { - if let Route::Radarr(active_radarr_block, _) = route { - return BLOCKLIST_BLOCKS.contains(&active_radarr_block); - } - - false + let Route::Radarr(active_radarr_block, _) = route else { + return false; + }; + BLOCKLIST_BLOCKS.contains(&active_radarr_block) } fn draw(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) { diff --git a/src/ui/radarr_ui/collections/mod.rs b/src/ui/radarr_ui/collections/mod.rs index 4e19ec8..8112bd9 100644 --- a/src/ui/radarr_ui/collections/mod.rs +++ b/src/ui/radarr_ui/collections/mod.rs @@ -25,13 +25,12 @@ pub(super) struct CollectionsUi; impl DrawUi for CollectionsUi { fn accepts(route: Route) -> bool { - if let Route::Radarr(active_radarr_block, _) = route { - return CollectionDetailsUi::accepts(route) - || EditCollectionUi::accepts(route) - || COLLECTIONS_BLOCKS.contains(&active_radarr_block); - } - - false + let Route::Radarr(active_radarr_block, _) = route else { + return false; + }; + CollectionDetailsUi::accepts(route) + || EditCollectionUi::accepts(route) + || COLLECTIONS_BLOCKS.contains(&active_radarr_block) } fn draw(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) { diff --git a/src/ui/radarr_ui/downloads/mod.rs b/src/ui/radarr_ui/downloads/mod.rs index b2a4692..e8d7973 100644 --- a/src/ui/radarr_ui/downloads/mod.rs +++ b/src/ui/radarr_ui/downloads/mod.rs @@ -22,11 +22,10 @@ pub(super) struct DownloadsUi; impl DrawUi for DownloadsUi { fn accepts(route: Route) -> bool { - if let Route::Radarr(active_radarr_block, _) = route { - return DOWNLOADS_BLOCKS.contains(&active_radarr_block); - } - - false + let Route::Radarr(active_radarr_block, _) = route else { + return false; + }; + DOWNLOADS_BLOCKS.contains(&active_radarr_block) } fn draw(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) { diff --git a/src/ui/radarr_ui/indexers/indexer_settings_ui.rs b/src/ui/radarr_ui/indexers/indexer_settings_ui.rs index a8343a9..677f17f 100644 --- a/src/ui/radarr_ui/indexers/indexer_settings_ui.rs +++ b/src/ui/radarr_ui/indexers/indexer_settings_ui.rs @@ -26,11 +26,10 @@ pub(super) struct IndexerSettingsUi; impl DrawUi for IndexerSettingsUi { fn accepts(route: Route) -> bool { - if let Route::Radarr(active_radarr_block, _) = route { - return INDEXER_SETTINGS_BLOCKS.contains(&active_radarr_block); - } - - false + let Route::Radarr(active_radarr_block, _) = route else { + return false; + }; + INDEXER_SETTINGS_BLOCKS.contains(&active_radarr_block) } fn draw(f: &mut Frame<'_>, app: &mut App<'_>, _area: Rect) { diff --git a/src/ui/radarr_ui/indexers/test_all_indexers_ui.rs b/src/ui/radarr_ui/indexers/test_all_indexers_ui.rs index afa165d..5536039 100644 --- a/src/ui/radarr_ui/indexers/test_all_indexers_ui.rs +++ b/src/ui/radarr_ui/indexers/test_all_indexers_ui.rs @@ -19,11 +19,10 @@ pub(super) struct TestAllIndexersUi; impl DrawUi for TestAllIndexersUi { fn accepts(route: Route) -> bool { - if let Route::Radarr(active_radarr_block, _) = route { - return active_radarr_block == ActiveRadarrBlock::TestAllIndexers; - } - - false + let Route::Radarr(active_radarr_block, _) = route else { + return false; + }; + active_radarr_block == ActiveRadarrBlock::TestAllIndexers } fn draw(f: &mut Frame<'_>, app: &mut App<'_>, _area: Rect) { diff --git a/src/ui/radarr_ui/library/add_movie_ui.rs b/src/ui/radarr_ui/library/add_movie_ui.rs index e6defa9..8836d82 100644 --- a/src/ui/radarr_ui/library/add_movie_ui.rs +++ b/src/ui/radarr_ui/library/add_movie_ui.rs @@ -31,11 +31,10 @@ pub(super) struct AddMovieUi; impl DrawUi for AddMovieUi { fn accepts(route: Route) -> bool { - if let Route::Radarr(active_radarr_block, _) = route { - return ADD_MOVIE_BLOCKS.contains(&active_radarr_block); - } - - false + let Route::Radarr(active_radarr_block, _) = route else { + return false; + }; + ADD_MOVIE_BLOCKS.contains(&active_radarr_block) } fn draw(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) { diff --git a/src/ui/radarr_ui/library/delete_movie_ui.rs b/src/ui/radarr_ui/library/delete_movie_ui.rs index 95ce33e..d750477 100644 --- a/src/ui/radarr_ui/library/delete_movie_ui.rs +++ b/src/ui/radarr_ui/library/delete_movie_ui.rs @@ -17,11 +17,10 @@ pub(super) struct DeleteMovieUi; impl DrawUi for DeleteMovieUi { fn accepts(route: Route) -> bool { - if let Route::Radarr(active_radarr_block, _) = route { - return DELETE_MOVIE_BLOCKS.contains(&active_radarr_block); - } - - false + let Route::Radarr(active_radarr_block, _) = route else { + return false; + }; + DELETE_MOVIE_BLOCKS.contains(&active_radarr_block) } fn draw(f: &mut Frame<'_>, app: &mut App<'_>, _area: Rect) { diff --git a/src/ui/radarr_ui/library/edit_movie_ui.rs b/src/ui/radarr_ui/library/edit_movie_ui.rs index cfc9df9..46512d4 100644 --- a/src/ui/radarr_ui/library/edit_movie_ui.rs +++ b/src/ui/radarr_ui/library/edit_movie_ui.rs @@ -31,11 +31,10 @@ pub(super) struct EditMovieUi; impl DrawUi for EditMovieUi { fn accepts(route: Route) -> bool { - if let Route::Radarr(active_radarr_block, _) = route { - return EDIT_MOVIE_BLOCKS.contains(&active_radarr_block); - } - - false + let Route::Radarr(active_radarr_block, _) = route else { + return false; + }; + EDIT_MOVIE_BLOCKS.contains(&active_radarr_block) } fn draw(f: &mut Frame<'_>, app: &mut App<'_>, _area: Rect) { diff --git a/src/ui/radarr_ui/library/movie_details_ui.rs b/src/ui/radarr_ui/library/movie_details_ui.rs index 53b3a77..fddc871 100644 --- a/src/ui/radarr_ui/library/movie_details_ui.rs +++ b/src/ui/radarr_ui/library/movie_details_ui.rs @@ -32,11 +32,10 @@ pub(super) struct MovieDetailsUi; impl DrawUi for MovieDetailsUi { fn accepts(route: Route) -> bool { - if let Route::Radarr(active_radarr_block, _) = route { - return MOVIE_DETAILS_BLOCKS.contains(&active_radarr_block); - } - - false + let Route::Radarr(active_radarr_block, _) = route else { + return false; + }; + MOVIE_DETAILS_BLOCKS.contains(&active_radarr_block) } fn draw(f: &mut Frame<'_>, app: &mut App<'_>, _area: Rect) { diff --git a/src/ui/radarr_ui/root_folders/mod.rs b/src/ui/radarr_ui/root_folders/mod.rs index 36bdc1e..9c5ecfe 100644 --- a/src/ui/radarr_ui/root_folders/mod.rs +++ b/src/ui/radarr_ui/root_folders/mod.rs @@ -22,11 +22,10 @@ pub(super) struct RootFoldersUi; impl DrawUi for RootFoldersUi { fn accepts(route: Route) -> bool { - if let Route::Radarr(active_radarr_block, _) = route { - return ROOT_FOLDERS_BLOCKS.contains(&active_radarr_block); - } - - false + let Route::Radarr(active_radarr_block, _) = route else { + return false; + }; + ROOT_FOLDERS_BLOCKS.contains(&active_radarr_block) } fn draw(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) { diff --git a/src/ui/radarr_ui/system/mod.rs b/src/ui/radarr_ui/system/mod.rs index 10e0d20..f876ee1 100644 --- a/src/ui/radarr_ui/system/mod.rs +++ b/src/ui/radarr_ui/system/mod.rs @@ -52,11 +52,10 @@ pub(super) struct SystemUi; impl DrawUi for SystemUi { fn accepts(route: Route) -> bool { - if let Route::Radarr(active_radarr_block, _) = route { - return SystemDetailsUi::accepts(route) || active_radarr_block == ActiveRadarrBlock::System; - } - - false + let Route::Radarr(active_radarr_block, _) = route else { + return false; + }; + SystemDetailsUi::accepts(route) || active_radarr_block == ActiveRadarrBlock::System } fn draw(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) { diff --git a/src/ui/radarr_ui/system/system_details_ui.rs b/src/ui/radarr_ui/system/system_details_ui.rs index ee0741a..bc8db27 100644 --- a/src/ui/radarr_ui/system/system_details_ui.rs +++ b/src/ui/radarr_ui/system/system_details_ui.rs @@ -27,11 +27,10 @@ pub(super) struct SystemDetailsUi; impl DrawUi for SystemDetailsUi { fn accepts(route: Route) -> bool { - if let Route::Radarr(active_radarr_block, _) = route { - return SYSTEM_DETAILS_BLOCKS.contains(&active_radarr_block); - } - - false + let Route::Radarr(active_radarr_block, _) = route else { + return false; + }; + SYSTEM_DETAILS_BLOCKS.contains(&active_radarr_block) } fn draw(f: &mut Frame<'_>, app: &mut App<'_>, _area: Rect) { diff --git a/src/ui/sonarr_ui/indexers/edit_indexer_ui.rs b/src/ui/sonarr_ui/indexers/edit_indexer_ui.rs index 0bb7e06..c12cafe 100644 --- a/src/ui/sonarr_ui/indexers/edit_indexer_ui.rs +++ b/src/ui/sonarr_ui/indexers/edit_indexer_ui.rs @@ -23,11 +23,10 @@ pub(super) struct EditIndexerUi; impl DrawUi for EditIndexerUi { fn accepts(route: Route) -> bool { - if let Route::Sonarr(active_sonarr_block, _) = route { - return EDIT_INDEXER_BLOCKS.contains(&active_sonarr_block); - } - - false + let Route::Sonarr(active_sonarr_block, _) = route else { + return false; + }; + EDIT_INDEXER_BLOCKS.contains(&active_sonarr_block) } fn draw(f: &mut Frame<'_>, app: &mut App<'_>, _area: Rect) { diff --git a/src/ui/sonarr_ui/indexers/indexer_settings_ui.rs b/src/ui/sonarr_ui/indexers/indexer_settings_ui.rs index f606bdb..5dcdce9 100644 --- a/src/ui/sonarr_ui/indexers/indexer_settings_ui.rs +++ b/src/ui/sonarr_ui/indexers/indexer_settings_ui.rs @@ -23,11 +23,10 @@ pub(super) struct IndexerSettingsUi; impl DrawUi for IndexerSettingsUi { fn accepts(route: Route) -> bool { - if let Route::Sonarr(active_sonarr_block, _) = route { - return INDEXER_SETTINGS_BLOCKS.contains(&active_sonarr_block); - } - - false + let Route::Sonarr(active_sonarr_block, _) = route else { + return false; + }; + INDEXER_SETTINGS_BLOCKS.contains(&active_sonarr_block) } fn draw(f: &mut Frame<'_>, app: &mut App<'_>, _area: Rect) { diff --git a/src/ui/sonarr_ui/library/add_series_ui.rs b/src/ui/sonarr_ui/library/add_series_ui.rs index f852215..477f5a2 100644 --- a/src/ui/sonarr_ui/library/add_series_ui.rs +++ b/src/ui/sonarr_ui/library/add_series_ui.rs @@ -30,11 +30,10 @@ pub(super) struct AddSeriesUi; impl DrawUi for AddSeriesUi { fn accepts(route: Route) -> bool { - if let Route::Sonarr(active_sonarr_block, _) = route { - return ADD_SERIES_BLOCKS.contains(&active_sonarr_block); - } - - false + let Route::Sonarr(active_sonarr_block, _) = route else { + return false; + }; + ADD_SERIES_BLOCKS.contains(&active_sonarr_block) } fn draw(f: &mut Frame<'_>, app: &mut App<'_>, _area: Rect) { diff --git a/src/ui/sonarr_ui/library/delete_series_ui.rs b/src/ui/sonarr_ui/library/delete_series_ui.rs index 71b3974..c5e33b0 100644 --- a/src/ui/sonarr_ui/library/delete_series_ui.rs +++ b/src/ui/sonarr_ui/library/delete_series_ui.rs @@ -17,11 +17,10 @@ pub(super) struct DeleteSeriesUi; impl DrawUi for DeleteSeriesUi { fn accepts(route: Route) -> bool { - if let Route::Sonarr(active_sonarr_block, _) = route { - return DELETE_SERIES_BLOCKS.contains(&active_sonarr_block); - } - - false + let Route::Sonarr(active_sonarr_block, _) = route else { + return false; + }; + DELETE_SERIES_BLOCKS.contains(&active_sonarr_block) } fn draw(f: &mut Frame<'_>, app: &mut App<'_>, _area: Rect) { diff --git a/src/ui/sonarr_ui/library/edit_series_ui.rs b/src/ui/sonarr_ui/library/edit_series_ui.rs index 5116a91..f7086ba 100644 --- a/src/ui/sonarr_ui/library/edit_series_ui.rs +++ b/src/ui/sonarr_ui/library/edit_series_ui.rs @@ -32,11 +32,10 @@ pub(super) struct EditSeriesUi; impl DrawUi for EditSeriesUi { fn accepts(route: Route) -> bool { - if let Route::Sonarr(active_sonarr_block, _) = route { - return EDIT_SERIES_BLOCKS.contains(&active_sonarr_block); - } - - false + let Route::Sonarr(active_sonarr_block, _) = route else { + return false; + }; + EDIT_SERIES_BLOCKS.contains(&active_sonarr_block) } fn draw(f: &mut Frame<'_>, app: &mut App<'_>, _area: Rect) { diff --git a/src/ui/sonarr_ui/library/episode_details_ui.rs b/src/ui/sonarr_ui/library/episode_details_ui.rs index fda994d..67196ac 100644 --- a/src/ui/sonarr_ui/library/episode_details_ui.rs +++ b/src/ui/sonarr_ui/library/episode_details_ui.rs @@ -39,11 +39,10 @@ pub(super) struct EpisodeDetailsUi; impl DrawUi for EpisodeDetailsUi { fn accepts(route: Route) -> bool { - if let Route::Sonarr(active_sonarr_block, _) = route { - return EPISODE_DETAILS_BLOCKS.contains(&active_sonarr_block); - } - - false + let Route::Sonarr(active_sonarr_block, _) = route else { + return false; + }; + EPISODE_DETAILS_BLOCKS.contains(&active_sonarr_block) } fn draw(f: &mut Frame<'_>, app: &mut App<'_>, _area: Rect) { diff --git a/src/ui/sonarr_ui/library/season_details_ui.rs b/src/ui/sonarr_ui/library/season_details_ui.rs index ed83e5b..276e3be 100644 --- a/src/ui/sonarr_ui/library/season_details_ui.rs +++ b/src/ui/sonarr_ui/library/season_details_ui.rs @@ -38,12 +38,10 @@ pub(super) struct SeasonDetailsUi; impl DrawUi for SeasonDetailsUi { fn accepts(route: Route) -> bool { - if let Route::Sonarr(active_sonarr_block, _) = route { - return EpisodeDetailsUi::accepts(route) - || SEASON_DETAILS_BLOCKS.contains(&active_sonarr_block); - } - - false + let Route::Sonarr(active_sonarr_block, _) = route else { + return false; + }; + EpisodeDetailsUi::accepts(route) || SEASON_DETAILS_BLOCKS.contains(&active_sonarr_block) } fn draw(f: &mut Frame<'_>, app: &mut App<'_>, _area: Rect) { diff --git a/src/ui/sonarr_ui/library/series_details_ui.rs b/src/ui/sonarr_ui/library/series_details_ui.rs index 38da6d7..b134403 100644 --- a/src/ui/sonarr_ui/library/series_details_ui.rs +++ b/src/ui/sonarr_ui/library/series_details_ui.rs @@ -42,13 +42,12 @@ pub(super) struct SeriesDetailsUi; impl DrawUi for SeriesDetailsUi { fn accepts(route: Route) -> bool { - if let Route::Sonarr(active_sonarr_block, _) = route { - return SeasonDetailsUi::accepts(route) - || EpisodeDetailsUi::accepts(route) - || SERIES_DETAILS_BLOCKS.contains(&active_sonarr_block); - } - - false + let Route::Sonarr(active_sonarr_block, _) = route else { + return false; + }; + SeasonDetailsUi::accepts(route) + || EpisodeDetailsUi::accepts(route) + || SERIES_DETAILS_BLOCKS.contains(&active_sonarr_block) } fn draw(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) { diff --git a/src/ui/sonarr_ui/system/mod.rs b/src/ui/sonarr_ui/system/mod.rs index 3006b4f..7876112 100644 --- a/src/ui/sonarr_ui/system/mod.rs +++ b/src/ui/sonarr_ui/system/mod.rs @@ -46,11 +46,10 @@ pub(super) struct SystemUi; impl DrawUi for SystemUi { fn accepts(route: Route) -> bool { - if let Route::Sonarr(active_sonarr_block, _) = route { - return SystemDetailsUi::accepts(route) || active_sonarr_block == ActiveSonarrBlock::System; - } - - false + let Route::Sonarr(active_sonarr_block, _) = route else { + return false; + }; + SystemDetailsUi::accepts(route) || active_sonarr_block == ActiveSonarrBlock::System } fn draw(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) { diff --git a/src/ui/sonarr_ui/system/system_details_ui.rs b/src/ui/sonarr_ui/system/system_details_ui.rs index 23eb01e..f25c5e9 100644 --- a/src/ui/sonarr_ui/system/system_details_ui.rs +++ b/src/ui/sonarr_ui/system/system_details_ui.rs @@ -27,11 +27,10 @@ pub(super) struct SystemDetailsUi; impl DrawUi for SystemDetailsUi { fn accepts(route: Route) -> bool { - if let Route::Sonarr(active_sonarr_block, _) = route { - return SYSTEM_DETAILS_BLOCKS.contains(&active_sonarr_block); - } - - false + let Route::Sonarr(active_sonarr_block, _) = route else { + return false; + }; + SYSTEM_DETAILS_BLOCKS.contains(&active_sonarr_block) } fn draw(f: &mut Frame<'_>, app: &mut App<'_>, _area: Rect) {