feat(network): Support for fetching all Sonarr root folders

src/network/radarr_network.rs

@@ -11,7 +11,7 @@ use crate::models::radarr_models::{
   CollectionMovie, CommandBody, Credit, CreditType, DeleteMovieParams, DiskSpace, DownloadRecord,
   DownloadsResponse, EditCollectionParams, EditIndexerParams, EditMovieParams, IndexerSettings,
   IndexerTestResult, Movie, MovieCommandBody, MovieHistoryItem, RadarrSerdeable,
-  ReleaseDownloadBody, RootFolder, SystemStatus, Tag, Task, TaskName, Update,
+  ReleaseDownloadBody, SystemStatus, Tag, Task, TaskName, Update,
 };
 use crate::models::servarr_data::radarr::modals::{
   AddMovieModal, EditCollectionModal, EditIndexerModal, EditMovieModal, IndexerTestResultModalItem,
@@ -19,7 +19,7 @@ use crate::models::servarr_data::radarr::modals::{
 };
 use crate::models::servarr_data::radarr::radarr_data::ActiveRadarrBlock;
 use crate::models::servarr_models::{
-  HostConfig, Indexer, LogResponse, QualityProfile, QueueEvent, Release, SecurityConfig,
+  HostConfig, Indexer, LogResponse, QualityProfile, QueueEvent, Release, RootFolder, SecurityConfig,
 };
 use crate::models::stateful_table::StatefulTable;
 use crate::models::{HorizontallyScrollableText, Route, Scrollable, ScrollableText};
@@ -228,7 +228,10 @@ impl<'a, 'b> Network<'a, 'b> {
         .get_movie_releases(movie_id)
         .await
         .map(RadarrSerdeable::from),
-      RadarrEvent::GetRootFolders => self.get_root_folders().await.map(RadarrSerdeable::from),
+      RadarrEvent::GetRootFolders => self
+        .get_radarr_root_folders()
+        .await
+        .map(RadarrSerdeable::from),
       RadarrEvent::GetSecurityConfig => self
         .get_radarr_security_config()
         .await
@@ -1785,7 +1788,7 @@ impl<'a, 'b> Network<'a, 'b> {
       .await
   }
 
-  async fn get_root_folders(&mut self) -> Result<Vec<RootFolder>> {
+  async fn get_radarr_root_folders(&mut self) -> Result<Vec<RootFolder>> {
     info!("Fetching Radarr root folders");
     let event = RadarrEvent::GetRootFolders;
 

src/network/radarr_network_tests.rs

@@ -2872,7 +2872,7 @@ mod test {
   }
 
   #[tokio::test]
-  async fn test_handle_get_root_folders_event() {
+  async fn test_handle_get_radarr_root_folders_event() {
     let root_folder_json = json!([{
       "id": 1,
       "path": "/nfs",

src/network/sonarr_network.rs

@@ -10,7 +10,8 @@ use crate::{
       sonarr_data::ActiveSonarrBlock,
     },
     servarr_models::{
-      HostConfig, Indexer, LogResponse, QualityProfile, QueueEvent, Release, SecurityConfig,
+      HostConfig, Indexer, LogResponse, QualityProfile, QueueEvent, Release, RootFolder,
+      SecurityConfig,
     },
     sonarr_models::{
       BlocklistResponse, DownloadRecord, DownloadsResponse, Episode, IndexerSettings, Series,
@@ -46,6 +47,7 @@ pub enum SonarrEvent {
   GetLogs(Option<u64>),
   GetQualityProfiles,
   GetQueuedEvents,
+  GetRootFolders,
   GetEpisodeReleases(Option<i64>),
   GetSeasonReleases(Option<(i64, i64)>),
   GetSecurityConfig,
@@ -71,6 +73,7 @@ impl NetworkResource for SonarrEvent {
       SonarrEvent::GetLogs(_) => "/log",
       SonarrEvent::GetQualityProfiles => "/qualityprofile",
       SonarrEvent::GetQueuedEvents => "/command",
+      SonarrEvent::GetRootFolders => "/rootfolder",
       SonarrEvent::GetSeasonReleases(_) | SonarrEvent::GetEpisodeReleases(_) => "/release",
       SonarrEvent::GetSeriesHistory(_) => "/history/series",
       SonarrEvent::GetStatus => "/system/status",
@@ -147,6 +150,10 @@ impl<'a, 'b> Network<'a, 'b> {
         .get_queued_sonarr_events()
         .await
         .map(SonarrSerdeable::from),
+      SonarrEvent::GetRootFolders => self
+        .get_sonarr_root_folders()
+        .await
+        .map(SonarrSerdeable::from),
       SonarrEvent::GetEpisodeReleases(params) => self
         .get_episode_releases(params)
         .await
@@ -746,6 +753,21 @@ impl<'a, 'b> Network<'a, 'b> {
       .await
   }
 
+  async fn get_sonarr_root_folders(&mut self) -> Result<Vec<RootFolder>> {
+    info!("Fetching Sonarr root folders");
+    let event = SonarrEvent::GetRootFolders;
+
+    let request_props = self
+      .request_props_from(event, RequestMethod::Get, None::<()>, None, None)
+      .await;
+
+    self
+      .handle_request::<(), Vec<RootFolder>>(request_props, |root_folders, mut app| {
+        app.data.sonarr_data.root_folders.set_items(root_folders);
+      })
+      .await
+  }
+
   async fn get_episode_releases(&mut self, episode_id: Option<i64>) -> Result<Vec<Release>> {
     let event = SonarrEvent::GetEpisodeReleases(None);
     let id = self.extract_episode_id(episode_id).await;

src/network/sonarr_network_tests.rs

@@ -18,7 +18,7 @@ mod test {
   use crate::models::servarr_data::sonarr::sonarr_data::ActiveSonarrBlock;
   use crate::models::servarr_models::{
     HostConfig, Indexer, IndexerField, Language, LogResponse, Quality, QualityProfile,
-    QualityWrapper, QueueEvent, Release, SecurityConfig,
+    QualityWrapper, QueueEvent, Release, RootFolder, SecurityConfig,
   };
   use crate::models::sonarr_models::SystemStatus;
   use crate::models::sonarr_models::{
@@ -172,6 +172,11 @@ mod test {
     assert_str_eq!(event.resource(), "/queue");
   }
 
+  #[rstest]
+  fn test_resource_root_folder(#[values(SonarrEvent::GetRootFolders)] event: SonarrEvent) {
+    assert_str_eq!(event.resource(), "/rootfolder");
+  }
+
   #[rstest]
   fn test_resource_release(
     #[values(
@@ -2148,6 +2153,41 @@ mod test {
     }
   }
 
+  #[tokio::test]
+  async fn test_handle_get_sonarr_root_folders_event() {
+    let root_folder_json = json!([{
+      "id": 1,
+      "path": "/nfs",
+      "accessible": true,
+      "freeSpace": 219902325555200u64,
+    }]);
+    let response: Vec<RootFolder> = serde_json::from_value(root_folder_json.clone()).unwrap();
+    let (async_server, app_arc, _server) = mock_servarr_api(
+      RequestMethod::Get,
+      None,
+      Some(root_folder_json),
+      None,
+      SonarrEvent::GetRootFolders,
+      None,
+      None,
+    )
+    .await;
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+
+    if let SonarrSerdeable::RootFolders(root_folders) = network
+      .handle_sonarr_event(SonarrEvent::GetRootFolders)
+      .await
+      .unwrap()
+    {
+      async_server.assert_async().await;
+      assert_eq!(
+        app_arc.lock().await.data.sonarr_data.root_folders.items,
+        vec![root_folder()]
+      );
+      assert_eq!(root_folders, response);
+    }
+  }
+
   #[tokio::test]
   async fn test_handle_get_episode_releases_event() {
     let release_json = json!([{
@@ -3839,4 +3879,14 @@ mod test {
       quality: quality_wrapper(),
     }
   }
+
+  fn root_folder() -> RootFolder {
+    RootFolder {
+      id: 1,
+      path: "/nfs".to_owned(),
+      accessible: true,
+      free_space: 219902325555200,
+      unmapped_folders: None,
+    }
+  }
 }