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

feat(network): Added support for fetching season releases for Sonarr

Browse Source
This commit is contained in:
Alex Clarke
2024-11-19 15:59:35 -07:00
parent 2876913f48
commit cc02832512
24 changed files with 830 additions and 402 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/network/radarr_network.rs
+10 -8
View File
@@ -10,16 +10,17 @@ use crate::models::radarr_models::{
AddMovieBody, AddMovieSearchResult, AddOptions, AddRootFolderBody, BlocklistResponse, Collection,
CollectionMovie, CommandBody, Credit, CreditType, DeleteMovieParams, DiskSpace, DownloadRecord,
DownloadsResponse, EditCollectionParams, EditIndexerParams, EditMovieParams, IndexerSettings,
IndexerTestResult, LogResponse, Movie, MovieCommandBody, MovieHistoryItem, QualityProfile,
RadarrSerdeable, Release, ReleaseDownloadBody, RootFolder, SystemStatus, Tag, Task, TaskName,
Update,
IndexerTestResult, Movie, MovieCommandBody, MovieHistoryItem, RadarrSerdeable,
ReleaseDownloadBody, RootFolder, SystemStatus, Tag, Task, TaskName, Update,
};
use crate::models::servarr_data::radarr::modals::{
AddMovieModal, EditCollectionModal, EditIndexerModal, EditMovieModal, IndexerTestResultModalItem,
MovieDetailsModal,
};
use crate::models::servarr_data::radarr::radarr_data::ActiveRadarrBlock;
use crate::models::servarr_models::{HostConfig, Indexer, QueueEvent, SecurityConfig};
use crate::models::servarr_models::{
HostConfig, Indexer, LogResponse, QualityProfile, QueueEvent, Release, SecurityConfig,
};
use crate::models::stateful_table::StatefulTable;
use crate::models::{HorizontallyScrollableText, Route, Scrollable, ScrollableText};
use crate::network::{Network, NetworkEvent, RequestMethod};
@@ -223,9 +224,10 @@ impl<'a, 'b> Network<'a, 'b> {
.get_queued_radarr_events()
.await
.map(RadarrSerdeable::from),
RadarrEvent::GetReleases(movie_id) => {
self.get_releases(movie_id).await.map(RadarrSerdeable::from)
}
RadarrEvent::GetReleases(movie_id) => self
.get_movie_releases(movie_id)
.await
.map(RadarrSerdeable::from),
RadarrEvent::GetRootFolders => self.get_root_folders().await.map(RadarrSerdeable::from),
RadarrEvent::GetSecurityConfig => self
.get_radarr_security_config()
@@ -1750,7 +1752,7 @@ impl<'a, 'b> Network<'a, 'b> {
.await
}
async fn get_releases(&mut self, movie_id: Option<i64>) -> Result<Vec<Release>> {
async fn get_movie_releases(&mut self, movie_id: Option<i64>) -> Result<Vec<Release>> {
let (id, movie_id_param) = self.extract_movie_id(movie_id).await;
info!("Fetching releases for movie with ID: {id}");
let event = RadarrEvent::GetReleases(None);
src/network/radarr_network_tests.rs
+5 -3
View File
@@ -15,11 +15,13 @@ mod test {
use crate::app::ServarrConfig;
use crate::models::radarr_models::{
BlocklistItem, BlocklistItemMovie, CollectionMovie, Language, MediaInfo, MinimumAvailability,
Monitor, MovieCollection, MovieFile, Quality, QualityWrapper, Rating, RatingsList,
BlocklistItem, BlocklistItemMovie, CollectionMovie, MediaInfo, MinimumAvailability, Monitor,
MovieCollection, MovieFile, Rating, RatingsList,
};
use crate::models::servarr_data::radarr::radarr_data::ActiveRadarrBlock;
use crate::models::servarr_models::{HostConfig, IndexerField};
use crate::models::servarr_models::{
HostConfig, IndexerField, Language, Quality, QualityWrapper,
};
use crate::models::stateful_table::SortOption;
use crate::models::HorizontallyScrollableText;
use crate::network::network_tests::test_utils::mock_servarr_api;
src/network/sonarr_network.rs
+112 -51
View File
@@ -1,18 +1,20 @@
use std::collections::BTreeMap;
use anyhow::Result;
use indoc::formatdoc;
use log::{debug, info};
use managarr_tree_widget::TreeItem;
use serde_json::{json, Value};
use crate::{
models::{
servarr_data::sonarr::{modals::EpisodeDetailsModal, sonarr_data::ActiveSonarrBlock},
servarr_models::{HostConfig, Indexer, QueueEvent, SecurityConfig},
servarr_data::sonarr::{
modals::{EpisodeDetailsModal, SeasonDetailsModal},
sonarr_data::ActiveSonarrBlock,
},
servarr_models::{
HostConfig, Indexer, LogResponse, QualityProfile, QueueEvent, Release, SecurityConfig,
},
sonarr_models::{
BlocklistResponse, DownloadRecord, DownloadsResponse, Episode, IndexerSettings, LogResponse,
QualityProfile, Series, SonarrSerdeable, SystemStatus,
BlocklistResponse, DownloadRecord, DownloadsResponse, Episode, IndexerSettings, Series,
SonarrSerdeable, SystemStatus,
},
HorizontallyScrollableText, Route, Scrollable, ScrollableText,
},
@@ -39,6 +41,7 @@ pub enum SonarrEvent {
GetLogs(Option<u64>),
GetQualityProfiles,
GetQueuedEvents,
GetSeasonReleases(Option<(i64, i64)>),
GetSecurityConfig,
GetStatus,
HealthCheck,
@@ -59,6 +62,7 @@ impl NetworkResource for SonarrEvent {
SonarrEvent::GetLogs(_) => "/log",
SonarrEvent::GetQualityProfiles => "/qualityprofile",
SonarrEvent::GetQueuedEvents => "/command",
SonarrEvent::GetSeasonReleases(_) => "/release",
SonarrEvent::GetStatus => "/system/status",
SonarrEvent::HealthCheck => "/health",
SonarrEvent::ListSeries => "/series",
@@ -100,11 +104,15 @@ impl<'a, 'b> Network<'a, 'b> {
.get_episode_details(episode_id)
.await
.map(SonarrSerdeable::from),
SonarrEvent::GetIndexers => self.get_sonarr_indexers().await.map(SonarrSerdeable::from),
SonarrEvent::GetHostConfig => self
.get_sonarr_host_config()
.await
.map(SonarrSerdeable::from),
SonarrEvent::GetIndexers => self.get_sonarr_indexers().await.map(SonarrSerdeable::from),
SonarrEvent::GetLogs(events) => self
.get_sonarr_logs(events)
.await
.map(SonarrSerdeable::from),
SonarrEvent::GetQualityProfiles => self
.get_sonarr_quality_profiles()
.await
@@ -113,8 +121,8 @@ impl<'a, 'b> Network<'a, 'b> {
.get_queued_sonarr_events()
.await
.map(SonarrSerdeable::from),
SonarrEvent::GetLogs(events) => self
.get_sonarr_logs(events)
SonarrEvent::GetSeasonReleases(params) => self
.get_season_releases(params)
.await
.map(SonarrSerdeable::from),
SonarrEvent::GetSecurityConfig => self
@@ -288,43 +296,29 @@ impl<'a, 'b> Network<'a, 'b> {
episode_vec.sort_by(|a, b| a.id.cmp(&b.id));
if !matches!(
app.get_current_route(),
Route::Sonarr(ActiveSonarrBlock::EpisodesTableSortPrompt, _)
Route::Sonarr(ActiveSonarrBlock::EpisodesSortPrompt, _)
) {
if app.data.sonarr_data.season_details_modal.is_none() {
app.data.sonarr_data.season_details_modal = Some(SeasonDetailsModal::default());
}
app
.data
.sonarr_data
.episodes_table
.season_details_modal
.as_mut()
.unwrap()
.episodes
.set_items(episode_vec.clone());
app
.data
.sonarr_data
.episodes_table
.season_details_modal
.as_mut()
.unwrap()
.episodes
.apply_sorting_toggle(false);
}
let mut seasons = BTreeMap::new();
for episode in episode_vec {
seasons
.entry(episode.season_number)
.or_insert_with(Vec::new)
.push(episode);
}
let tree = seasons
.into_iter()
.map(|(season, episodes_vec)| {
let marker_episode = Episode {
title: Some(format!("Season {season}")),
..Episode::default()
};
let children = episodes_vec.into_iter().map(TreeItem::new_leaf).collect();
TreeItem::new(marker_episode, children).expect("All item identifiers must be unique")
})
.collect();
app.data.sonarr_data.episodes_tree.set_items(tree);
})
.await
}
@@ -431,7 +425,15 @@ impl<'a, 'b> Network<'a, 'b> {
}
};
app.data.sonarr_data.episode_details_modal = Some(episode_details_modal);
if !app.cli_mode {
app
.data
.sonarr_data
.season_details_modal
.as_mut()
.expect("Season details modal is empty")
.episode_details_modal = Some(episode_details_modal);
}
})
.await
}
@@ -548,6 +550,51 @@ impl<'a, 'b> Network<'a, 'b> {
.await
}
async fn get_season_releases(
&mut self,
series_season_id_tuple: Option<(i64, i64)>,
) -> Result<Vec<Release>> {
let event = SonarrEvent::GetSeasonReleases(None);
let (series_id, season_number) =
if let Some((series_id, season_number)) = series_season_id_tuple {
(Some(series_id), Some(season_number))
} else {
(None, None)
};
let (series_id, series_id_param) = self.extract_series_id(series_id).await;
let (season_number, season_number_param) = self.extract_season_number(season_number).await;
info!("Fetching releases for series with ID: {series_id} and season number: {season_number}");
let request_props = self
.request_props_from(
event,
RequestMethod::Get,
None::<()>,
None,
Some(format!("{}&{}", series_id_param, season_number_param)),
)
.await;
self
.handle_request::<(), Vec<Release>>(request_props, |release_vec, mut app| {
if app.data.sonarr_data.season_details_modal.is_none() {
app.data.sonarr_data.season_details_modal = Some(SeasonDetailsModal::default());
}
app
.data
.sonarr_data
.season_details_modal
.as_mut()
.unwrap()
.season_releases
.set_items(release_vec);
})
.await
}
async fn get_sonarr_security_config(&mut self) -> Result<SecurityConfig> {
info!("Fetching Sonarr security config");
let event = SonarrEvent::GetSecurityConfig;
@@ -616,24 +663,38 @@ impl<'a, 'b> Network<'a, 'b> {
(series_id, format!("seriesId={series_id}"))
}
async fn extract_episode_id(&mut self, episode_id: Option<i64>) -> i64 {
let app = self.app.lock().await;
let episode_id = if let Some(id) = episode_id {
id
} else if matches!(
app.get_current_route(),
Route::Sonarr(ActiveSonarrBlock::EpisodesTable, _)
) {
app.data.sonarr_data.episodes_table.current_selection().id
async fn extract_season_number(&mut self, season_number: Option<i64>) -> (i64, String) {
let season_number = if let Some(number) = season_number {
number
} else {
app
self
.app
.lock()
.await
.data
.sonarr_data
.episodes_tree
.seasons
.current_selection()
.season_number
};
(season_number, format!("seasonNumber={season_number}"))
}
async fn extract_episode_id(&mut self, episode_id: Option<i64>) -> i64 {
let episode_id = if let Some(id) = episode_id {
id
} else {
self
.app
.lock()
.await
.data
.sonarr_data
.season_details_modal
.as_ref()
.unwrap()
.expect("Season details have not been loaded")
.episodes
.current_selection()
.id
};
src/network/sonarr_network_tests.rs
+543 -190
View File
@@ -21,16 +21,17 @@ mod test {
use tokio_util::sync::CancellationToken;
use crate::app::App;
use crate::models::servarr_data::sonarr::modals::SeasonDetailsModal;
use crate::models::servarr_data::sonarr::sonarr_data::ActiveSonarrBlock;
use crate::models::servarr_models::{
HostConfig, Indexer, IndexerField, QueueEvent, SecurityConfig,
HostConfig, Indexer, IndexerField, Language, LogResponse, Quality, QualityProfile,
QualityWrapper, QueueEvent, Release, SecurityConfig,
};
use crate::models::sonarr_models::BlocklistResponse;
use crate::models::sonarr_models::SystemStatus;
use crate::models::sonarr_models::{
BlocklistItem, DownloadRecord, DownloadsResponse, Episode, EpisodeFile, Language, LogResponse,
MediaInfo, QualityProfile,
BlocklistItem, DownloadRecord, DownloadsResponse, Episode, EpisodeFile, MediaInfo,
};
use crate::models::sonarr_models::{BlocklistResponse, Quality};
use crate::models::sonarr_models::{QualityWrapper, SystemStatus};
use crate::models::stateful_table::StatefulTable;
use crate::models::HorizontallyScrollableText;
use crate::models::{sonarr_models::SonarrSerdeable, stateful_table::SortOption};
@@ -157,6 +158,11 @@ mod test {
assert_str_eq!(event.resource(), "/indexer");
}
#[rstest]
fn test_resource_release(#[values(SonarrEvent::GetSeasonReleases(None))] event: SonarrEvent) {
assert_str_eq!(event.resource(), "/release");
}
#[rstest]
#[case(SonarrEvent::ClearBlocklist, "/blocklist/bulk")]
#[case(SonarrEvent::DeleteBlocklistItem(None), "/blocklist")]
@@ -408,14 +414,6 @@ mod test {
#[rstest]
#[tokio::test]
async fn test_handle_get_episodes_event(#[values(true, false)] use_custom_sorting: bool) {
let marker_episode_1 = Episode {
title: Some("Season 1".to_owned()),
..Episode::default()
};
let marker_episode_2 = Episode {
title: Some("Season 2".to_owned()),
..Episode::default()
};
let episode_1 = Episode {
title: Some("z test".to_owned()),
episode_file: None,
@@ -432,18 +430,6 @@ mod test {
};
let expected_episodes = vec![episode_1.clone(), episode_2.clone()];
let mut expected_sorted_episodes = vec![episode_1.clone(), episode_2.clone()];
let expected_tree = vec![
TreeItem::new(
marker_episode_1,
vec![TreeItem::new_leaf(episode_1.clone())],
)
.unwrap(),
TreeItem::new(
marker_episode_2,
vec![TreeItem::new_leaf(episode_2.clone())],
)
.unwrap(),
];
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
@@ -454,13 +440,8 @@ mod test {
Some("seriesId=1"),
)
.await;
app_arc
.lock()
.await
.data
.sonarr_data
.episodes_table
.sort_asc = true;
let mut season_details_modal = SeasonDetailsModal::default();
season_details_modal.episodes.sort_asc = true;
if use_custom_sorting {
let cmp_fn = |a: &Episode, b: &Episode| {
a.title
@@ -474,14 +455,11 @@ mod test {
name: "Title",
cmp_fn: Some(cmp_fn),
};
app_arc
.lock()
.await
.data
.sonarr_data
.episodes_table
season_details_modal
.episodes
.sorting(vec![title_sort_option]);
}
app_arc.lock().await.data.sonarr_data.season_details_modal = Some(season_details_modal);
app_arc
.lock()
.await
@@ -501,7 +479,16 @@ mod test {
{
async_server.assert_async().await;
assert_eq!(
app_arc.lock().await.data.sonarr_data.episodes_table.items,
app_arc
.lock()
.await
.data
.sonarr_data
.season_details_modal
.as_ref()
.unwrap()
.episodes
.items,
expected_sorted_episodes
);
assert!(
@@ -510,17 +497,63 @@ mod test {
.await
.data
.sonarr_data
.episodes_table
.season_details_modal
.as_ref()
.unwrap()
.episodes
.sort_asc
);
assert_eq!(
app_arc.lock().await.data.sonarr_data.episodes_tree.items,
expected_tree
);
assert_eq!(episodes, expected_episodes);
}
}
#[tokio::test]
async fn test_handle_get_episodes_event_empty_season_details_modal() {
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(json!([episode()])),
None,
SonarrEvent::GetEpisodes(None),
None,
Some("seriesId=1"),
)
.await;
app_arc
.lock()
.await
.data
.sonarr_data
.series
.set_items(vec![Series {
id: 1,
..Series::default()
}]);
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
if let SonarrSerdeable::Episodes(episodes) = network
.handle_sonarr_event(SonarrEvent::GetEpisodes(None))
.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()]);
}
}
#[tokio::test]
async fn test_handle_get_episodes_event_no_op_while_user_is_selecting_sort_options_on_table() {
let episodes_json = json!([
@@ -551,14 +584,6 @@ mod test {
"monitored": true
}
]);
let marker_episode_1 = Episode {
title: Some("Season 1".to_owned()),
..Episode::default()
};
let marker_episode_2 = Episode {
title: Some("Season 2".to_owned()),
..Episode::default()
};
let episode_1 = Episode {
episode_file: None,
..episode()
@@ -572,18 +597,6 @@ mod test {
..episode()
};
let mut expected_episodes = vec![episode_2.clone(), episode_1.clone()];
let expected_tree = vec![
TreeItem::new(
marker_episode_1,
vec![TreeItem::new_leaf(episode_1.clone())],
)
.unwrap(),
TreeItem::new(
marker_episode_2,
vec![TreeItem::new_leaf(episode_2.clone())],
)
.unwrap(),
];
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
@@ -597,14 +610,9 @@ mod test {
app_arc
.lock()
.await
.push_navigation_stack(ActiveSonarrBlock::EpisodesTableSortPrompt.into());
app_arc
.lock()
.await
.data
.sonarr_data
.episodes_table
.sort_asc = true;
.push_navigation_stack(ActiveSonarrBlock::EpisodesSortPrompt.into());
let mut season_details_modal = SeasonDetailsModal::default();
season_details_modal.episodes.sort_asc = true;
let cmp_fn = |a: &Episode, b: &Episode| {
a.title
.as_ref()
@@ -617,12 +625,8 @@ mod test {
name: "Title",
cmp_fn: Some(cmp_fn),
};
app_arc
.lock()
.await
.data
.sonarr_data
.episodes_table
season_details_modal
.episodes
.sorting(vec![title_sort_option]);
app_arc
.lock()
@@ -634,6 +638,7 @@ mod test {
id: 1,
..Series::default()
}]);
app_arc.lock().await.data.sonarr_data.season_details_modal = Some(season_details_modal);
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
if let SonarrSerdeable::Episodes(episodes) = network
@@ -647,7 +652,10 @@ mod test {
.await
.data
.sonarr_data
.episodes_table
.season_details_modal
.as_ref()
.unwrap()
.episodes
.is_empty());
assert!(
app_arc
@@ -655,13 +663,12 @@ mod test {
.await
.data
.sonarr_data
.episodes_table
.season_details_modal
.as_ref()
.unwrap()
.episodes
.sort_asc
);
assert_eq!(
app_arc.lock().await.data.sonarr_data.episodes_tree.items,
expected_tree
);
assert_eq!(episodes, expected_episodes);
}
}
@@ -791,14 +798,6 @@ mod test {
"monitored": true
}
]);
let marker_episode_1 = Episode {
title: Some("Season 1".to_owned()),
..Episode::default()
};
let marker_episode_2 = Episode {
title: Some("Season 2".to_owned()),
..Episode::default()
};
let episode_1 = Episode {
series_id: 2,
episode_file: None,
@@ -814,18 +813,6 @@ mod test {
..episode()
};
let expected_episodes = vec![episode_2.clone(), episode_1.clone()];
let expected_tree = vec![
TreeItem::new(
marker_episode_1,
vec![TreeItem::new_leaf(episode_1.clone())],
)
.unwrap(),
TreeItem::new(
marker_episode_2,
vec![TreeItem::new_leaf(episode_2.clone())],
)
.unwrap(),
];
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
@@ -844,10 +831,6 @@ mod test {
.unwrap()
{
async_server.assert_async().await;
assert_eq!(
app_arc.lock().await.data.sonarr_data.episodes_tree.items,
expected_tree
);
assert_eq!(episodes, expected_episodes);
}
}
@@ -865,17 +848,13 @@ mod test {
None,
)
.await;
let mut season_details_modal = SeasonDetailsModal::default();
season_details_modal.episodes.set_items(vec![episode()]);
app_arc.lock().await.data.sonarr_data.season_details_modal = Some(season_details_modal);
app_arc
.lock()
.await
.data
.sonarr_data
.episodes_table
.set_items(vec![episode()]);
app_arc
.lock()
.await
.push_navigation_stack(ActiveSonarrBlock::EpisodesTable.into());
.push_navigation_stack(ActiveSonarrBlock::Episodes.into());
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
if let SonarrSerdeable::Episode(episode) = network
@@ -889,12 +868,23 @@ mod test {
.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.data.sonarr_data.episode_details_modal.as_ref().unwrap();
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!(
@@ -955,6 +945,9 @@ mod test {
None,
)
.await;
let mut season_details_modal = SeasonDetailsModal::default();
season_details_modal.episodes.set_items(vec![episode()]);
app_arc.lock().await.data.sonarr_data.season_details_modal = Some(season_details_modal);
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
if let SonarrSerdeable::Episode(episode) = network
@@ -967,6 +960,75 @@ mod test {
}
}
#[tokio::test]
async fn test_handle_get_episode_details_event_season_details_modal_not_required_in_cli_mode() {
let response: Episode = serde_json::from_str(EPISODE_JSON).unwrap();
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(serde_json::from_str(EPISODE_JSON).unwrap()),
None,
SonarrEvent::GetEpisodeDetails(None),
Some("/1"),
None,
)
.await;
app_arc.lock().await.cli_mode = true;
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
if let SonarrSerdeable::Episode(episode) = network
.handle_sonarr_event(SonarrEvent::GetEpisodeDetails(Some(1)))
.await
.unwrap()
{
async_server.assert_async().await;
assert_eq!(episode, response);
}
}
#[tokio::test]
#[should_panic(expected = "Season details have not been loaded")]
async fn test_handle_get_episode_details_event_requires_season_details_modal_to_be_some_when_no_parameter_is_passed(
) {
let (_async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(serde_json::from_str(EPISODE_JSON).unwrap()),
None,
SonarrEvent::GetEpisodeDetails(None),
Some("/1"),
None,
)
.await;
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
network
.handle_sonarr_event(SonarrEvent::GetEpisodeDetails(None))
.await
.unwrap();
}
#[tokio::test]
#[should_panic(expected = "Season details modal is empty")]
async fn test_handle_get_episode_details_event_requires_season_details_modal_to_be_some() {
let (_async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(serde_json::from_str(EPISODE_JSON).unwrap()),
None,
SonarrEvent::GetEpisodeDetails(None),
Some("/1"),
None,
)
.await;
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
network
.handle_sonarr_event(SonarrEvent::GetEpisodeDetails(Some(1)))
.await
.unwrap();
}
#[tokio::test]
async fn test_handle_get_sonarr_logs_event() {
let expected_logs = vec![
@@ -1188,6 +1250,272 @@ mod test {
}
}
#[tokio::test]
async fn test_handle_get_season_releases_event() {
let release_json = json!([{
"guid": "1234",
"protocol": "torrent",
"age": 1,
"title": "Test Release",
"indexer": "kickass torrents",
"indexerId": 2,
"size": 1234,
"rejected": true,
"rejections": [ "Unknown quality profile", "Release is already mapped" ],
"seeders": 2,
"leechers": 1,
"languages": [ { "name": "English" } ],
"quality": { "quality": { "name": "Bluray-1080p" }}
}]);
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(release_json),
None,
SonarrEvent::GetSeasonReleases(None),
None,
Some("seriesId=1&seasonNumber=1"),
)
.await;
app_arc
.lock()
.await
.data
.sonarr_data
.series
.set_items(vec![series()]);
app_arc
.lock()
.await
.data
.sonarr_data
.seasons
.set_items(vec![season()]);
app_arc.lock().await.data.sonarr_data.season_details_modal =
Some(SeasonDetailsModal::default());
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
if let SonarrSerdeable::Releases(releases_vec) = network
.handle_sonarr_event(SonarrEvent::GetSeasonReleases(None))
.await
.unwrap()
{
async_server.assert_async().await;
assert_eq!(
app_arc
.lock()
.await
.data
.sonarr_data
.season_details_modal
.as_ref()
.unwrap()
.season_releases
.items,
vec![release()]
);
assert_eq!(releases_vec, vec![release()]);
}
}
#[tokio::test]
async fn test_handle_get_season_releases_event_empty_season_details_modal() {
let release_json = json!([{
"guid": "1234",
"protocol": "torrent",
"age": 1,
"title": "Test Release",
"indexer": "kickass torrents",
"indexerId": 2,
"size": 1234,
"rejected": true,
"rejections": [ "Unknown quality profile", "Release is already mapped" ],
"seeders": 2,
"leechers": 1,
"languages": [ { "name": "English" } ],
"quality": { "quality": { "name": "Bluray-1080p" }}
}]);
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(release_json),
None,
SonarrEvent::GetSeasonReleases(None),
None,
Some("seriesId=1&seasonNumber=1"),
)
.await;
app_arc
.lock()
.await
.data
.sonarr_data
.series
.set_items(vec![series()]);
app_arc
.lock()
.await
.data
.sonarr_data
.seasons
.set_items(vec![season()]);
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
assert!(network
.handle_sonarr_event(SonarrEvent::GetSeasonReleases(None))
.await
.is_ok());
async_server.assert_async().await;
assert_eq!(
app_arc
.lock()
.await
.data
.sonarr_data
.season_details_modal
.as_ref()
.unwrap()
.season_releases
.items,
vec![release()]
);
}
#[tokio::test]
async fn test_handle_get_season_releases_event_uses_provided_series_id_and_season_number() {
let release_json = json!([{
"guid": "1234",
"protocol": "torrent",
"age": 1,
"title": "Test Release",
"indexer": "kickass torrents",
"indexerId": 2,
"size": 1234,
"rejected": true,
"rejections": [ "Unknown quality profile", "Release is already mapped" ],
"seeders": 2,
"leechers": 1,
"languages": [ { "name": "English" } ],
"quality": { "quality": { "name": "Bluray-1080p" }}
}]);
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(release_json),
None,
SonarrEvent::GetSeasonReleases(None),
None,
Some("seriesId=2&seasonNumber=2"),
)
.await;
app_arc
.lock()
.await
.data
.sonarr_data
.series
.set_items(vec![series()]);
app_arc
.lock()
.await
.data
.sonarr_data
.seasons
.set_items(vec![season()]);
app_arc.lock().await.data.sonarr_data.season_details_modal =
Some(SeasonDetailsModal::default());
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
if let SonarrSerdeable::Releases(releases_vec) = network
.handle_sonarr_event(SonarrEvent::GetSeasonReleases(Some((2, 2))))
.await
.unwrap()
{
async_server.assert_async().await;
assert_eq!(
app_arc
.lock()
.await
.data
.sonarr_data
.season_details_modal
.as_ref()
.unwrap()
.season_releases
.items,
vec![release()]
);
assert_eq!(releases_vec, vec![release()]);
}
}
#[tokio::test]
async fn test_handle_get_season_releases_event_filtered_series_and_filtered_seasons() {
let release_json = json!([{
"guid": "1234",
"protocol": "torrent",
"age": 1,
"title": "Test Release",
"indexer": "kickass torrents",
"indexerId": 2,
"size": 1234,
"rejected": true,
"rejections": [ "Unknown quality profile", "Release is already mapped" ],
"seeders": 2,
"leechers": 1,
"languages": [ { "name": "English" } ],
"quality": { "quality": { "name": "Bluray-1080p" }}
}]);
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(release_json),
None,
SonarrEvent::GetSeasonReleases(None),
None,
Some("seriesId=1&seasonNumber=1"),
)
.await;
let mut filtered_series = StatefulTable::default();
filtered_series.set_filtered_items(vec![Series {
id: 1,
..Series::default()
}]);
app_arc.lock().await.data.sonarr_data.series = filtered_series;
let mut filtered_seasons = StatefulTable::default();
filtered_seasons.set_filtered_items(vec![Season {
season_number: 1,
..Season::default()
}]);
app_arc.lock().await.data.sonarr_data.seasons = filtered_seasons;
app_arc.lock().await.data.sonarr_data.season_details_modal =
Some(SeasonDetailsModal::default());
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
if let SonarrSerdeable::Releases(releases_vec) = network
.handle_sonarr_event(SonarrEvent::GetSeasonReleases(None))
.await
.unwrap()
{
async_server.assert_async().await;
assert_eq!(
app_arc
.lock()
.await
.data
.sonarr_data
.season_details_modal
.as_ref()
.unwrap()
.season_releases
.items,
vec![release()]
);
assert_eq!(releases_vec, vec![release()]);
}
}
#[rstest]
#[tokio::test]
async fn test_handle_get_series_event(#[values(true, false)] use_custom_sorting: bool) {
@@ -1459,22 +1787,76 @@ mod test {
}
#[tokio::test]
async fn test_extract_episode_id() {
async fn test_extract_season_number() {
let app_arc = Arc::new(Mutex::new(App::default()));
app_arc
.lock()
.await
.data
.sonarr_data
.episodes_table
.set_items(vec![Episode {
id: 1,
..Episode::default()
.seasons
.set_items(vec![Season {
season_number: 1,
..Season::default()
}]);
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let (id, season_number_param) = network.extract_season_number(None).await;
assert_eq!(id, 1);
assert_str_eq!(season_number_param, "seasonNumber=1");
}
#[tokio::test]
async fn test_extract_season_number_uses_provided_season_number() {
let app_arc = Arc::new(Mutex::new(App::default()));
app_arc
.lock()
.await
.push_navigation_stack(ActiveSonarrBlock::EpisodesTable.into());
.data
.sonarr_data
.seasons
.set_items(vec![Season {
season_number: 1,
..Season::default()
}]);
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let (id, season_number_param) = network.extract_season_number(Some(2)).await;
assert_eq!(id, 2);
assert_str_eq!(season_number_param, "seasonNumber=2");
}
#[tokio::test]
async fn test_extract_season_number_filtered_seasons() {
let app_arc = Arc::new(Mutex::new(App::default()));
let mut filtered_seasons = StatefulTable::default();
filtered_seasons.set_filtered_items(vec![Season {
season_number: 1,
..Season::default()
}]);
app_arc.lock().await.data.sonarr_data.seasons = filtered_seasons;
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let (id, season_number_param) = network.extract_season_number(None).await;
assert_eq!(id, 1);
assert_str_eq!(season_number_param, "seasonNumber=1");
}
#[tokio::test]
async fn test_extract_episode_id() {
let app_arc = Arc::new(Mutex::new(App::default()));
let mut season_details_modal = SeasonDetailsModal::default();
season_details_modal.episodes.set_items(vec![Episode {
id: 1,
..Episode::default()
}]);
app_arc.lock().await.data.sonarr_data.season_details_modal = Some(season_details_modal);
app_arc
.lock()
.await
.push_navigation_stack(ActiveSonarrBlock::Episodes.into());
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let id = network.extract_episode_id(None).await;
@@ -1485,20 +1867,16 @@ mod test {
#[tokio::test]
async fn test_extract_episode_id_uses_provided_id() {
let app_arc = Arc::new(Mutex::new(App::default()));
let mut season_details_modal = SeasonDetailsModal::default();
season_details_modal.episodes.set_items(vec![Episode {
id: 1,
..Episode::default()
}]);
app_arc.lock().await.data.sonarr_data.season_details_modal = Some(season_details_modal);
app_arc
.lock()
.await
.data
.sonarr_data
.episodes_table
.set_items(vec![Episode {
id: 1,
..Episode::default()
}]);
app_arc
.lock()
.await
.push_navigation_stack(ActiveSonarrBlock::EpisodesTable.into());
.push_navigation_stack(ActiveSonarrBlock::Episodes.into());
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let id = network.extract_episode_id(Some(2)).await;
@@ -1514,11 +1892,15 @@ mod test {
id: 1,
..Episode::default()
}]);
app_arc.lock().await.data.sonarr_data.episodes_table = filtered_episodes;
let season_details_modal = SeasonDetailsModal {
episodes: filtered_episodes,
..SeasonDetailsModal::default()
};
app_arc.lock().await.data.sonarr_data.season_details_modal = Some(season_details_modal);
app_arc
.lock()
.await
.push_navigation_stack(ActiveSonarrBlock::EpisodesTable.into());
.push_navigation_stack(ActiveSonarrBlock::Episodes.into());
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let id = network.extract_episode_id(None).await;
@@ -1526,60 +1908,6 @@ mod test {
assert_eq!(id, 1);
}
#[tokio::test]
async fn test_extract_episode_id_from_tree() {
let app_arc = Arc::new(Mutex::new(App::default()));
{
let mut app = app_arc.lock().await;
let items = vec![TreeItem::new_leaf(Episode {
id: 1,
..Episode::default()
})];
app.data.sonarr_data.episodes_tree.set_items(items.clone());
render(
&mut app.data.sonarr_data.episodes_tree.state,
&items.clone(),
);
app.data.sonarr_data.episodes_tree.state.key_down();
render(
&mut app.data.sonarr_data.episodes_tree.state,
&items.clone(),
);
}
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let id = network.extract_episode_id(None).await;
assert_eq!(id, 1);
}
#[tokio::test]
async fn test_extract_episode_id_uses_provided_id_over_tree() {
let app_arc = Arc::new(Mutex::new(App::default()));
{
let mut app = app_arc.lock().await;
let items = vec![TreeItem::new_leaf(Episode {
id: 1,
..Episode::default()
})];
app.data.sonarr_data.episodes_tree.set_items(items.clone());
render(
&mut app.data.sonarr_data.episodes_tree.state,
&items.clone(),
);
app.data.sonarr_data.episodes_tree.state.key_down();
render(
&mut app.data.sonarr_data.episodes_tree.state,
&items.clone(),
);
}
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let id = network.extract_episode_id(Some(2)).await;
assert_eq!(id, 2);
}
#[test]
fn test_get_episode_status_downloaded() {
assert_str_eq!(get_episode_status(true, &[], 0), "Downloaded");
@@ -1831,6 +2159,31 @@ mod test {
}
}
fn rejections() -> Vec<String> {
vec![
"Unknown quality profile".to_owned(),
"Release is already mapped".to_owned(),
]
}
fn release() -> Release {
Release {
guid: "1234".to_owned(),
protocol: "torrent".to_owned(),
age: 1,
title: HorizontallyScrollableText::from("Test Release"),
indexer: "kickass torrents".to_owned(),
indexer_id: 2,
size: 1234,
rejected: true,
rejections: Some(rejections()),
seeders: Some(Number::from(2)),
leechers: Some(Number::from(1)),
languages: Some(vec![language()]),
quality: quality_wrapper(),
}
}
fn render<T>(state: &mut TreeState, items: &[TreeItem<T>])
where
T: ToText + Clone + Default + Display + Hash + PartialEq + Eq,