refactor: Refactored to use more idiomatic let-else statements where applicable
This commit is contained in:
@@ -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,
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -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) {}
|
||||
|
||||
@@ -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) {}
|
||||
|
||||
@@ -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]
|
||||
|
||||
@@ -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]
|
||||
|
||||
@@ -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]
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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]
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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]
|
||||
|
||||
@@ -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]
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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]
|
||||
|
||||
@@ -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]
|
||||
|
||||
@@ -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]
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -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) {
|
||||
|
||||
Reference in New Issue
Block a user