Dark-Alex-17/managarr
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor: Refactored to use more idiomatic let-else statements where applicable

Browse Source
This commit is contained in:
Alex Clarke
2025-12-03 15:23:07 -07:00
parent ad58912baf
commit e50fb88bfc
43 changed files with 1337 additions and 1291 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/handlers/radarr_handlers/library/movie_details_handler.rs
+16 -20
View File
@@ -158,27 +158,23 @@ impl<'a, 'b> KeyEventHandler<'a, 'b, ActiveRadarrBlock> for MovieDetailsHandler<
} }
fn is_ready(&self) -> bool { fn is_ready(&self) -> bool {
if let Some(movie_details_modal) = &self.app.data.radarr_data.movie_details_modal { let Some(movie_details_modal) = &self.app.data.radarr_data.movie_details_modal else {
match self.active_radarr_block { return false;
ActiveRadarrBlock::MovieDetails => { };
!self.app.is_loading && !movie_details_modal.movie_details.is_empty()
} match self.active_radarr_block {
ActiveRadarrBlock::MovieHistory => { ActiveRadarrBlock::MovieDetails => {
!self.app.is_loading && !movie_details_modal.movie_history.is_empty() !self.app.is_loading && !movie_details_modal.movie_details.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,
} }
} else { ActiveRadarrBlock::MovieHistory => {
false !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,
} }
} }
src/handlers/sonarr_handlers/library/episode_details_handler.rs
+17 -17
View File
@@ -110,23 +110,23 @@ impl<'a, 'b> KeyEventHandler<'a, 'b, ActiveSonarrBlock> for EpisodeDetailsHandle
} }
fn is_ready(&self) -> bool { fn is_ready(&self) -> bool {
!self.app.is_loading if self.app.is_loading {
&& if let Some(season_details_modal) = self.app.data.sonarr_data.season_details_modal.as_ref() return false;
{ }
if let Some(episode_details_modal) = &season_details_modal.episode_details_modal {
match self.active_sonarr_block { let Some(season_details_modal) = self.app.data.sonarr_data.season_details_modal.as_ref() else {
ActiveSonarrBlock::EpisodeHistory => !episode_details_modal.episode_history.is_empty(), return false;
ActiveSonarrBlock::ManualEpisodeSearch => { };
!episode_details_modal.episode_releases.is_empty()
} let Some(episode_details_modal) = &season_details_modal.episode_details_modal else {
_ => true, return false;
} };
} else {
false match self.active_sonarr_block {
} ActiveSonarrBlock::EpisodeHistory => !episode_details_modal.episode_history.is_empty(),
} else { ActiveSonarrBlock::ManualEpisodeSearch => !episode_details_modal.episode_releases.is_empty(),
false _ => true,
} }
} }
fn handle_scroll_up(&mut self) {} fn handle_scroll_up(&mut self) {}
src/handlers/sonarr_handlers/library/season_details_handler.rs
+14 -11
View File
@@ -162,17 +162,20 @@ impl<'a, 'b> KeyEventHandler<'a, 'b, ActiveSonarrBlock> for SeasonDetailsHandler
} }
fn is_ready(&self) -> bool { fn is_ready(&self) -> bool {
!self.app.is_loading if self.app.is_loading {
&& if let Some(season_details_modal) = &self.app.data.sonarr_data.season_details_modal { return false;
match self.active_sonarr_block { }
ActiveSonarrBlock::SeasonDetails => !season_details_modal.episodes.is_empty(),
ActiveSonarrBlock::SeasonHistory => !season_details_modal.season_history.is_empty(), let Some(season_details_modal) = &self.app.data.sonarr_data.season_details_modal else {
ActiveSonarrBlock::ManualSeasonSearch => !season_details_modal.season_releases.is_empty(), return false;
_ => true, };
}
} else { match self.active_sonarr_block {
false 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) {} fn handle_scroll_up(&mut self) {}
src/network/radarr_network/blocklist/radarr_blocklist_network_tests.rs
+11 -10
View File
@@ -195,19 +195,20 @@ mod tests {
} }
let mut network = test_network(&app); let mut network = test_network(&app);
if let RadarrSerdeable::BlocklistResponse(blocklist) = network let RadarrSerdeable::BlocklistResponse(blocklist) = network
.handle_radarr_event(RadarrEvent::GetBlocklist) .handle_radarr_event(RadarrEvent::GetBlocklist)
.await .await
.unwrap() .unwrap()
{ else {
mock.assert_async().await; panic!("Expected BlocklistResponse")
assert_eq!( };
app.lock().await.data.radarr_data.blocklist.items, mock.assert_async().await;
expected_blocklist assert_eq!(
); app.lock().await.data.radarr_data.blocklist.items,
assert!(app.lock().await.data.radarr_data.blocklist.sort_asc); expected_blocklist
assert_eq!(blocklist, response); );
} assert!(app.lock().await.data.radarr_data.blocklist.sort_asc);
assert_eq!(blocklist, response);
} }
#[tokio::test] #[tokio::test]
src/network/radarr_network/collections/radarr_collections_network_tests.rs
+11 -10
View File
@@ -277,19 +277,20 @@ mod tests {
} }
let mut network = test_network(&app); let mut network = test_network(&app);
if let RadarrSerdeable::Collections(collections) = network let RadarrSerdeable::Collections(collections) = network
.handle_radarr_event(RadarrEvent::GetCollections) .handle_radarr_event(RadarrEvent::GetCollections)
.await .await
.unwrap() .unwrap()
{ else {
mock.assert_async().await; panic!("Expected Collections")
assert_eq!( };
app.lock().await.data.radarr_data.collections.items, mock.assert_async().await;
expected_collections assert_eq!(
); app.lock().await.data.radarr_data.collections.items,
assert!(app.lock().await.data.radarr_data.collections.sort_asc); expected_collections
assert_eq!(collections, response); );
} assert!(app.lock().await.data.radarr_data.collections.sort_asc);
assert_eq!(collections, response);
} }
#[tokio::test] #[tokio::test]
src/network/radarr_network/downloads/radarr_downloads_network_tests.rs
+10 -9
View File
@@ -48,18 +48,19 @@ mod tests {
.await; .await;
let mut network = test_network(&app); let mut network = test_network(&app);
if let RadarrSerdeable::DownloadsResponse(downloads) = network let RadarrSerdeable::DownloadsResponse(downloads) = network
.handle_radarr_event(RadarrEvent::GetDownloads(500)) .handle_radarr_event(RadarrEvent::GetDownloads(500))
.await .await
.unwrap() .unwrap()
{ else {
mock.assert_async().await; panic!("Expected DownloadsResponse")
pretty_assertions::assert_eq!( };
app.lock().await.data.radarr_data.downloads.items, mock.assert_async().await;
downloads_response().records pretty_assertions::assert_eq!(
); app.lock().await.data.radarr_data.downloads.items,
pretty_assertions::assert_eq!(downloads, response); downloads_response().records
} );
pretty_assertions::assert_eq!(downloads, response);
} }
#[tokio::test] #[tokio::test]
src/network/radarr_network/indexers/radarr_indexers_network_tests.rs
+69 -64
View File
@@ -623,18 +623,19 @@ mod tests {
.await; .await;
let mut network = test_network(&app); let mut network = test_network(&app);
if let RadarrSerdeable::Indexers(indexers) = network let RadarrSerdeable::Indexers(indexers) = network
.handle_radarr_event(RadarrEvent::GetIndexers) .handle_radarr_event(RadarrEvent::GetIndexers)
.await .await
.unwrap() .unwrap()
{ else {
async_server.assert_async().await; panic!("Expected Indexers")
assert_eq!( };
app.lock().await.data.radarr_data.indexers.items, async_server.assert_async().await;
vec![indexer()] assert_eq!(
); app.lock().await.data.radarr_data.indexers.items,
assert_eq!(indexers, response); vec![indexer()]
} );
assert_eq!(indexers, response);
} }
#[tokio::test] #[tokio::test]
@@ -658,18 +659,19 @@ mod tests {
.await; .await;
let mut network = test_network(&app); let mut network = test_network(&app);
if let RadarrSerdeable::IndexerSettings(settings) = network let RadarrSerdeable::IndexerSettings(settings) = network
.handle_radarr_event(RadarrEvent::GetAllIndexerSettings) .handle_radarr_event(RadarrEvent::GetAllIndexerSettings)
.await .await
.unwrap() .unwrap()
{ else {
async_server.assert_async().await; panic!("Expected IndexerSettings")
assert_eq!( };
app.lock().await.data.radarr_data.indexer_settings, async_server.assert_async().await;
Some(indexer_settings()) assert_eq!(
); app.lock().await.data.radarr_data.indexer_settings,
assert_eq!(settings, response); Some(indexer_settings())
} );
assert_eq!(settings, response);
} }
#[tokio::test] #[tokio::test]
@@ -755,19 +757,20 @@ mod tests {
.await; .await;
let mut network = test_network(&app); let mut network = test_network(&app);
if let RadarrSerdeable::Value(value) = network let RadarrSerdeable::Value(value) = network
.handle_radarr_event(RadarrEvent::TestIndexer(1)) .handle_radarr_event(RadarrEvent::TestIndexer(1))
.await .await
.unwrap() .unwrap()
{ else {
async_details_server.assert_async().await; panic!("Expected Value")
async_test_server.assert_async().await; };
assert_eq!( async_details_server.assert_async().await;
app.lock().await.data.radarr_data.indexer_test_errors, async_test_server.assert_async().await;
Some("\"test failure\"".to_owned()) assert_eq!(
); app.lock().await.data.radarr_data.indexer_test_errors,
assert_eq!(value, response_json) Some("\"test failure\"".to_owned())
} );
assert_eq!(value, response_json);
} }
#[tokio::test] #[tokio::test]
@@ -812,19 +815,20 @@ mod tests {
.await; .await;
let mut network = test_network(&app); let mut network = test_network(&app);
if let RadarrSerdeable::Value(value) = network let RadarrSerdeable::Value(value) = network
.handle_radarr_event(RadarrEvent::TestIndexer(1)) .handle_radarr_event(RadarrEvent::TestIndexer(1))
.await .await
.unwrap() .unwrap()
{ else {
async_details_server.assert_async().await; panic!("Expected Value")
async_test_server.assert_async().await; };
assert_eq!( async_details_server.assert_async().await;
app.lock().await.data.radarr_data.indexer_test_errors, async_test_server.assert_async().await;
Some(String::new()) assert_eq!(
); app.lock().await.data.radarr_data.indexer_test_errors,
assert_eq!(value, json!({})); Some(String::new())
} );
assert_eq!(value, json!({}));
} }
#[tokio::test] #[tokio::test]
@@ -890,34 +894,35 @@ mod tests {
.set_items(indexers); .set_items(indexers);
let mut network = test_network(&app); let mut network = test_network(&app);
if let RadarrSerdeable::IndexerTestResults(results) = network let RadarrSerdeable::IndexerTestResults(results) = network
.handle_radarr_event(RadarrEvent::TestAllIndexers) .handle_radarr_event(RadarrEvent::TestAllIndexers)
.await .await
.unwrap() .unwrap()
{ else {
async_server.assert_async().await; panic!("Expected IndexerTestResults")
assert!( };
app async_server.assert_async().await;
.lock() assert!(
.await app
.data .lock()
.radarr_data .await
.indexer_test_all_results .data
.is_some() .radarr_data
); .indexer_test_all_results
assert_eq!( .is_some()
app );
.lock() assert_eq!(
.await app
.data .lock()
.radarr_data .await
.indexer_test_all_results .data
.as_ref() .radarr_data
.unwrap() .indexer_test_all_results
.items, .as_ref()
indexer_test_results_modal_items .unwrap()
); .items,
assert_eq!(results, response); indexer_test_results_modal_items
} );
assert_eq!(results, response);
} }
} }
src/network/radarr_network/library/radarr_library_network_tests.rs
+142 -137
View File
@@ -382,19 +382,20 @@ mod tests {
app_arc.lock().await.data.radarr_data.movie_details_modal = Some(MovieDetailsModal::default()); app_arc.lock().await.data.radarr_data.movie_details_modal = Some(MovieDetailsModal::default());
let mut network = test_network(&app_arc); let mut network = test_network(&app_arc);
if let RadarrSerdeable::Credits(credits) = network let RadarrSerdeable::Credits(credits) = network
.handle_radarr_event(RadarrEvent::GetMovieCredits(1)) .handle_radarr_event(RadarrEvent::GetMovieCredits(1))
.await .await
.unwrap() .unwrap()
{ else {
let app = app_arc.lock().await; panic!("Expected Credits")
let movie_details_modal = app.data.radarr_data.movie_details_modal.as_ref().unwrap(); };
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; async_server.assert_async().await;
assert_eq!(movie_details_modal.movie_cast.items, vec![cast_credit()]); assert_eq!(movie_details_modal.movie_cast.items, vec![cast_credit()]);
assert_eq!(movie_details_modal.movie_crew.items, vec![crew_credit()]); assert_eq!(movie_details_modal.movie_crew.items, vec![crew_credit()]);
assert_eq!(credits, response); assert_eq!(credits, response);
}
} }
#[tokio::test] #[tokio::test]
@@ -570,77 +571,78 @@ mod tests {
BiMap::from_iter([(2222, "HD - 1080p".to_owned())]); BiMap::from_iter([(2222, "HD - 1080p".to_owned())]);
let mut network = test_network(&app_arc); let mut network = test_network(&app_arc);
if let RadarrSerdeable::Movie(movie) = network let RadarrSerdeable::Movie(movie) = network
.handle_radarr_event(RadarrEvent::GetMovieDetails(1)) .handle_radarr_event(RadarrEvent::GetMovieDetails(1))
.await .await
.unwrap() .unwrap()
{ else {
async_server.assert_async().await; panic!("Expected Movie")
assert!( };
app_arc async_server.assert_async().await;
.lock() assert!(
.await app_arc
.data .lock()
.radarr_data .await
.movie_details_modal .data
.is_some() .radarr_data
); .movie_details_modal
assert_eq!(movie, response); .is_some()
);
assert_eq!(movie, response);
let app = app_arc.lock().await; let app = app_arc.lock().await;
let movie_details_modal = app.data.radarr_data.movie_details_modal.as_ref().unwrap(); let movie_details_modal = app.data.radarr_data.movie_details_modal.as_ref().unwrap();
assert_str_eq!( assert_str_eq!(
movie_details_modal.movie_details.get_text(), movie_details_modal.movie_details.get_text(),
formatdoc!( formatdoc!(
"Title: Test "Title: Test
Year: 2023 Year: 2023
Runtime: 2h 0m Runtime: 2h 0m
Rating: R Rating: R
Collection: Test Collection Collection: Test Collection
Status: Downloaded Status: Downloaded
Description: Blah blah blah Description: Blah blah blah
TMDB: 99% TMDB: 99%
IMDB: 9.9 IMDB: 9.9
Rotten Tomatoes: Rotten Tomatoes:
Quality Profile: HD - 1080p 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
Size: 3.30 GB Size: 3.30 GB
Date Added: 2022-12-30 07:37:56 UTC" Path: /nfs/movies
) Studio: 21st Century Alex
); Genres: cool, family, fun"
assert_str_eq!( )
movie_details_modal.audio_details, );
formatdoc!( assert_str_eq!(
"Bitrate: 0 movie_details_modal.file_details,
Channels: 7.1 formatdoc!(
Codec: AAC "Relative Path: Test.mkv
Languages: eng Absolute Path: /nfs/movies/Test.mkv
Stream Count: 1" Size: 3.30 GB
) Date Added: 2022-12-30 07:37:56 UTC"
); )
assert_str_eq!( );
movie_details_modal.video_details, assert_str_eq!(
formatdoc!( movie_details_modal.audio_details,
"Bit Depth: 10 formatdoc!(
Bitrate: 0 "Bitrate: 0
Codec: x265 Channels: 7.1
FPS: 23.976 Codec: AAC
Resolution: 1920x804 Languages: eng
Scan Type: Progressive Stream Count: 1"
Runtime: 2:00:00" )
) );
); 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] #[tokio::test]
@@ -741,27 +743,28 @@ mod tests {
app_arc.lock().await.data.radarr_data.movie_details_modal = Some(MovieDetailsModal::default()); app_arc.lock().await.data.radarr_data.movie_details_modal = Some(MovieDetailsModal::default());
let mut network = test_network(&app_arc); let mut network = test_network(&app_arc);
if let RadarrSerdeable::MovieHistoryItems(history) = network let RadarrSerdeable::MovieHistoryItems(history) = network
.handle_radarr_event(RadarrEvent::GetMovieHistory(1)) .handle_radarr_event(RadarrEvent::GetMovieHistory(1))
.await .await
.unwrap() .unwrap()
{ else {
async_server.assert_async().await; panic!("Expected MovieHistoryItems")
assert_eq!( };
app_arc async_server.assert_async().await;
.lock() assert_eq!(
.await app_arc
.data .lock()
.radarr_data .await
.movie_details_modal .data
.as_ref() .radarr_data
.unwrap() .movie_details_modal
.movie_history .as_ref()
.items, .unwrap()
vec![movie_history_item()] .movie_history
); .items,
assert_eq!(history, response); vec![movie_history_item()]
} );
assert_eq!(history, response);
} }
#[tokio::test] #[tokio::test]
@@ -828,27 +831,28 @@ mod tests {
app_arc.lock().await.data.radarr_data.movie_details_modal = Some(MovieDetailsModal::default()); app_arc.lock().await.data.radarr_data.movie_details_modal = Some(MovieDetailsModal::default());
let mut network = test_network(&app_arc); 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)) .handle_radarr_event(RadarrEvent::GetReleases(1))
.await .await
.unwrap() .unwrap()
{ else {
async_server.assert_async().await; panic!("Expected Releases")
assert_eq!( };
app_arc async_server.assert_async().await;
.lock() assert_eq!(
.await app_arc
.data .lock()
.radarr_data .await
.movie_details_modal .data
.as_ref() .radarr_data
.unwrap() .movie_details_modal
.movie_releases .as_ref()
.items, .unwrap()
vec![release()] .movie_releases
); .items,
assert_eq!(releases_vec, vec![release()]); vec![release()]
} );
assert_eq!(releases_vec, vec![release()]);
} }
#[tokio::test] #[tokio::test]
@@ -928,35 +932,36 @@ mod tests {
.await; .await;
let mut network = test_network(&app_arc); 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())) .handle_radarr_event(RadarrEvent::SearchNewMovie("test term".into()))
.await .await
.unwrap() .unwrap()
{ else {
async_server.assert_async().await; panic!("Expected AddMovieSearchResults")
assert!( };
app_arc async_server.assert_async().await;
.lock() assert!(
.await app_arc
.data .lock()
.radarr_data .await
.add_searched_movies .data
.is_some() .radarr_data
); .add_searched_movies
assert_eq!( .is_some()
app_arc );
.lock() assert_eq!(
.await app_arc
.data .lock()
.radarr_data .await
.add_searched_movies .data
.as_ref() .radarr_data
.unwrap() .add_searched_movies
.items, .as_ref()
vec![add_movie_search_result()] .unwrap()
); .items,
assert_eq!(add_movie_search_results, vec![add_movie_search_result()]); vec![add_movie_search_result()]
} );
assert_eq!(add_movie_search_results, vec![add_movie_search_result()]);
} }
#[tokio::test] #[tokio::test]
src/network/radarr_network/radarr_network_tests.rs
+6 -3
View File
@@ -194,8 +194,9 @@ mod test {
mock.assert_async().await; mock.assert_async().await;
let RadarrSerdeable::QualityProfiles(quality_profiles) = result.unwrap() else { let RadarrSerdeable::QualityProfiles(quality_profiles) = result.unwrap() else {
panic!("Expected QualityProfiles variant"); panic!("Expected QualityProfiles");
}; };
assert_eq!(quality_profiles, expected); assert_eq!(quality_profiles, expected);
assert_eq!( assert_eq!(
app.lock().await.data.radarr_data.quality_profile_map, app.lock().await.data.radarr_data.quality_profile_map,
@@ -225,8 +226,9 @@ mod test {
mock.assert_async().await; mock.assert_async().await;
let RadarrSerdeable::Tags(tags) = result.unwrap() else { let RadarrSerdeable::Tags(tags) = result.unwrap() else {
panic!("Expected Tags variant"); panic!("Expected Tags");
}; };
assert_eq!(tags, expected); assert_eq!(tags, expected);
assert_eq!( assert_eq!(
app.lock().await.data.radarr_data.tags_map, app.lock().await.data.radarr_data.tags_map,
@@ -259,8 +261,9 @@ mod test {
mock.assert_async().await; mock.assert_async().await;
let RadarrSerdeable::Tag(tag) = result.unwrap() else { let RadarrSerdeable::Tag(tag) = result.unwrap() else {
panic!("Expected Tag variant"); panic!("Expected Tag");
}; };
assert_eq!(tag, expected); assert_eq!(tag, expected);
assert_eq!( assert_eq!(
app.lock().await.data.radarr_data.tags_map, app.lock().await.data.radarr_data.tags_map,
src/network/radarr_network/root_folders/radarr_root_folders_network_tests.rs
+10 -9
View File
@@ -65,17 +65,18 @@ mod tests {
.await; .await;
let mut network = test_network(&app); let mut network = test_network(&app);
if let RadarrSerdeable::RootFolders(root_folders) = network let RadarrSerdeable::RootFolders(root_folders) = network
.handle_radarr_event(RadarrEvent::GetRootFolders) .handle_radarr_event(RadarrEvent::GetRootFolders)
.await .await
.unwrap() .unwrap()
{ else {
mock.assert_async().await; panic!("Expected RootFolders")
assert_eq!( };
app.lock().await.data.radarr_data.root_folders.items, mock.assert_async().await;
vec![root_folder()] assert_eq!(
); app.lock().await.data.radarr_data.root_folders.items,
assert_eq!(root_folders, response); vec![root_folder()]
} );
assert_eq!(root_folders, response);
} }
} }
src/network/radarr_network/system/radarr_system_network_tests.rs
+90 -81
View File
@@ -39,18 +39,19 @@ mod tests {
}, },
]; ];
if let RadarrSerdeable::DiskSpaces(disk_space) = network let RadarrSerdeable::DiskSpaces(disk_space) = network
.handle_radarr_event(RadarrEvent::GetDiskSpace) .handle_radarr_event(RadarrEvent::GetDiskSpace)
.await .await
.unwrap() .unwrap()
{ else {
mock.assert_async().await; panic!("Expected DiskSpaces")
assert_eq!( };
app.lock().await.data.radarr_data.disk_space_vec, mock.assert_async().await;
disk_space_vec assert_eq!(
); app.lock().await.data.radarr_data.disk_space_vec,
assert_eq!(disk_space, disk_space_vec); disk_space_vec
} );
assert_eq!(disk_space, disk_space_vec);
} }
#[tokio::test] #[tokio::test]
@@ -73,14 +74,15 @@ mod tests {
.await; .await;
let mut network = test_network(&app); let mut network = test_network(&app);
if let RadarrSerdeable::HostConfig(host_config) = network let RadarrSerdeable::HostConfig(host_config) = network
.handle_radarr_event(RadarrEvent::GetHostConfig) .handle_radarr_event(RadarrEvent::GetHostConfig)
.await .await
.unwrap() .unwrap()
{ else {
mock.assert_async().await; panic!("Expected HostConfig")
assert_eq!(host_config, response); };
} mock.assert_async().await;
assert_eq!(host_config, response);
} }
#[tokio::test] #[tokio::test]
@@ -123,26 +125,27 @@ mod tests {
.await; .await;
let mut network = test_network(&app); let mut network = test_network(&app);
if let RadarrSerdeable::LogResponse(logs) = network let RadarrSerdeable::LogResponse(logs) = network
.handle_radarr_event(RadarrEvent::GetLogs(500)) .handle_radarr_event(RadarrEvent::GetLogs(500))
.await .await
.unwrap() .unwrap()
{ else {
mock.assert_async().await; panic!("Expected LogResponse")
assert_eq!(app.lock().await.data.radarr_data.logs.items, expected_logs); };
assert!( mock.assert_async().await;
app assert_eq!(app.lock().await.data.radarr_data.logs.items, expected_logs);
.lock() assert!(
.await app
.data .lock()
.radarr_data .await
.logs .data
.current_selection() .radarr_data
.text .logs
.contains("INFO") .current_selection()
); .text
assert_eq!(logs, response); .contains("INFO")
} );
assert_eq!(logs, response);
} }
#[tokio::test] #[tokio::test]
@@ -176,18 +179,19 @@ mod tests {
.await; .await;
let mut network = test_network(&app); let mut network = test_network(&app);
if let RadarrSerdeable::QueueEvents(events) = network let RadarrSerdeable::QueueEvents(events) = network
.handle_radarr_event(RadarrEvent::GetQueuedEvents) .handle_radarr_event(RadarrEvent::GetQueuedEvents)
.await .await
.unwrap() .unwrap()
{ else {
mock.assert_async().await; panic!("Expected QueueEvents")
assert_eq!( };
app.lock().await.data.radarr_data.queued_events.items, mock.assert_async().await;
vec![expected_event] assert_eq!(
); app.lock().await.data.radarr_data.queued_events.items,
assert_eq!(events, response); vec![expected_event]
} );
assert_eq!(events, response);
} }
#[tokio::test] #[tokio::test]
@@ -208,14 +212,15 @@ mod tests {
.await; .await;
let mut network = test_network(&app); let mut network = test_network(&app);
if let RadarrSerdeable::SecurityConfig(security_config) = network let RadarrSerdeable::SecurityConfig(security_config) = network
.handle_radarr_event(RadarrEvent::GetSecurityConfig) .handle_radarr_event(RadarrEvent::GetSecurityConfig)
.await .await
.unwrap() .unwrap()
{ else {
mock.assert_async().await; panic!("Expected SecurityConfig")
assert_eq!(security_config, response); };
} mock.assert_async().await;
assert_eq!(security_config, response);
} }
#[tokio::test] #[tokio::test]
@@ -230,22 +235,23 @@ mod tests {
let mut network = test_network(&app); let mut network = test_network(&app);
let date_time = DateTime::from(DateTime::parse_from_rfc3339("2023-02-25T20:16:43Z").unwrap()); 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) .handle_radarr_event(RadarrEvent::GetStatus)
.await .await
.unwrap() .unwrap()
{ else {
async_server.assert_async().await; panic!("Expected SystemStatus")
assert_str_eq!(app.lock().await.data.radarr_data.version, "v1"); };
assert_eq!(app.lock().await.data.radarr_data.start_time, date_time); async_server.assert_async().await;
assert_eq!( assert_str_eq!(app.lock().await.data.radarr_data.version, "v1");
status, assert_eq!(app.lock().await.data.radarr_data.start_time, date_time);
SystemStatus { assert_eq!(
version: "v1".to_owned(), status,
start_time: date_time SystemStatus {
} version: "v1".to_owned(),
); start_time: date_time
} }
);
} }
#[tokio::test] #[tokio::test]
@@ -323,18 +329,19 @@ mod tests {
.await; .await;
let mut network = test_network(&app); let mut network = test_network(&app);
if let RadarrSerdeable::Updates(updates) = network let RadarrSerdeable::Updates(updates) = network
.handle_radarr_event(RadarrEvent::GetUpdates) .handle_radarr_event(RadarrEvent::GetUpdates)
.await .await
.unwrap() .unwrap()
{ else {
async_server.assert_async().await; panic!("Expected Updates")
assert_str_eq!( };
app.lock().await.data.radarr_data.updates.get_text(), async_server.assert_async().await;
expected_text.get_text() assert_str_eq!(
); app.lock().await.data.radarr_data.updates.get_text(),
assert_eq!(updates, response); expected_text.get_text()
} );
assert_eq!(updates, response);
} }
#[tokio::test] #[tokio::test]
@@ -381,18 +388,19 @@ mod tests {
.await; .await;
let mut network = test_network(&app); let mut network = test_network(&app);
if let RadarrSerdeable::Tasks(tasks) = network let RadarrSerdeable::Tasks(tasks) = network
.handle_radarr_event(RadarrEvent::GetTasks) .handle_radarr_event(RadarrEvent::GetTasks)
.await .await
.unwrap() .unwrap()
{ else {
async_server.assert_async().await; panic!("Expected Tasks")
assert_eq!( };
app.lock().await.data.radarr_data.tasks.items, async_server.assert_async().await;
expected_tasks assert_eq!(
); app.lock().await.data.radarr_data.tasks.items,
assert_eq!(tasks, response); expected_tasks
} );
assert_eq!(tasks, response);
} }
#[tokio::test] #[tokio::test]
@@ -409,15 +417,16 @@ mod tests {
.await; .await;
let mut network = test_network(&app); let mut network = test_network(&app);
if let RadarrSerdeable::Value(value) = network let RadarrSerdeable::Value(value) = network
.handle_radarr_event(RadarrEvent::StartTask( .handle_radarr_event(RadarrEvent::StartTask(
RadarrTaskName::ApplicationCheckUpdate, RadarrTaskName::ApplicationCheckUpdate,
)) ))
.await .await
.unwrap() .unwrap()
{ else {
async_server.assert_async().await; panic!("Expected Value")
assert_eq!(value, response); };
} async_server.assert_async().await;
assert_eq!(value, response);
} }
} }
src/network/sonarr_network/blocklist/sonarr_blocklist_network_tests.rs
+19 -17
View File
@@ -163,19 +163,20 @@ mod tests {
app.lock().await.server_tabs.next(); app.lock().await.server_tabs.next();
let mut network = test_network(&app); let mut network = test_network(&app);
if let SonarrSerdeable::BlocklistResponse(blocklist) = network let SonarrSerdeable::BlocklistResponse(blocklist) = network
.handle_sonarr_event(SonarrEvent::GetBlocklist) .handle_sonarr_event(SonarrEvent::GetBlocklist)
.await .await
.unwrap() .unwrap()
{ else {
mock.assert_async().await; panic!("Expected BlocklistResponse")
assert_eq!( };
app.lock().await.data.sonarr_data.blocklist.items, mock.assert_async().await;
expected_blocklist assert_eq!(
); app.lock().await.data.sonarr_data.blocklist.items,
assert!(app.lock().await.data.sonarr_data.blocklist.sort_asc); expected_blocklist
assert_eq!(blocklist, response); );
} assert!(app.lock().await.data.sonarr_data.blocklist.sort_asc);
assert_eq!(blocklist, response);
} }
#[tokio::test] #[tokio::test]
@@ -233,15 +234,16 @@ mod tests {
app.lock().await.server_tabs.next(); app.lock().await.server_tabs.next();
let mut network = test_network(&app); let mut network = test_network(&app);
if let SonarrSerdeable::BlocklistResponse(blocklist) = network let SonarrSerdeable::BlocklistResponse(blocklist) = network
.handle_sonarr_event(SonarrEvent::GetBlocklist) .handle_sonarr_event(SonarrEvent::GetBlocklist)
.await .await
.unwrap() .unwrap()
{ else {
mock.assert_async().await; panic!("Expected BlocklistResponse")
assert!(app.lock().await.data.sonarr_data.blocklist.is_empty()); };
assert!(app.lock().await.data.sonarr_data.blocklist.sort_asc); mock.assert_async().await;
assert_eq!(blocklist, response); assert!(app.lock().await.data.sonarr_data.blocklist.is_empty());
} assert!(app.lock().await.data.sonarr_data.blocklist.sort_asc);
assert_eq!(blocklist, response);
} }
} }
src/network/sonarr_network/downloads/sonarr_downloads_network_tests.rs
+10 -9
View File
@@ -60,18 +60,19 @@ mod tests {
app.lock().await.server_tabs.next(); app.lock().await.server_tabs.next();
let mut network = test_network(&app); let mut network = test_network(&app);
if let SonarrSerdeable::DownloadsResponse(downloads) = network let SonarrSerdeable::DownloadsResponse(downloads) = network
.handle_sonarr_event(SonarrEvent::GetDownloads(500)) .handle_sonarr_event(SonarrEvent::GetDownloads(500))
.await .await
.unwrap() .unwrap()
{ else {
mock.assert_async().await; panic!("Expected DownloadsResponse")
assert_eq!( };
app.lock().await.data.sonarr_data.downloads.items, mock.assert_async().await;
downloads_response().records assert_eq!(
); app.lock().await.data.sonarr_data.downloads.items,
assert_eq!(downloads, response); downloads_response().records
} );
assert_eq!(downloads, response);
} }
#[tokio::test] #[tokio::test]
src/network/sonarr_network/history/sonarr_history_network_tests.rs
+19 -17
View File
@@ -84,19 +84,20 @@ mod tests {
app.lock().await.server_tabs.next(); app.lock().await.server_tabs.next();
let mut network = test_network(&app); let mut network = test_network(&app);
if let SonarrSerdeable::SonarrHistoryWrapper(history) = network let SonarrSerdeable::SonarrHistoryWrapper(history) = network
.handle_sonarr_event(SonarrEvent::GetHistory(500)) .handle_sonarr_event(SonarrEvent::GetHistory(500))
.await .await
.unwrap() .unwrap()
{ else {
mock.assert_async().await; panic!("Expected SonarrHistoryWrapper")
assert_eq!( };
app.lock().await.data.sonarr_data.history.items, mock.assert_async().await;
expected_history_items assert_eq!(
); app.lock().await.data.sonarr_data.history.items,
assert!(app.lock().await.data.sonarr_data.history.sort_asc); expected_history_items
assert_eq!(history, response); );
} assert!(app.lock().await.data.sonarr_data.history.sort_asc);
assert_eq!(history, response);
} }
#[tokio::test] #[tokio::test]
@@ -158,16 +159,17 @@ mod tests {
app.lock().await.server_tabs.next(); app.lock().await.server_tabs.next();
let mut network = test_network(&app); let mut network = test_network(&app);
if let SonarrSerdeable::SonarrHistoryWrapper(history) = network let SonarrSerdeable::SonarrHistoryWrapper(history) = network
.handle_sonarr_event(SonarrEvent::GetHistory(500)) .handle_sonarr_event(SonarrEvent::GetHistory(500))
.await .await
.unwrap() .unwrap()
{ else {
mock.assert_async().await; panic!("Expected SonarrHistoryWrapper")
assert!(app.lock().await.data.sonarr_data.history.is_empty()); };
assert!(app.lock().await.data.sonarr_data.history.sort_asc); mock.assert_async().await;
assert_eq!(history, response); 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] #[tokio::test]
src/network/sonarr_network/indexers/sonarr_indexers_network_tests.rs
+59 -55
View File
@@ -635,18 +635,19 @@ mod tests {
app.lock().await.server_tabs.next(); app.lock().await.server_tabs.next();
let mut network = test_network(&app); let mut network = test_network(&app);
if let SonarrSerdeable::Indexers(indexers) = network let SonarrSerdeable::Indexers(indexers) = network
.handle_sonarr_event(SonarrEvent::GetIndexers) .handle_sonarr_event(SonarrEvent::GetIndexers)
.await .await
.unwrap() .unwrap()
{ else {
async_server.assert_async().await; panic!("Expected Indexers")
assert_eq!( };
app.lock().await.data.sonarr_data.indexers.items, async_server.assert_async().await;
vec![indexer()] assert_eq!(
); app.lock().await.data.sonarr_data.indexers.items,
assert_eq!(indexers, response); vec![indexer()]
} );
assert_eq!(indexers, response);
} }
#[tokio::test] #[tokio::test]
@@ -706,19 +707,20 @@ mod tests {
app.lock().await.server_tabs.next(); app.lock().await.server_tabs.next();
let mut network = test_network(&app); let mut network = test_network(&app);
if let SonarrSerdeable::Value(value) = network let SonarrSerdeable::Value(value) = network
.handle_sonarr_event(SonarrEvent::TestIndexer(1)) .handle_sonarr_event(SonarrEvent::TestIndexer(1))
.await .await
.unwrap() .unwrap()
{ else {
async_details_server.assert_async().await; panic!("Expected Value")
async_test_server.assert_async().await; };
assert_eq!( async_details_server.assert_async().await;
app.lock().await.data.sonarr_data.indexer_test_errors, async_test_server.assert_async().await;
Some("\"test failure\"".to_owned()) assert_eq!(
); app.lock().await.data.sonarr_data.indexer_test_errors,
assert_eq!(value, response_json) Some("\"test failure\"".to_owned())
} );
assert_eq!(value, response_json);
} }
#[tokio::test] #[tokio::test]
@@ -771,19 +773,20 @@ mod tests {
app.lock().await.server_tabs.next(); app.lock().await.server_tabs.next();
let mut network = test_network(&app); let mut network = test_network(&app);
if let SonarrSerdeable::Value(value) = network let SonarrSerdeable::Value(value) = network
.handle_sonarr_event(SonarrEvent::TestIndexer(1)) .handle_sonarr_event(SonarrEvent::TestIndexer(1))
.await .await
.unwrap() .unwrap()
{ else {
async_details_server.assert_async().await; panic!("Expected Value")
async_test_server.assert_async().await; };
assert_eq!( async_details_server.assert_async().await;
app.lock().await.data.sonarr_data.indexer_test_errors, async_test_server.assert_async().await;
Some(String::new()) assert_eq!(
); app.lock().await.data.sonarr_data.indexer_test_errors,
assert_eq!(value, json!({})); Some(String::new())
} );
assert_eq!(value, json!({}));
} }
#[tokio::test] #[tokio::test]
@@ -850,34 +853,35 @@ mod tests {
app.lock().await.server_tabs.next(); app.lock().await.server_tabs.next();
let mut network = test_network(&app); let mut network = test_network(&app);
if let SonarrSerdeable::IndexerTestResults(results) = network let SonarrSerdeable::IndexerTestResults(results) = network
.handle_sonarr_event(SonarrEvent::TestAllIndexers) .handle_sonarr_event(SonarrEvent::TestAllIndexers)
.await .await
.unwrap() .unwrap()
{ else {
async_server.assert_async().await; panic!("Expected IndexerTestResults")
assert!( };
app async_server.assert_async().await;
.lock() assert!(
.await app
.data .lock()
.sonarr_data .await
.indexer_test_all_results .data
.is_some() .sonarr_data
); .indexer_test_all_results
assert_eq!( .is_some()
app );
.lock() assert_eq!(
.await app
.data .lock()
.sonarr_data .await
.indexer_test_all_results .data
.as_ref() .sonarr_data
.unwrap() .indexer_test_all_results
.items, .as_ref()
indexer_test_results_modal_items .unwrap()
); .items,
assert_eq!(results, response); indexer_test_results_modal_items
} );
assert_eq!(results, response);
} }
} }
src/network/sonarr_network/library/episodes/sonarr_episodes_network_tests.rs
+406 -394
View File
@@ -253,27 +253,28 @@ mod tests {
app_arc.lock().await.server_tabs.next(); app_arc.lock().await.server_tabs.next();
let mut network = test_network(&app_arc); let mut network = test_network(&app_arc);
if let SonarrSerdeable::Episodes(episodes) = network let SonarrSerdeable::Episodes(episodes) = network
.handle_sonarr_event(SonarrEvent::GetEpisodes(1)) .handle_sonarr_event(SonarrEvent::GetEpisodes(1))
.await .await
.unwrap() .unwrap()
{ else {
async_server.assert_async().await; panic!("Expected Episodes")
assert_eq!( };
app_arc async_server.assert_async().await;
.lock() assert_eq!(
.await app_arc
.data .lock()
.sonarr_data .await
.season_details_modal .data
.as_ref() .sonarr_data
.unwrap() .season_details_modal
.episodes .as_ref()
.items, .unwrap()
vec![episode()] .episodes
); .items,
assert_eq!(episodes, vec![episode()]); vec![episode()]
} );
assert_eq!(episodes, vec![episode()]);
} }
#[tokio::test] #[tokio::test]
@@ -353,38 +354,39 @@ mod tests {
app_arc.lock().await.server_tabs.next(); app_arc.lock().await.server_tabs.next();
let mut network = test_network(&app_arc); let mut network = test_network(&app_arc);
if let SonarrSerdeable::Episodes(episodes) = network let SonarrSerdeable::Episodes(episodes) = network
.handle_sonarr_event(SonarrEvent::GetEpisodes(1)) .handle_sonarr_event(SonarrEvent::GetEpisodes(1))
.await .await
.unwrap() .unwrap()
{ else {
async_server.assert_async().await; panic!("Expected Episodes")
assert!( };
app_arc async_server.assert_async().await;
.lock() assert!(
.await app_arc
.data .lock()
.sonarr_data .await
.season_details_modal .data
.as_ref() .sonarr_data
.unwrap() .season_details_modal
.episodes .as_ref()
.is_empty() .unwrap()
); .episodes
assert!( .is_empty()
app_arc );
.lock() assert!(
.await app_arc
.data .lock()
.sonarr_data .await
.season_details_modal .data
.as_ref() .sonarr_data
.unwrap() .season_details_modal
.episodes .as_ref()
.sort_asc .unwrap()
); .episodes
assert_eq!(episodes, expected_episodes); .sort_asc
} );
assert_eq!(episodes, expected_episodes);
} }
#[tokio::test] #[tokio::test]
@@ -409,27 +411,28 @@ mod tests {
app_arc.lock().await.server_tabs.next(); app_arc.lock().await.server_tabs.next();
let mut network = test_network(&app_arc); 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)) .handle_sonarr_event(SonarrEvent::GetEpisodeFiles(1))
.await .await
.unwrap() .unwrap()
{ else {
async_server.assert_async().await; panic!("Expected EpisodeFiles")
assert_eq!( };
app_arc async_server.assert_async().await;
.lock() assert_eq!(
.await app_arc
.data .lock()
.sonarr_data .await
.season_details_modal .data
.as_ref() .sonarr_data
.unwrap() .season_details_modal
.episode_files .as_ref()
.items, .unwrap()
vec![episode_file()] .episode_files
); .items,
assert_eq!(episode_files, vec![episode_file()]); vec![episode_file()]
} );
assert_eq!(episode_files, vec![episode_file()]);
} }
#[tokio::test] #[tokio::test]
@@ -452,36 +455,37 @@ mod tests {
app_arc.lock().await.server_tabs.next(); app_arc.lock().await.server_tabs.next();
let mut network = test_network(&app_arc); 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)) .handle_sonarr_event(SonarrEvent::GetEpisodeFiles(1))
.await .await
.unwrap() .unwrap()
{ else {
async_server.assert_async().await; panic!("Expected EpisodeFiles")
assert!( };
app_arc async_server.assert_async().await;
.lock() assert!(
.await app_arc
.data .lock()
.sonarr_data .await
.season_details_modal .data
.is_some() .sonarr_data
); .season_details_modal
assert_eq!( .is_some()
app_arc );
.lock() assert_eq!(
.await app_arc
.data .lock()
.sonarr_data .await
.season_details_modal .data
.as_ref() .sonarr_data
.unwrap() .season_details_modal
.episode_files .as_ref()
.items, .unwrap()
vec![episode_file()] .episode_files
); .items,
assert_eq!(episode_files, vec![episode_file()]); vec![episode_file()]
} );
assert_eq!(episode_files, vec![episode_file()]);
} }
#[tokio::test] #[tokio::test]
@@ -569,45 +573,46 @@ mod tests {
app_arc.lock().await.server_tabs.next(); app_arc.lock().await.server_tabs.next();
let mut network = test_network(&app_arc); let mut network = test_network(&app_arc);
if let SonarrSerdeable::SonarrHistoryWrapper(history) = network let SonarrSerdeable::SonarrHistoryWrapper(history) = network
.handle_sonarr_event(SonarrEvent::GetEpisodeHistory(1)) .handle_sonarr_event(SonarrEvent::GetEpisodeHistory(1))
.await .await
.unwrap() .unwrap()
{ else {
async_server.assert_async().await; panic!("Expected SonarrHistoryWrapper")
assert_eq!( };
app_arc async_server.assert_async().await;
.lock() assert_eq!(
.await app_arc
.data .lock()
.sonarr_data .await
.season_details_modal .data
.as_ref() .sonarr_data
.unwrap() .season_details_modal
.episode_details_modal .as_ref()
.as_ref() .unwrap()
.unwrap() .episode_details_modal
.episode_history .as_ref()
.items, .unwrap()
expected_history_items .episode_history
); .items,
assert!( expected_history_items
app_arc );
.lock() assert!(
.await app_arc
.data .lock()
.sonarr_data .await
.season_details_modal .data
.as_ref() .sonarr_data
.unwrap() .season_details_modal
.episode_details_modal .as_ref()
.as_ref() .unwrap()
.unwrap() .episode_details_modal
.episode_history .as_ref()
.sort_asc .unwrap()
); .episode_history
assert_eq!(history, response); .sort_asc
} );
assert_eq!(history, response);
} }
#[tokio::test] #[tokio::test]
@@ -673,45 +678,46 @@ mod tests {
app_arc.lock().await.server_tabs.next(); app_arc.lock().await.server_tabs.next();
let mut network = test_network(&app_arc); let mut network = test_network(&app_arc);
if let SonarrSerdeable::SonarrHistoryWrapper(history) = network let SonarrSerdeable::SonarrHistoryWrapper(history) = network
.handle_sonarr_event(SonarrEvent::GetEpisodeHistory(1)) .handle_sonarr_event(SonarrEvent::GetEpisodeHistory(1))
.await .await
.unwrap() .unwrap()
{ else {
async_server.assert_async().await; panic!("Expected SonarrHistoryWrapper")
assert_eq!( };
app_arc async_server.assert_async().await;
.lock() assert_eq!(
.await app_arc
.data .lock()
.sonarr_data .await
.season_details_modal .data
.as_ref() .sonarr_data
.unwrap() .season_details_modal
.episode_details_modal .as_ref()
.as_ref() .unwrap()
.unwrap() .episode_details_modal
.episode_history .as_ref()
.items, .unwrap()
expected_history_items .episode_history
); .items,
assert!( expected_history_items
!app_arc );
.lock() assert!(
.await !app_arc
.data .lock()
.sonarr_data .await
.season_details_modal .data
.as_ref() .sonarr_data
.unwrap() .season_details_modal
.episode_details_modal .as_ref()
.as_ref() .unwrap()
.unwrap() .episode_details_modal
.episode_history .as_ref()
.sort_asc .unwrap()
); .episode_history
assert_eq!(history, response); .sort_asc
} );
assert_eq!(history, response);
} }
#[tokio::test] #[tokio::test]
@@ -765,45 +771,46 @@ mod tests {
app_arc.lock().await.server_tabs.next(); app_arc.lock().await.server_tabs.next();
let mut network = test_network(&app_arc); let mut network = test_network(&app_arc);
if let SonarrSerdeable::SonarrHistoryWrapper(history) = network let SonarrSerdeable::SonarrHistoryWrapper(history) = network
.handle_sonarr_event(SonarrEvent::GetEpisodeHistory(1)) .handle_sonarr_event(SonarrEvent::GetEpisodeHistory(1))
.await .await
.unwrap() .unwrap()
{ else {
async_server.assert_async().await; panic!("Expected SonarrHistoryWrapper")
assert_eq!( };
app_arc async_server.assert_async().await;
.lock() assert_eq!(
.await app_arc
.data .lock()
.sonarr_data .await
.season_details_modal .data
.as_ref() .sonarr_data
.unwrap() .season_details_modal
.episode_details_modal .as_ref()
.as_ref() .unwrap()
.unwrap() .episode_details_modal
.episode_history .as_ref()
.items, .unwrap()
expected_history_items .episode_history
); .items,
assert!( expected_history_items
!app_arc );
.lock() assert!(
.await !app_arc
.data .lock()
.sonarr_data .await
.season_details_modal .data
.as_ref() .sonarr_data
.unwrap() .season_details_modal
.episode_details_modal .as_ref()
.as_ref() .unwrap()
.unwrap() .episode_details_modal
.episode_history .as_ref()
.sort_asc .unwrap()
); .episode_history
assert_eq!(history, response); .sort_asc
} );
assert_eq!(history, response);
} }
#[tokio::test] #[tokio::test]
@@ -827,44 +834,30 @@ mod tests {
app_arc.lock().await.server_tabs.next(); app_arc.lock().await.server_tabs.next();
let mut network = test_network(&app_arc); let mut network = test_network(&app_arc);
if let SonarrSerdeable::Episode(episode) = network let SonarrSerdeable::Episode(episode) = network
.handle_sonarr_event(SonarrEvent::GetEpisodeDetails(1)) .handle_sonarr_event(SonarrEvent::GetEpisodeDetails(1))
.await .await
.unwrap() .unwrap()
{ else {
async_server.assert_async().await; panic!("Expected Episode")
assert!( };
app_arc async_server.assert_async().await;
.lock() assert!(
.await app_arc
.data .lock()
.sonarr_data .await
.season_details_modal .data
.as_ref() .sonarr_data
.unwrap() .season_details_modal
.episode_details_modal .as_ref()
.is_some() .unwrap()
); .episode_details_modal
assert_eq!( .is_some()
app_arc );
.lock() assert_eq!(
.await app_arc
.data .lock()
.sonarr_data .await
.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
.data .data
.sonarr_data .sonarr_data
.season_details_modal .season_details_modal
@@ -872,52 +865,67 @@ mod tests {
.unwrap() .unwrap()
.episode_details_modal .episode_details_modal
.as_ref() .as_ref()
.unwrap(); .unwrap()
assert_str_eq!( .episode_details_tabs
episode_details_modal.episode_details.get_text(), .get_active_route(),
formatdoc!( ActiveSonarrBlock::EpisodeHistory.into()
"Title: Something cool );
Season: 1 assert_eq!(episode, response);
Episode Number: 1
Air Date: 2024-02-10 07:28:45 UTC let app = app_arc.lock().await;
Status: Downloaded let episode_details_modal = app
Description: Okay so this one time at band camp..." .data
) .sonarr_data
); .season_details_modal
assert_str_eq!( .as_ref()
episode_details_modal.file_details, .unwrap()
formatdoc!( .episode_details_modal
"Relative Path: /season 1/episode 1.mkv .as_ref()
Absolute Path: /nfs/tv/series/season 1/episode 1.mkv .unwrap();
Size: 3.30 GB assert_str_eq!(
Language: English episode_details_modal.episode_details.get_text(),
Date Added: 2024-02-10 07:28:45 UTC" formatdoc!(
) "Title: Something cool
); Season: 1
assert_str_eq!( Episode Number: 1
episode_details_modal.audio_details, Air Date: 2024-02-10 07:28:45 UTC
formatdoc!( Status: Downloaded
"Bitrate: 0 Description: Okay so this one time at band camp..."
Channels: 7.1 )
Codec: AAC );
Languages: eng assert_str_eq!(
Stream Count: 1" episode_details_modal.file_details,
) formatdoc!(
); "Relative Path: /season 1/episode 1.mkv
assert_str_eq!( Absolute Path: /nfs/tv/series/season 1/episode 1.mkv
episode_details_modal.video_details, Size: 3.30 GB
formatdoc!( Language: English
"Bit Depth: 10 Date Added: 2024-02-10 07:28:45 UTC"
Bitrate: 0 )
Codec: x265 );
FPS: 23.976 assert_str_eq!(
Resolution: 1920x1080 episode_details_modal.audio_details,
Scan Type: Progressive formatdoc!(
Runtime: 23:51 "Bitrate: 0
Subtitles: English" 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] #[tokio::test]
@@ -938,81 +946,82 @@ mod tests {
app_arc.lock().await.server_tabs.next(); app_arc.lock().await.server_tabs.next();
let mut network = test_network(&app_arc); let mut network = test_network(&app_arc);
if let SonarrSerdeable::Episode(episode) = network let SonarrSerdeable::Episode(episode) = network
.handle_sonarr_event(SonarrEvent::GetEpisodeDetails(1)) .handle_sonarr_event(SonarrEvent::GetEpisodeDetails(1))
.await .await
.unwrap() .unwrap()
{ else {
async_server.assert_async().await; panic!("Expected Episode")
assert!( };
app_arc async_server.assert_async().await;
.lock() assert!(
.await app_arc
.data .lock()
.sonarr_data .await
.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
.data .data
.sonarr_data .sonarr_data
.season_details_modal .season_details_modal
.as_ref() .as_ref()
.unwrap() .unwrap()
.episode_details_modal .episode_details_modal
.as_ref() .is_some()
.unwrap(); );
assert_str_eq!( assert_eq!(episode, response);
episode_details_modal.episode_details.get_text(),
formatdoc!( let app = app_arc.lock().await;
"Title: Something cool let episode_details_modal = app
Season: 1 .data
Episode Number: 1 .sonarr_data
Air Date: 2024-02-10 07:28:45 UTC .season_details_modal
Status: Downloaded .as_ref()
Description: Okay so this one time at band camp..." .unwrap()
) .episode_details_modal
); .as_ref()
assert_str_eq!( .unwrap();
episode_details_modal.file_details, assert_str_eq!(
formatdoc!( episode_details_modal.episode_details.get_text(),
"Relative Path: /season 1/episode 1.mkv formatdoc!(
Absolute Path: /nfs/tv/series/season 1/episode 1.mkv "Title: Something cool
Size: 3.30 GB Season: 1
Language: English Episode Number: 1
Date Added: 2024-02-10 07:28:45 UTC" 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.audio_details, );
formatdoc!( assert_str_eq!(
"Bitrate: 0 episode_details_modal.file_details,
Channels: 7.1 formatdoc!(
Codec: AAC "Relative Path: /season 1/episode 1.mkv
Languages: eng Absolute Path: /nfs/tv/series/season 1/episode 1.mkv
Stream Count: 1" Size: 3.30 GB
) Language: English
); Date Added: 2024-02-10 07:28:45 UTC"
assert_str_eq!( )
episode_details_modal.video_details, );
formatdoc!( assert_str_eq!(
"Bit Depth: 10 episode_details_modal.audio_details,
Bitrate: 0 formatdoc!(
Codec: x265 "Bitrate: 0
FPS: 23.976 Channels: 7.1
Resolution: 1920x1080 Codec: AAC
Scan Type: Progressive Languages: eng
Runtime: 23:51 Stream Count: 1"
Subtitles: English" )
) );
); 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] #[tokio::test]
@@ -1027,14 +1036,15 @@ mod tests {
app_arc.lock().await.server_tabs.next(); app_arc.lock().await.server_tabs.next();
let mut network = test_network(&app_arc); let mut network = test_network(&app_arc);
if let SonarrSerdeable::Episode(episode) = network let SonarrSerdeable::Episode(episode) = network
.handle_sonarr_event(SonarrEvent::GetEpisodeDetails(1)) .handle_sonarr_event(SonarrEvent::GetEpisodeDetails(1))
.await .await
.unwrap() .unwrap()
{ else {
async_server.assert_async().await; panic!("Expected Episode")
assert_eq!(episode, response); };
} async_server.assert_async().await;
assert_eq!(episode, response);
} }
#[tokio::test] #[tokio::test]
@@ -1092,30 +1102,31 @@ mod tests {
app_arc.lock().await.server_tabs.next(); app_arc.lock().await.server_tabs.next();
let mut network = test_network(&app_arc); 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)) .handle_sonarr_event(SonarrEvent::GetEpisodeReleases(1))
.await .await
.unwrap() .unwrap()
{ else {
async_server.assert_async().await; panic!("Expected Releases")
assert_eq!( };
app_arc async_server.assert_async().await;
.lock() assert_eq!(
.await app_arc
.data .lock()
.sonarr_data .await
.season_details_modal .data
.as_ref() .sonarr_data
.unwrap() .season_details_modal
.episode_details_modal .as_ref()
.as_ref() .unwrap()
.unwrap() .episode_details_modal
.episode_releases .as_ref()
.items, .unwrap()
vec![release()] .episode_releases
); .items,
assert_eq!(releases_vec, vec![release()]); vec![release()]
} );
assert_eq!(releases_vec, vec![release()]);
} }
#[tokio::test] #[tokio::test]
@@ -1146,30 +1157,31 @@ mod tests {
app_arc.lock().await.server_tabs.next(); app_arc.lock().await.server_tabs.next();
let mut network = test_network(&app_arc); 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)) .handle_sonarr_event(SonarrEvent::GetEpisodeReleases(1))
.await .await
.unwrap() .unwrap()
{ else {
async_server.assert_async().await; panic!("Expected Releases")
assert_eq!( };
app_arc async_server.assert_async().await;
.lock() assert_eq!(
.await app_arc
.data .lock()
.sonarr_data .await
.season_details_modal .data
.as_ref() .sonarr_data
.unwrap() .season_details_modal
.episode_details_modal .as_ref()
.as_ref() .unwrap()
.unwrap() .episode_details_modal
.episode_releases .as_ref()
.items, .unwrap()
vec![release()] .episode_releases
); .items,
assert_eq!(releases_vec, vec![release()]); vec![release()]
} );
assert_eq!(releases_vec, vec![release()]);
} }
#[tokio::test] #[tokio::test]
src/network/sonarr_network/library/seasons/sonarr_seasons_network_tests.rs
+90 -87
View File
@@ -136,27 +136,28 @@ mod tests {
app.lock().await.server_tabs.next(); app.lock().await.server_tabs.next();
let mut network = test_network(&app); 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))) .handle_sonarr_event(SonarrEvent::GetSeasonReleases((1, 1)))
.await .await
.unwrap() .unwrap()
{ else {
mock.assert_async().await; panic!("Expected Releases")
assert_eq!( };
app mock.assert_async().await;
.lock() assert_eq!(
.await app
.data .lock()
.sonarr_data .await
.season_details_modal .data
.as_ref() .sonarr_data
.unwrap() .season_details_modal
.season_releases .as_ref()
.items, .unwrap()
vec![expected_filtered_sonarr_release] .season_releases
); .items,
assert_eq!(releases_vec, expected_raw_sonarr_releases); vec![expected_filtered_sonarr_release]
} );
assert_eq!(releases_vec, expected_raw_sonarr_releases);
} }
#[tokio::test] #[tokio::test]
@@ -319,39 +320,40 @@ mod tests {
app.lock().await.server_tabs.next(); app.lock().await.server_tabs.next();
let mut network = test_network(&app); let mut network = test_network(&app);
if let SonarrSerdeable::SonarrHistoryItems(history) = network let SonarrSerdeable::SonarrHistoryItems(history) = network
.handle_sonarr_event(SonarrEvent::GetSeasonHistory((1, 1))) .handle_sonarr_event(SonarrEvent::GetSeasonHistory((1, 1)))
.await .await
.unwrap() .unwrap()
{ else {
mock.assert_async().await; panic!("Expected SonarrHistoryItems")
assert_eq!( };
app mock.assert_async().await;
.lock() assert_eq!(
.await app
.data .lock()
.sonarr_data .await
.season_details_modal .data
.as_ref() .sonarr_data
.unwrap() .season_details_modal
.season_history .as_ref()
.items, .unwrap()
expected_history_items .season_history
); .items,
assert!( expected_history_items
app );
.lock() assert!(
.await app
.data .lock()
.sonarr_data .await
.season_details_modal .data
.as_ref() .sonarr_data
.unwrap() .season_details_modal
.season_history .as_ref()
.sort_asc .unwrap()
); .season_history
assert_eq!(history, response); .sort_asc
} );
assert_eq!(history, response);
} }
#[tokio::test] #[tokio::test]
@@ -419,48 +421,49 @@ mod tests {
app.lock().await.server_tabs.next(); app.lock().await.server_tabs.next();
let mut network = test_network(&app); let mut network = test_network(&app);
if let SonarrSerdeable::SonarrHistoryItems(history) = network let SonarrSerdeable::SonarrHistoryItems(history) = network
.handle_sonarr_event(SonarrEvent::GetSeasonHistory((1, 1))) .handle_sonarr_event(SonarrEvent::GetSeasonHistory((1, 1)))
.await .await
.unwrap() .unwrap()
{ else {
mock.assert_async().await; panic!("Expected SonarrHistoryItems")
assert!( };
app mock.assert_async().await;
.lock() assert!(
.await app
.data .lock()
.sonarr_data .await
.season_details_modal .data
.is_some() .sonarr_data
); .season_details_modal
assert_eq!( .is_some()
app );
.lock() assert_eq!(
.await app
.data .lock()
.sonarr_data .await
.season_details_modal .data
.as_ref() .sonarr_data
.unwrap() .season_details_modal
.season_history .as_ref()
.items, .unwrap()
expected_history_items .season_history
); .items,
assert!( expected_history_items
!app );
.lock() assert!(
.await !app
.data .lock()
.sonarr_data .await
.season_details_modal .data
.as_ref() .sonarr_data
.unwrap() .season_details_modal
.season_history .as_ref()
.sort_asc .unwrap()
); .season_history
assert_eq!(history, response); .sort_asc
} );
assert_eq!(history, response);
} }
#[tokio::test] #[tokio::test]
src/network/sonarr_network/library/series/sonarr_series_network_tests.rs
+133 -127
View File
@@ -409,14 +409,15 @@ mod tests {
app.lock().await.server_tabs.next(); app.lock().await.server_tabs.next();
let mut network = test_network(&app); let mut network = test_network(&app);
if let SonarrSerdeable::Series(series) = network let SonarrSerdeable::Series(series) = network
.handle_sonarr_event(SonarrEvent::GetSeriesDetails(1)) .handle_sonarr_event(SonarrEvent::GetSeriesDetails(1))
.await .await
.unwrap() .unwrap()
{ else {
async_server.assert_async().await; panic!("Expected Series")
assert_eq!(series, expected_series); };
} async_server.assert_async().await;
assert_eq!(series, expected_series);
} }
#[rstest] #[rstest]
@@ -500,38 +501,39 @@ mod tests {
app.lock().await.server_tabs.next(); app.lock().await.server_tabs.next();
let mut network = test_network(&app); 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)) .handle_sonarr_event(SonarrEvent::GetSeriesHistory(1))
.await .await
.unwrap() .unwrap()
{ else {
async_server.assert_async().await; panic!("Expected SonarrHistoryItems")
assert!(app.lock().await.data.sonarr_data.series_history.is_some()); };
assert_eq!( async_server.assert_async().await;
app assert!(app.lock().await.data.sonarr_data.series_history.is_some());
.lock() assert_eq!(
.await app
.data .lock()
.sonarr_data .await
.series_history .data
.as_ref() .sonarr_data
.unwrap() .series_history
.items, .as_ref()
expected_history_items .unwrap()
); .items,
assert!( expected_history_items
app );
.lock() assert!(
.await app
.data .lock()
.sonarr_data .await
.series_history .data
.as_ref() .sonarr_data
.unwrap() .series_history
.sort_asc .as_ref()
); .unwrap()
assert_eq!(history_items, response); .sort_asc
} );
assert_eq!(history_items, response);
} }
#[tokio::test] #[tokio::test]
@@ -592,38 +594,39 @@ mod tests {
app.lock().await.server_tabs.next(); app.lock().await.server_tabs.next();
let mut network = test_network(&app); 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)) .handle_sonarr_event(SonarrEvent::GetSeriesHistory(1))
.await .await
.unwrap() .unwrap()
{ else {
async_server.assert_async().await; panic!("Expected SonarrHistoryItems")
assert!(app.lock().await.data.sonarr_data.series_history.is_some()); };
assert_eq!( async_server.assert_async().await;
app assert!(app.lock().await.data.sonarr_data.series_history.is_some());
.lock() assert_eq!(
.await app
.data .lock()
.sonarr_data .await
.series_history .data
.as_ref() .sonarr_data
.unwrap() .series_history
.items, .as_ref()
expected_history_items .unwrap()
); .items,
assert!( expected_history_items
!app );
.lock() assert!(
.await !app
.data .lock()
.sonarr_data .await
.series_history .data
.as_ref() .sonarr_data
.unwrap() .series_history
.sort_asc .as_ref()
); .unwrap()
assert_eq!(history_items, response); .sort_asc
} );
assert_eq!(history_items, response);
} }
#[tokio::test] #[tokio::test]
@@ -690,37 +693,38 @@ mod tests {
app.lock().await.server_tabs.next(); app.lock().await.server_tabs.next();
let mut network = test_network(&app); 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)) .handle_sonarr_event(SonarrEvent::GetSeriesHistory(1))
.await .await
.unwrap() .unwrap()
{ else {
async_server.assert_async().await; panic!("Expected SonarrHistoryItems")
assert!(app.lock().await.data.sonarr_data.series_history.is_some()); };
assert!( async_server.assert_async().await;
app assert!(app.lock().await.data.sonarr_data.series_history.is_some());
.lock() assert!(
.await app
.data .lock()
.sonarr_data .await
.series_history .data
.as_ref() .sonarr_data
.unwrap() .series_history
.is_empty() .as_ref()
); .unwrap()
assert!( .is_empty()
app );
.lock() assert!(
.await app
.data .lock()
.sonarr_data .await
.series_history .data
.as_ref() .sonarr_data
.unwrap() .series_history
.sort_asc .as_ref()
); .unwrap()
assert_eq!(history_items, response); .sort_asc
} );
assert_eq!(history_items, response);
} }
#[rstest] #[rstest]
@@ -784,19 +788,20 @@ mod tests {
app.lock().await.server_tabs.next(); app.lock().await.server_tabs.next();
let mut network = test_network(&app); let mut network = test_network(&app);
if let SonarrSerdeable::SeriesVec(series) = network let SonarrSerdeable::SeriesVec(series) = network
.handle_sonarr_event(SonarrEvent::ListSeries) .handle_sonarr_event(SonarrEvent::ListSeries)
.await .await
.unwrap() .unwrap()
{ else {
async_server.assert_async().await; panic!("Expected SeriesVec")
assert_eq!( };
app.lock().await.data.sonarr_data.series.items, async_server.assert_async().await;
expected_sorted_series assert_eq!(
); app.lock().await.data.sonarr_data.series.items,
assert!(app.lock().await.data.sonarr_data.series.sort_asc); expected_sorted_series
assert_eq!(series, expected_series); );
} assert!(app.lock().await.data.sonarr_data.series.sort_asc);
assert_eq!(series, expected_series);
} }
#[tokio::test] #[tokio::test]
@@ -872,35 +877,36 @@ mod tests {
app.lock().await.server_tabs.next(); app.lock().await.server_tabs.next();
let mut network = test_network(&app); 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())) .handle_sonarr_event(SonarrEvent::SearchNewSeries("test term".into()))
.await .await
.unwrap() .unwrap()
{ else {
async_server.assert_async().await; panic!("Expected AddSeriesSearchResults")
assert!( };
app async_server.assert_async().await;
.lock() assert!(
.await app
.data .lock()
.sonarr_data .await
.add_searched_series .data
.is_some() .sonarr_data
); .add_searched_series
assert_eq!( .is_some()
app );
.lock() assert_eq!(
.await app
.data .lock()
.sonarr_data .await
.add_searched_series .data
.as_ref() .sonarr_data
.unwrap() .add_searched_series
.items, .as_ref()
vec![add_series_search_result()] .unwrap()
); .items,
assert_eq!(add_series_search_results, vec![add_series_search_result()]); vec![add_series_search_result()]
} );
assert_eq!(add_series_search_results, vec![add_series_search_result()]);
} }
#[tokio::test] #[tokio::test]
src/network/sonarr_network/root_folders/sonarr_root_folders_network_tests.rs
+10 -9
View File
@@ -71,17 +71,18 @@ mod tests {
app.lock().await.server_tabs.next(); app.lock().await.server_tabs.next();
let mut network = test_network(&app); let mut network = test_network(&app);
if let SonarrSerdeable::RootFolders(root_folders) = network let SonarrSerdeable::RootFolders(root_folders) = network
.handle_sonarr_event(SonarrEvent::GetRootFolders) .handle_sonarr_event(SonarrEvent::GetRootFolders)
.await .await
.unwrap() .unwrap()
{ else {
mock.assert_async().await; panic!("Expected RootFolders")
assert_eq!( };
app.lock().await.data.sonarr_data.root_folders.items, mock.assert_async().await;
vec![root_folder()] assert_eq!(
); app.lock().await.data.sonarr_data.root_folders.items,
assert_eq!(root_folders, response); vec![root_folder()]
} );
assert_eq!(root_folders, response);
} }
} }
src/network/sonarr_network/sonarr_network_tests.rs
+8 -4
View File
@@ -212,8 +212,9 @@ mod test {
mock.assert_async().await; mock.assert_async().await;
let SonarrSerdeable::Tag(tag) = result.unwrap() else { let SonarrSerdeable::Tag(tag) = result.unwrap() else {
panic!("Expected Tag variant"); panic!("Expected Tag");
}; };
assert_eq!(tag, expected); assert_eq!(tag, expected);
assert_eq!( assert_eq!(
app.lock().await.data.sonarr_data.tags_map, app.lock().await.data.sonarr_data.tags_map,
@@ -278,8 +279,9 @@ mod test {
mock.assert_async().await; mock.assert_async().await;
let SonarrSerdeable::LanguageProfiles(language_profiles) = result.unwrap() else { let SonarrSerdeable::LanguageProfiles(language_profiles) = result.unwrap() else {
panic!("Expected the LanguageProfiles variant") panic!("Expected LanguageProfiles")
}; };
assert_eq!( assert_eq!(
app.lock().await.data.sonarr_data.language_profiles_map, app.lock().await.data.sonarr_data.language_profiles_map,
BiMap::from_iter([(2222i64, "English".to_owned())]) BiMap::from_iter([(2222i64, "English".to_owned())])
@@ -309,8 +311,9 @@ mod test {
mock.assert_async().await; mock.assert_async().await;
let SonarrSerdeable::QualityProfiles(quality_profiles) = result.unwrap() else { let SonarrSerdeable::QualityProfiles(quality_profiles) = result.unwrap() else {
panic!("Expected the QualityProfiles variant") panic!("Expected QualityProfiles")
}; };
assert_eq!( assert_eq!(
app.lock().await.data.sonarr_data.quality_profile_map, app.lock().await.data.sonarr_data.quality_profile_map,
BiMap::from_iter([(2222i64, "HD - 1080p".to_owned())]) BiMap::from_iter([(2222i64, "HD - 1080p".to_owned())])
@@ -337,8 +340,9 @@ mod test {
mock.assert_async().await; mock.assert_async().await;
let SonarrSerdeable::Tags(tags) = result.unwrap() else { let SonarrSerdeable::Tags(tags) = result.unwrap() else {
panic!("Expected the Tag variant") panic!("Expected Tags")
}; };
mock.assert_async().await; mock.assert_async().await;
assert_eq!( assert_eq!(
app.lock().await.data.sonarr_data.tags_map, app.lock().await.data.sonarr_data.tags_map,
src/network/sonarr_network/system/sonarr_system_network_tests.rs
+95 -86
View File
@@ -33,14 +33,15 @@ mod tests {
app.lock().await.server_tabs.next(); app.lock().await.server_tabs.next();
let mut network = test_network(&app); let mut network = test_network(&app);
if let SonarrSerdeable::HostConfig(host_config) = network let SonarrSerdeable::HostConfig(host_config) = network
.handle_sonarr_event(SonarrEvent::GetHostConfig) .handle_sonarr_event(SonarrEvent::GetHostConfig)
.await .await
.unwrap() .unwrap()
{ else {
mock.assert_async().await; panic!("Expected HostConfig")
assert_eq!(host_config, response); };
} mock.assert_async().await;
assert_eq!(host_config, response);
} }
#[tokio::test] #[tokio::test]
@@ -84,26 +85,27 @@ mod tests {
app.lock().await.server_tabs.next(); app.lock().await.server_tabs.next();
let mut network = test_network(&app); let mut network = test_network(&app);
if let SonarrSerdeable::LogResponse(logs) = network let SonarrSerdeable::LogResponse(logs) = network
.handle_sonarr_event(SonarrEvent::GetLogs(500)) .handle_sonarr_event(SonarrEvent::GetLogs(500))
.await .await
.unwrap() .unwrap()
{ else {
mock.assert_async().await; panic!("Expected LogResponse")
assert_eq!(app.lock().await.data.sonarr_data.logs.items, expected_logs); };
assert!( mock.assert_async().await;
app assert_eq!(app.lock().await.data.sonarr_data.logs.items, expected_logs);
.lock() assert!(
.await app
.data .lock()
.sonarr_data .await
.logs .data
.current_selection() .sonarr_data
.text .logs
.contains("INFO") .current_selection()
); .text
assert_eq!(logs, response); .contains("INFO")
} );
assert_eq!(logs, response);
} }
#[tokio::test] #[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) .handle_sonarr_event(SonarrEvent::GetDiskSpace)
.await .await
.unwrap() .unwrap()
{ else {
mock.assert_async().await; panic!("Expected DiskSpaces")
assert_eq!( };
app.lock().await.data.sonarr_data.disk_space_vec, mock.assert_async().await;
disk_space_vec assert_eq!(
); app.lock().await.data.sonarr_data.disk_space_vec,
assert_eq!(disk_space, disk_space_vec); disk_space_vec
} );
assert_eq!(disk_space, disk_space_vec);
} }
#[tokio::test] #[tokio::test]
@@ -180,18 +183,19 @@ mod tests {
app.lock().await.server_tabs.next(); app.lock().await.server_tabs.next();
let mut network = test_network(&app); let mut network = test_network(&app);
if let SonarrSerdeable::QueueEvents(events) = network let SonarrSerdeable::QueueEvents(events) = network
.handle_sonarr_event(SonarrEvent::GetQueuedEvents) .handle_sonarr_event(SonarrEvent::GetQueuedEvents)
.await .await
.unwrap() .unwrap()
{ else {
mock.assert_async().await; panic!("Expected QueueEvents")
assert_eq!( };
app.lock().await.data.sonarr_data.queued_events.items, mock.assert_async().await;
vec![expected_event] assert_eq!(
); app.lock().await.data.sonarr_data.queued_events.items,
assert_eq!(events, response); vec![expected_event]
} );
assert_eq!(events, response);
} }
#[tokio::test] #[tokio::test]
@@ -213,14 +217,15 @@ mod tests {
app.lock().await.server_tabs.next(); app.lock().await.server_tabs.next();
let mut network = test_network(&app); let mut network = test_network(&app);
if let SonarrSerdeable::SecurityConfig(security_config) = network let SonarrSerdeable::SecurityConfig(security_config) = network
.handle_sonarr_event(SonarrEvent::GetSecurityConfig) .handle_sonarr_event(SonarrEvent::GetSecurityConfig)
.await .await
.unwrap() .unwrap()
{ else {
mock.assert_async().await; panic!("Expected SecurityConfig")
assert_eq!(security_config, response); };
} mock.assert_async().await;
assert_eq!(security_config, response);
} }
#[tokio::test] #[tokio::test]
@@ -236,22 +241,23 @@ mod tests {
let mut network = test_network(&app); let mut network = test_network(&app);
let date_time = DateTime::from(DateTime::parse_from_rfc3339("2023-02-25T20:16:43Z").unwrap()); 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) .handle_sonarr_event(SonarrEvent::GetStatus)
.await .await
.unwrap() .unwrap()
{ else {
mock.assert_async().await; panic!("Expected SystemStatus")
assert_str_eq!(app.lock().await.data.sonarr_data.version, "v1"); };
assert_eq!(app.lock().await.data.sonarr_data.start_time, date_time); mock.assert_async().await;
assert_eq!( assert_str_eq!(app.lock().await.data.sonarr_data.version, "v1");
status, assert_eq!(app.lock().await.data.sonarr_data.start_time, date_time);
SystemStatus { assert_eq!(
version: "v1".to_owned(), status,
start_time: date_time SystemStatus {
} version: "v1".to_owned(),
); start_time: date_time
} }
);
} }
#[tokio::test] #[tokio::test]
@@ -295,18 +301,19 @@ mod tests {
app.lock().await.server_tabs.next(); app.lock().await.server_tabs.next();
let mut network = test_network(&app); let mut network = test_network(&app);
if let SonarrSerdeable::Tasks(tasks) = network let SonarrSerdeable::Tasks(tasks) = network
.handle_sonarr_event(SonarrEvent::GetTasks) .handle_sonarr_event(SonarrEvent::GetTasks)
.await .await
.unwrap() .unwrap()
{ else {
mock.assert_async().await; panic!("Expected Tasks")
assert_eq!( };
app.lock().await.data.sonarr_data.tasks.items, mock.assert_async().await;
expected_tasks assert_eq!(
); app.lock().await.data.sonarr_data.tasks.items,
assert_eq!(tasks, response); expected_tasks
} );
assert_eq!(tasks, response);
} }
#[tokio::test] #[tokio::test]
@@ -385,25 +392,26 @@ mod tests {
app.lock().await.server_tabs.next(); app.lock().await.server_tabs.next();
let mut network = test_network(&app); let mut network = test_network(&app);
if let SonarrSerdeable::Updates(updates) = network let SonarrSerdeable::Updates(updates) = network
.handle_sonarr_event(SonarrEvent::GetUpdates) .handle_sonarr_event(SonarrEvent::GetUpdates)
.await .await
.unwrap() .unwrap()
{ else {
mock.assert_async().await; panic!("Expected Updates")
let actual_text = app.lock().await.data.sonarr_data.updates.get_text(); };
let expected = expected_text.get_text(); 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 // Trim trailing whitespace from each line for comparison
let actual_trimmed: Vec<&str> = actual_text.lines().map(|l| l.trim_end()).collect(); 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(); let expected_trimmed: Vec<&str> = expected.lines().map(|l| l.trim_end()).collect();
assert_eq!( assert_eq!(
actual_trimmed, expected_trimmed, actual_trimmed, expected_trimmed,
"Updates text mismatch (after trimming trailing whitespace)" "Updates text mismatch (after trimming trailing whitespace)"
); );
assert_eq!(updates, response); assert_eq!(updates, response);
}
} }
#[tokio::test] #[tokio::test]
@@ -431,15 +439,16 @@ mod tests {
app.lock().await.server_tabs.next(); app.lock().await.server_tabs.next();
let mut network = test_network(&app); let mut network = test_network(&app);
if let SonarrSerdeable::Value(value) = network let SonarrSerdeable::Value(value) = network
.handle_sonarr_event(SonarrEvent::StartTask( .handle_sonarr_event(SonarrEvent::StartTask(
SonarrTaskName::ApplicationUpdateCheck, SonarrTaskName::ApplicationUpdateCheck,
)) ))
.await .await
.unwrap() .unwrap()
{ else {
mock.assert_async().await; panic!("Expected Value")
assert_eq!(value, response); };
} mock.assert_async().await;
assert_eq!(value, response);
} }
} }
src/ui/radarr_ui/blocklist/mod.rs
+4 -5
View File
@@ -23,11 +23,10 @@ pub(super) struct BlocklistUi;
impl DrawUi for BlocklistUi { impl DrawUi for BlocklistUi {
fn accepts(route: Route) -> bool { fn accepts(route: Route) -> bool {
if let Route::Radarr(active_radarr_block, _) = route { let Route::Radarr(active_radarr_block, _) = route else {
return BLOCKLIST_BLOCKS.contains(&active_radarr_block); return false;
} };
BLOCKLIST_BLOCKS.contains(&active_radarr_block)
false
} }
fn draw(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) { fn draw(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) {
src/ui/radarr_ui/collections/mod.rs
+6 -7
View File
@@ -25,13 +25,12 @@ pub(super) struct CollectionsUi;
impl DrawUi for CollectionsUi { impl DrawUi for CollectionsUi {
fn accepts(route: Route) -> bool { fn accepts(route: Route) -> bool {
if let Route::Radarr(active_radarr_block, _) = route { let Route::Radarr(active_radarr_block, _) = route else {
return CollectionDetailsUi::accepts(route) return false;
|| EditCollectionUi::accepts(route) };
|| COLLECTIONS_BLOCKS.contains(&active_radarr_block); CollectionDetailsUi::accepts(route)
} || EditCollectionUi::accepts(route)
|| COLLECTIONS_BLOCKS.contains(&active_radarr_block)
false
} }
fn draw(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) { fn draw(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) {
src/ui/radarr_ui/downloads/mod.rs
+4 -5
View File
@@ -22,11 +22,10 @@ pub(super) struct DownloadsUi;
impl DrawUi for DownloadsUi { impl DrawUi for DownloadsUi {
fn accepts(route: Route) -> bool { fn accepts(route: Route) -> bool {
if let Route::Radarr(active_radarr_block, _) = route { let Route::Radarr(active_radarr_block, _) = route else {
return DOWNLOADS_BLOCKS.contains(&active_radarr_block); return false;
} };
DOWNLOADS_BLOCKS.contains(&active_radarr_block)
false
} }
fn draw(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) { fn draw(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) {
src/ui/radarr_ui/indexers/indexer_settings_ui.rs
+4 -5
View File
@@ -26,11 +26,10 @@ pub(super) struct IndexerSettingsUi;
impl DrawUi for IndexerSettingsUi { impl DrawUi for IndexerSettingsUi {
fn accepts(route: Route) -> bool { fn accepts(route: Route) -> bool {
if let Route::Radarr(active_radarr_block, _) = route { let Route::Radarr(active_radarr_block, _) = route else {
return INDEXER_SETTINGS_BLOCKS.contains(&active_radarr_block); return false;
} };
INDEXER_SETTINGS_BLOCKS.contains(&active_radarr_block)
false
} }
fn draw(f: &mut Frame<'_>, app: &mut App<'_>, _area: Rect) { fn draw(f: &mut Frame<'_>, app: &mut App<'_>, _area: Rect) {
src/ui/radarr_ui/indexers/test_all_indexers_ui.rs
+4 -5
View File
@@ -19,11 +19,10 @@ pub(super) struct TestAllIndexersUi;
impl DrawUi for TestAllIndexersUi { impl DrawUi for TestAllIndexersUi {
fn accepts(route: Route) -> bool { fn accepts(route: Route) -> bool {
if let Route::Radarr(active_radarr_block, _) = route { let Route::Radarr(active_radarr_block, _) = route else {
return active_radarr_block == ActiveRadarrBlock::TestAllIndexers; return false;
} };
active_radarr_block == ActiveRadarrBlock::TestAllIndexers
false
} }
fn draw(f: &mut Frame<'_>, app: &mut App<'_>, _area: Rect) { fn draw(f: &mut Frame<'_>, app: &mut App<'_>, _area: Rect) {
src/ui/radarr_ui/library/add_movie_ui.rs
+4 -5
View File
@@ -31,11 +31,10 @@ pub(super) struct AddMovieUi;
impl DrawUi for AddMovieUi { impl DrawUi for AddMovieUi {
fn accepts(route: Route) -> bool { fn accepts(route: Route) -> bool {
if let Route::Radarr(active_radarr_block, _) = route { let Route::Radarr(active_radarr_block, _) = route else {
return ADD_MOVIE_BLOCKS.contains(&active_radarr_block); return false;
} };
ADD_MOVIE_BLOCKS.contains(&active_radarr_block)
false
} }
fn draw(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) { fn draw(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) {
src/ui/radarr_ui/library/delete_movie_ui.rs
+4 -5
View File
@@ -17,11 +17,10 @@ pub(super) struct DeleteMovieUi;
impl DrawUi for DeleteMovieUi { impl DrawUi for DeleteMovieUi {
fn accepts(route: Route) -> bool { fn accepts(route: Route) -> bool {
if let Route::Radarr(active_radarr_block, _) = route { let Route::Radarr(active_radarr_block, _) = route else {
return DELETE_MOVIE_BLOCKS.contains(&active_radarr_block); return false;
} };
DELETE_MOVIE_BLOCKS.contains(&active_radarr_block)
false
} }
fn draw(f: &mut Frame<'_>, app: &mut App<'_>, _area: Rect) { fn draw(f: &mut Frame<'_>, app: &mut App<'_>, _area: Rect) {
src/ui/radarr_ui/library/edit_movie_ui.rs
+4 -5
View File
@@ -31,11 +31,10 @@ pub(super) struct EditMovieUi;
impl DrawUi for EditMovieUi { impl DrawUi for EditMovieUi {
fn accepts(route: Route) -> bool { fn accepts(route: Route) -> bool {
if let Route::Radarr(active_radarr_block, _) = route { let Route::Radarr(active_radarr_block, _) = route else {
return EDIT_MOVIE_BLOCKS.contains(&active_radarr_block); return false;
} };
EDIT_MOVIE_BLOCKS.contains(&active_radarr_block)
false
} }
fn draw(f: &mut Frame<'_>, app: &mut App<'_>, _area: Rect) { fn draw(f: &mut Frame<'_>, app: &mut App<'_>, _area: Rect) {
src/ui/radarr_ui/library/movie_details_ui.rs
+4 -5
View File
@@ -32,11 +32,10 @@ pub(super) struct MovieDetailsUi;
impl DrawUi for MovieDetailsUi { impl DrawUi for MovieDetailsUi {
fn accepts(route: Route) -> bool { fn accepts(route: Route) -> bool {
if let Route::Radarr(active_radarr_block, _) = route { let Route::Radarr(active_radarr_block, _) = route else {
return MOVIE_DETAILS_BLOCKS.contains(&active_radarr_block); return false;
} };
MOVIE_DETAILS_BLOCKS.contains(&active_radarr_block)
false
} }
fn draw(f: &mut Frame<'_>, app: &mut App<'_>, _area: Rect) { fn draw(f: &mut Frame<'_>, app: &mut App<'_>, _area: Rect) {
src/ui/radarr_ui/root_folders/mod.rs
+4 -5
View File
@@ -22,11 +22,10 @@ pub(super) struct RootFoldersUi;
impl DrawUi for RootFoldersUi { impl DrawUi for RootFoldersUi {
fn accepts(route: Route) -> bool { fn accepts(route: Route) -> bool {
if let Route::Radarr(active_radarr_block, _) = route { let Route::Radarr(active_radarr_block, _) = route else {
return ROOT_FOLDERS_BLOCKS.contains(&active_radarr_block); return false;
} };
ROOT_FOLDERS_BLOCKS.contains(&active_radarr_block)
false
} }
fn draw(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) { fn draw(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) {
src/ui/radarr_ui/system/mod.rs
+4 -5
View File
@@ -52,11 +52,10 @@ pub(super) struct SystemUi;
impl DrawUi for SystemUi { impl DrawUi for SystemUi {
fn accepts(route: Route) -> bool { fn accepts(route: Route) -> bool {
if let Route::Radarr(active_radarr_block, _) = route { let Route::Radarr(active_radarr_block, _) = route else {
return SystemDetailsUi::accepts(route) || active_radarr_block == ActiveRadarrBlock::System; return false;
} };
SystemDetailsUi::accepts(route) || active_radarr_block == ActiveRadarrBlock::System
false
} }
fn draw(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) { fn draw(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) {
src/ui/radarr_ui/system/system_details_ui.rs
+4 -5
View File
@@ -27,11 +27,10 @@ pub(super) struct SystemDetailsUi;
impl DrawUi for SystemDetailsUi { impl DrawUi for SystemDetailsUi {
fn accepts(route: Route) -> bool { fn accepts(route: Route) -> bool {
if let Route::Radarr(active_radarr_block, _) = route { let Route::Radarr(active_radarr_block, _) = route else {
return SYSTEM_DETAILS_BLOCKS.contains(&active_radarr_block); return false;
} };
SYSTEM_DETAILS_BLOCKS.contains(&active_radarr_block)
false
} }
fn draw(f: &mut Frame<'_>, app: &mut App<'_>, _area: Rect) { fn draw(f: &mut Frame<'_>, app: &mut App<'_>, _area: Rect) {
src/ui/sonarr_ui/indexers/edit_indexer_ui.rs
+4 -5
View File
@@ -23,11 +23,10 @@ pub(super) struct EditIndexerUi;
impl DrawUi for EditIndexerUi { impl DrawUi for EditIndexerUi {
fn accepts(route: Route) -> bool { fn accepts(route: Route) -> bool {
if let Route::Sonarr(active_sonarr_block, _) = route { let Route::Sonarr(active_sonarr_block, _) = route else {
return EDIT_INDEXER_BLOCKS.contains(&active_sonarr_block); return false;
} };
EDIT_INDEXER_BLOCKS.contains(&active_sonarr_block)
false
} }
fn draw(f: &mut Frame<'_>, app: &mut App<'_>, _area: Rect) { fn draw(f: &mut Frame<'_>, app: &mut App<'_>, _area: Rect) {
src/ui/sonarr_ui/indexers/indexer_settings_ui.rs
+4 -5
View File
@@ -23,11 +23,10 @@ pub(super) struct IndexerSettingsUi;
impl DrawUi for IndexerSettingsUi { impl DrawUi for IndexerSettingsUi {
fn accepts(route: Route) -> bool { fn accepts(route: Route) -> bool {
if let Route::Sonarr(active_sonarr_block, _) = route { let Route::Sonarr(active_sonarr_block, _) = route else {
return INDEXER_SETTINGS_BLOCKS.contains(&active_sonarr_block); return false;
} };
INDEXER_SETTINGS_BLOCKS.contains(&active_sonarr_block)
false
} }
fn draw(f: &mut Frame<'_>, app: &mut App<'_>, _area: Rect) { fn draw(f: &mut Frame<'_>, app: &mut App<'_>, _area: Rect) {
src/ui/sonarr_ui/library/add_series_ui.rs
+4 -5
View File
@@ -30,11 +30,10 @@ pub(super) struct AddSeriesUi;
impl DrawUi for AddSeriesUi { impl DrawUi for AddSeriesUi {
fn accepts(route: Route) -> bool { fn accepts(route: Route) -> bool {
if let Route::Sonarr(active_sonarr_block, _) = route { let Route::Sonarr(active_sonarr_block, _) = route else {
return ADD_SERIES_BLOCKS.contains(&active_sonarr_block); return false;
} };
ADD_SERIES_BLOCKS.contains(&active_sonarr_block)
false
} }
fn draw(f: &mut Frame<'_>, app: &mut App<'_>, _area: Rect) { fn draw(f: &mut Frame<'_>, app: &mut App<'_>, _area: Rect) {
src/ui/sonarr_ui/library/delete_series_ui.rs
+4 -5
View File
@@ -17,11 +17,10 @@ pub(super) struct DeleteSeriesUi;
impl DrawUi for DeleteSeriesUi { impl DrawUi for DeleteSeriesUi {
fn accepts(route: Route) -> bool { fn accepts(route: Route) -> bool {
if let Route::Sonarr(active_sonarr_block, _) = route { let Route::Sonarr(active_sonarr_block, _) = route else {
return DELETE_SERIES_BLOCKS.contains(&active_sonarr_block); return false;
} };
DELETE_SERIES_BLOCKS.contains(&active_sonarr_block)
false
} }
fn draw(f: &mut Frame<'_>, app: &mut App<'_>, _area: Rect) { fn draw(f: &mut Frame<'_>, app: &mut App<'_>, _area: Rect) {
src/ui/sonarr_ui/library/edit_series_ui.rs
+4 -5
View File
@@ -32,11 +32,10 @@ pub(super) struct EditSeriesUi;
impl DrawUi for EditSeriesUi { impl DrawUi for EditSeriesUi {
fn accepts(route: Route) -> bool { fn accepts(route: Route) -> bool {
if let Route::Sonarr(active_sonarr_block, _) = route { let Route::Sonarr(active_sonarr_block, _) = route else {
return EDIT_SERIES_BLOCKS.contains(&active_sonarr_block); return false;
} };
EDIT_SERIES_BLOCKS.contains(&active_sonarr_block)
false
} }
fn draw(f: &mut Frame<'_>, app: &mut App<'_>, _area: Rect) { fn draw(f: &mut Frame<'_>, app: &mut App<'_>, _area: Rect) {
src/ui/sonarr_ui/library/episode_details_ui.rs
+4 -5
View File
@@ -39,11 +39,10 @@ pub(super) struct EpisodeDetailsUi;
impl DrawUi for EpisodeDetailsUi { impl DrawUi for EpisodeDetailsUi {
fn accepts(route: Route) -> bool { fn accepts(route: Route) -> bool {
if let Route::Sonarr(active_sonarr_block, _) = route { let Route::Sonarr(active_sonarr_block, _) = route else {
return EPISODE_DETAILS_BLOCKS.contains(&active_sonarr_block); return false;
} };
EPISODE_DETAILS_BLOCKS.contains(&active_sonarr_block)
false
} }
fn draw(f: &mut Frame<'_>, app: &mut App<'_>, _area: Rect) { fn draw(f: &mut Frame<'_>, app: &mut App<'_>, _area: Rect) {
src/ui/sonarr_ui/library/season_details_ui.rs
+4 -6
View File
@@ -38,12 +38,10 @@ pub(super) struct SeasonDetailsUi;
impl DrawUi for SeasonDetailsUi { impl DrawUi for SeasonDetailsUi {
fn accepts(route: Route) -> bool { fn accepts(route: Route) -> bool {
if let Route::Sonarr(active_sonarr_block, _) = route { let Route::Sonarr(active_sonarr_block, _) = route else {
return EpisodeDetailsUi::accepts(route) return false;
|| SEASON_DETAILS_BLOCKS.contains(&active_sonarr_block); };
} EpisodeDetailsUi::accepts(route) || SEASON_DETAILS_BLOCKS.contains(&active_sonarr_block)
false
} }
fn draw(f: &mut Frame<'_>, app: &mut App<'_>, _area: Rect) { fn draw(f: &mut Frame<'_>, app: &mut App<'_>, _area: Rect) {
src/ui/sonarr_ui/library/series_details_ui.rs
+6 -7
View File
@@ -42,13 +42,12 @@ pub(super) struct SeriesDetailsUi;
impl DrawUi for SeriesDetailsUi { impl DrawUi for SeriesDetailsUi {
fn accepts(route: Route) -> bool { fn accepts(route: Route) -> bool {
if let Route::Sonarr(active_sonarr_block, _) = route { let Route::Sonarr(active_sonarr_block, _) = route else {
return SeasonDetailsUi::accepts(route) return false;
|| EpisodeDetailsUi::accepts(route) };
|| SERIES_DETAILS_BLOCKS.contains(&active_sonarr_block); SeasonDetailsUi::accepts(route)
} || EpisodeDetailsUi::accepts(route)
|| SERIES_DETAILS_BLOCKS.contains(&active_sonarr_block)
false
} }
fn draw(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) { fn draw(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) {
src/ui/sonarr_ui/system/mod.rs
+4 -5
View File
@@ -46,11 +46,10 @@ pub(super) struct SystemUi;
impl DrawUi for SystemUi { impl DrawUi for SystemUi {
fn accepts(route: Route) -> bool { fn accepts(route: Route) -> bool {
if let Route::Sonarr(active_sonarr_block, _) = route { let Route::Sonarr(active_sonarr_block, _) = route else {
return SystemDetailsUi::accepts(route) || active_sonarr_block == ActiveSonarrBlock::System; return false;
} };
SystemDetailsUi::accepts(route) || active_sonarr_block == ActiveSonarrBlock::System
false
} }
fn draw(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) { fn draw(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) {
src/ui/sonarr_ui/system/system_details_ui.rs
+4 -5
View File
@@ -27,11 +27,10 @@ pub(super) struct SystemDetailsUi;
impl DrawUi for SystemDetailsUi { impl DrawUi for SystemDetailsUi {
fn accepts(route: Route) -> bool { fn accepts(route: Route) -> bool {
if let Route::Sonarr(active_sonarr_block, _) = route { let Route::Sonarr(active_sonarr_block, _) = route else {
return SYSTEM_DETAILS_BLOCKS.contains(&active_sonarr_block); return false;
} };
SYSTEM_DETAILS_BLOCKS.contains(&active_sonarr_block)
false
} }
fn draw(f: &mut Frame<'_>, app: &mut App<'_>, _area: Rect) { fn draw(f: &mut Frame<'_>, app: &mut App<'_>, _area: Rect) {