feat(readarr): fetch Readarr downloads and expose them on the CLI

src/cli/readarr/list_command_handler.rs

@@ -72,6 +72,11 @@ pub enum ReadarrListCommand {
   },
   #[command(about = "List disk space details for all provisioned root folders in Readarr")]
   DiskSpace,
+  #[command(about = "List all active downloads in Readarr")]
+  Downloads {
+    #[arg(long, help = "How many downloads to fetch", default_value_t = 500)]
+    count: u64,
+  },
   #[command(about = "Fetch Readarr logs")]
   Logs {
     #[arg(long, help = "How many log events to fetch", default_value_t = 500)]
@@ -174,6 +179,13 @@ impl<'a, 'b> CliCommandHandler<'a, 'b, ReadarrListCommand> for ReadarrListComman
           .await?;
         serde_json::to_string_pretty(&resp)?
       }
+      ReadarrListCommand::Downloads { count } => {
+        let resp = self
+          .network
+          .handle_network_event(ReadarrEvent::GetDownloads(count).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
       ReadarrListCommand::Logs {
         events,
         output_in_log_format,

src/cli/readarr/list_command_handler_tests.rs

@@ -52,6 +52,20 @@ mod tests {
       assert_eq!(result.unwrap_err().kind(), ErrorKind::InvalidValue);
     }
 
+    #[test]
+    fn test_list_downloads_count_flag_requires_arguments() {
+      let result = Cli::command().try_get_matches_from([
+        "managarr",
+        "readarr",
+        "list",
+        "downloads",
+        "--count",
+      ]);
+
+      assert_err!(&result);
+      assert_eq!(result.unwrap_err().kind(), ErrorKind::InvalidValue);
+    }
+
     #[test]
     fn test_list_author_history_requires_author_id() {
       let result =
@@ -234,6 +248,41 @@ mod tests {
       };
       assert_eq!(logs_command, expected_args);
     }
+
+    #[test]
+    fn test_list_downloads_default_values() {
+      let expected_args = ReadarrListCommand::Downloads { count: 500 };
+      let result = Cli::try_parse_from(["managarr", "readarr", "list", "downloads"]);
+
+      assert_ok!(&result);
+
+      let Some(Command::Readarr(ReadarrCommand::List(downloads_command))) = result.unwrap().command
+      else {
+        panic!("Unexpected command type");
+      };
+      assert_eq!(downloads_command, expected_args);
+    }
+
+    #[test]
+    fn test_list_downloads_success() {
+      let expected_args = ReadarrListCommand::Downloads { count: 1000 };
+      let result = Cli::try_parse_from([
+        "managarr",
+        "readarr",
+        "list",
+        "downloads",
+        "--count",
+        "1000",
+      ]);
+
+      assert_ok!(&result);
+
+      let Some(Command::Readarr(ReadarrCommand::List(downloads_command))) = result.unwrap().command
+      else {
+        panic!("Unexpected command type");
+      };
+      assert_eq!(downloads_command, expected_args);
+    }
   }
 
   mod handler {
@@ -433,6 +482,32 @@ mod tests {
       assert_ok!(&result);
     }
 
+    #[tokio::test]
+    async fn test_handle_list_downloads_command() {
+      let expected_count = 1000;
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          ReadarrEvent::GetDownloads(expected_count).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Readarr(ReadarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let list_downloads_command = ReadarrListCommand::Downloads { count: 1000 };
+
+      let result =
+        ReadarrListCommandHandler::with(&app_arc, list_downloads_command, &mut mock_network)
+          .handle()
+          .await;
+
+      assert_ok!(&result);
+    }
+
     #[tokio::test]
     async fn test_handle_list_logs_command() {
       let expected_events = 1000;

src/network/readarr_network/downloads/mod.rs

@@ -0,0 +1,40 @@
+use anyhow::Result;
+use log::info;
+
+use crate::models::readarr_models::DownloadsResponse;
+use crate::network::readarr_network::ReadarrEvent;
+use crate::network::{Network, RequestMethod};
+
+#[cfg(test)]
+#[path = "readarr_downloads_network_tests.rs"]
+mod readarr_downloads_network_tests;
+
+impl Network<'_, '_> {
+  pub(in crate::network::readarr_network) async fn get_readarr_downloads(
+    &mut self,
+    count: u64,
+  ) -> Result<DownloadsResponse> {
+    info!("Fetching Readarr downloads");
+    let event = ReadarrEvent::GetDownloads(count);
+
+    let request_props = self
+      .request_props_from(
+        event,
+        RequestMethod::Get,
+        None::<()>,
+        None,
+        Some(format!("pageSize={count}")),
+      )
+      .await;
+
+    self
+      .handle_request::<(), DownloadsResponse>(request_props, |queue_response, mut app| {
+        app
+          .data
+          .readarr_data
+          .downloads
+          .set_items(queue_response.records);
+      })
+      .await
+  }
+}

src/network/readarr_network/downloads/readarr_downloads_network_tests.rs

@@ -0,0 +1,84 @@
+#[cfg(test)]
+mod tests {
+  use crate::models::readarr_models::ReadarrSerdeable;
+  use crate::network::network_tests::test_utils::{MockServarrApi, test_network};
+  use crate::network::readarr_network::ReadarrEvent;
+  use crate::network::readarr_network::readarr_network_test_utils::test_utils::{
+    DOWNLOAD_RECORD_JSON, download_record, downloads_response, stale_download_record,
+  };
+  use pretty_assertions::assert_eq;
+  use serde_json::{Value, json};
+
+  #[tokio::test]
+  async fn test_handle_get_downloads_event() {
+    let downloads_json = json!({
+      "records": [serde_json::from_str::<Value>(DOWNLOAD_RECORD_JSON).unwrap()]
+    });
+    let (mock, app, _server) = MockServarrApi::get()
+      .returns(downloads_json)
+      .query("pageSize=250")
+      .build_for(ReadarrEvent::GetDownloads(250))
+      .await;
+    {
+      let mut app = app.lock().await;
+      app.server_tabs.set_index(3);
+      app
+        .data
+        .readarr_data
+        .downloads
+        .set_items(vec![stale_download_record()]);
+    }
+    let mut network = test_network(&app);
+
+    let result = network
+      .handle_readarr_event(ReadarrEvent::GetDownloads(250))
+      .await;
+
+    mock.assert_async().await;
+
+    let ReadarrSerdeable::DownloadsResponse(downloads) = result.unwrap() else {
+      panic!("Expected DownloadsResponse")
+    };
+
+    assert_eq!(downloads, downloads_response());
+    assert_eq!(
+      app.lock().await.data.readarr_data.downloads.items,
+      vec![download_record()]
+    );
+  }
+
+  #[tokio::test]
+  async fn test_handle_get_downloads_event_failure() {
+    let stale_downloads = vec![stale_download_record()];
+    let (mock, app, _server) = MockServarrApi::get()
+      .returns(json!({
+        "records": [serde_json::from_str::<Value>(DOWNLOAD_RECORD_JSON).unwrap()]
+      }))
+      .status(500)
+      .query("pageSize=500")
+      .build_for(ReadarrEvent::GetDownloads(500))
+      .await;
+    {
+      let mut app = app.lock().await;
+      app.server_tabs.set_index(3);
+      app
+        .data
+        .readarr_data
+        .downloads
+        .set_items(stale_downloads.clone());
+    }
+    let mut network = test_network(&app);
+
+    let result = network
+      .handle_readarr_event(ReadarrEvent::GetDownloads(500))
+      .await;
+
+    mock.assert_async().await;
+
+    assert_err!(result);
+    assert_eq!(
+      app.lock().await.data.readarr_data.downloads.items,
+      stale_downloads
+    );
+  }
+}

src/network/readarr_network/mod.rs

@@ -10,6 +10,7 @@ use crate::models::readarr_models::{
 use crate::models::servarr_models::{MetadataProfile, QualityProfile, Tag};
 use crate::network::{Network, RequestMethod};
 
+mod downloads;
 mod library;
 mod root_folders;
 mod system;
@@ -41,6 +42,7 @@ pub enum ReadarrEvent {
   GetBookHistory(i64, i64),
   GetBooks(i64),
   GetDiskSpace,
+  GetDownloads(u64),
   GetHostConfig,
   GetLogs(u64),
   GetMetadataProfiles,
@@ -93,6 +95,7 @@ impl NetworkResource for ReadarrEvent {
       ReadarrEvent::GetLogs(_) => "/log",
       ReadarrEvent::GetMetadataProfiles => "/metadataprofile",
       ReadarrEvent::GetQualityProfiles => "/qualityprofile",
+      ReadarrEvent::GetDownloads(_) => "/queue",
       ReadarrEvent::AddRootFolder(_)
       | ReadarrEvent::DeleteRootFolder(_)
       | ReadarrEvent::GetRootFolders => "/rootfolder",
@@ -177,6 +180,10 @@ impl Network<'_, '_> {
         .get_readarr_diskspace()
         .await
         .map(ReadarrSerdeable::from),
+      ReadarrEvent::GetDownloads(count) => self
+        .get_readarr_downloads(count)
+        .await
+        .map(ReadarrSerdeable::from),
       ReadarrEvent::GetHostConfig => self
         .get_readarr_host_config()
         .await

src/network/readarr_network/readarr_network_test_utils.rs

@@ -3,11 +3,12 @@
 pub mod test_utils {
   use crate::models::readarr_models::{
     AddAuthorBody, AddAuthorOptions, AddAuthorSearchResult, Author, AuthorStatus, Book, BookFile,
-    Edition, MonitorType, NewItemMonitorType, ReadarrHistoryData, ReadarrHistoryEventType,
+    DownloadRecord, DownloadStatus, DownloadsResponse, Edition, MonitorType, NewItemMonitorType,
-    ReadarrHistoryItem,
+    ReadarrHistoryData, ReadarrHistoryEventType, ReadarrHistoryItem,
   };
   use crate::models::servarr_models::{Quality, QualityWrapper, RootFolder};
   use chrono::DateTime;
+  use serde_json::Number;
 
   pub const AUTHOR_JSON: &str = r#"{
     "id": 1,
@@ -106,6 +107,19 @@ pub mod test_utils {
     "ratings": { "votes": 15, "value": 8.4, "popularity": 1.2 }
   }"#;
 
+  pub const DOWNLOAD_RECORD_JSON: &str = r#"{
+    "title": "Test Book Download",
+    "status": "downloading",
+    "id": 1,
+    "bookId": 1,
+    "authorId": 1,
+    "size": 1000.0,
+    "sizeleft": 250.0,
+    "outputPath": "/nfs/nzbget/completed/books/Test Author - Test Book",
+    "indexer": "test-indexer",
+    "downloadClient": "NZBGet"
+  }"#;
+
   pub fn stale_author() -> Author {
     Author {
       id: 99,
@@ -184,6 +198,15 @@ pub mod test_utils {
     }
   }
 
+  pub fn stale_download_record() -> DownloadRecord {
+    DownloadRecord {
+      id: 99,
+      title: "Stale Download".to_owned(),
+      status: DownloadStatus::Queued,
+      ..DownloadRecord::default()
+    }
+  }
+
   pub fn quality_wrapper() -> QualityWrapper {
     QualityWrapper { quality: quality() }
   }
@@ -232,4 +255,25 @@ pub mod test_utils {
       },
     }
   }
+
+  pub fn download_record() -> DownloadRecord {
+    DownloadRecord {
+      title: "Test Book Download".to_owned(),
+      status: DownloadStatus::Downloading,
+      id: 1,
+      book_id: Some(Number::from(1)),
+      author_id: Some(Number::from(1)),
+      size: 1000.0,
+      sizeleft: 250.0,
+      output_path: Some("/nfs/nzbget/completed/books/Test Author - Test Book".into()),
+      indexer: "test-indexer".to_owned(),
+      download_client: Some("NZBGet".to_owned()),
+    }
+  }
+
+  pub fn downloads_response() -> DownloadsResponse {
+    DownloadsResponse {
+      records: vec![download_record()],
+    }
+  }
 }

src/network/readarr_network/readarr_network_tests.rs

@@ -44,6 +44,7 @@ mod tests {
   #[case(ReadarrEvent::GetLogs(500), "/log")]
   #[case(ReadarrEvent::GetMetadataProfiles, "/metadataprofile")]
   #[case(ReadarrEvent::GetQualityProfiles, "/qualityprofile")]
+  #[case(ReadarrEvent::GetDownloads(500), "/queue")]
   #[case(
     ReadarrEvent::AddRootFolder(AddReadarrRootFolderBody::default()),
     "/rootfolder"