From 520b422dcce8a391f430a8ec46e90b0eb0115822 Mon Sep 17 00:00:00 2001 From: Alex Clarke Date: Thu, 20 Aug 2026 15:49:56 -0600 Subject: [PATCH] feat(readarr): fetch Readarr disk space and expose it on the CLI Add ReadarrEvent::GetDiskSpace, mapped to GET /diskspace, and get_readarr_diskspace, which stores the result on ReadarrData for the root folder and system views. Surface it as `managarr readarr list disk-space`, matching the other three servarrs. Readarr returns a label field on some records that DiskSpace does not model; serde drops it, so the CLI prints only the path and the free and total space, as it does for the other three servarrs. --- src/cli/readarr/list_command_handler.rs | 62 ++++++++++++++++ src/cli/readarr/list_command_handler_tests.rs | 73 +++++++++++++++++++ src/cli/readarr/mod.rs | 12 +++ src/network/readarr_network/mod.rs | 6 ++ .../readarr_network/readarr_network_tests.rs | 1 + src/network/readarr_network/system/mod.rs | 19 ++++- .../system/readarr_system_network_tests.rs | 71 +++++++++++++++++- 7 files changed, 242 insertions(+), 2 deletions(-) create mode 100644 src/cli/readarr/list_command_handler.rs create mode 100644 src/cli/readarr/list_command_handler_tests.rs diff --git a/src/cli/readarr/list_command_handler.rs b/src/cli/readarr/list_command_handler.rs new file mode 100644 index 00000000..55c2cb76 --- /dev/null +++ b/src/cli/readarr/list_command_handler.rs @@ -0,0 +1,62 @@ +use std::sync::Arc; + +use anyhow::Result; +use clap::Subcommand; +use tokio::sync::Mutex; + +use super::ReadarrCommand; +use crate::{ + app::App, + cli::{CliCommandHandler, Command}, + network::{NetworkTrait, readarr_network::ReadarrEvent}, +}; + +#[cfg(test)] +#[path = "list_command_handler_tests.rs"] +mod list_command_handler_tests; + +#[derive(Debug, Clone, PartialEq, Eq, Subcommand)] +pub enum ReadarrListCommand { + #[command(about = "List disk space details for all provisioned root folders in Readarr")] + DiskSpace, +} + +impl From for Command { + fn from(value: ReadarrListCommand) -> Self { + Command::Readarr(ReadarrCommand::List(value)) + } +} + +pub(super) struct ReadarrListCommandHandler<'a, 'b> { + _app: &'a Arc>>, + command: ReadarrListCommand, + network: &'a mut dyn NetworkTrait, +} + +impl<'a, 'b> CliCommandHandler<'a, 'b, ReadarrListCommand> for ReadarrListCommandHandler<'a, 'b> { + fn with( + _app: &'a Arc>>, + command: ReadarrListCommand, + network: &'a mut dyn NetworkTrait, + ) -> Self { + ReadarrListCommandHandler { + _app, + command, + network, + } + } + + async fn handle(self) -> Result { + let result = match self.command { + ReadarrListCommand::DiskSpace => { + let resp = self + .network + .handle_network_event(ReadarrEvent::GetDiskSpace.into()) + .await?; + serde_json::to_string_pretty(&resp)? + } + }; + + Ok(result) + } +} diff --git a/src/cli/readarr/list_command_handler_tests.rs b/src/cli/readarr/list_command_handler_tests.rs new file mode 100644 index 00000000..85568cad --- /dev/null +++ b/src/cli/readarr/list_command_handler_tests.rs @@ -0,0 +1,73 @@ +#[cfg(test)] +mod tests { + use crate::Cli; + use crate::cli::{ + Command, + readarr::{ReadarrCommand, list_command_handler::ReadarrListCommand}, + }; + use clap::CommandFactory; + use pretty_assertions::assert_eq; + + #[test] + fn test_readarr_list_command_from() { + let command = ReadarrListCommand::DiskSpace; + + let result = Command::from(command.clone()); + + assert_eq!(result, Command::Readarr(ReadarrCommand::List(command))); + } + + mod cli { + use rstest::rstest; + + use super::*; + + #[rstest] + fn test_list_commands_have_no_arg_requirements(#[values("disk-space")] subcommand: &str) { + let result = Cli::command().try_get_matches_from(["managarr", "readarr", "list", subcommand]); + + assert_ok!(&result); + } + } + + mod handler { + use std::sync::Arc; + + use mockall::predicate::eq; + use serde_json::json; + use tokio::sync::Mutex; + + use crate::{ + app::App, + cli::{ + CliCommandHandler, + readarr::list_command_handler::{ReadarrListCommand, ReadarrListCommandHandler}, + }, + models::{Serdeable, readarr_models::ReadarrSerdeable}, + network::{MockNetworkTrait, NetworkEvent, readarr_network::ReadarrEvent}, + }; + + #[tokio::test] + async fn test_handle_list_disk_space_command() { + let mut mock_network = MockNetworkTrait::new(); + mock_network + .expect_handle_network_event() + .with(eq::(ReadarrEvent::GetDiskSpace.into())) + .times(1) + .returning(|_| { + Ok(Serdeable::Readarr(ReadarrSerdeable::Value( + json!({"testResponse": "response"}), + ))) + }); + let app_arc = Arc::new(Mutex::new(App::test_default())); + let list_disk_space_command = ReadarrListCommand::DiskSpace; + + let result = + ReadarrListCommandHandler::with(&app_arc, list_disk_space_command, &mut mock_network) + .handle() + .await; + + assert_ok!(&result); + } + } +} diff --git a/src/cli/readarr/mod.rs b/src/cli/readarr/mod.rs index 1bd27875..1b8ac8f5 100644 --- a/src/cli/readarr/mod.rs +++ b/src/cli/readarr/mod.rs @@ -3,12 +3,14 @@ use std::sync::Arc; use anyhow::Result; use clap::Subcommand; use get_command_handler::{ReadarrGetCommand, ReadarrGetCommandHandler}; +use list_command_handler::{ReadarrListCommand, ReadarrListCommandHandler}; use tokio::sync::Mutex; use super::{CliCommandHandler, Command}; use crate::{app::App, network::NetworkTrait}; mod get_command_handler; +mod list_command_handler; #[cfg(test)] #[path = "readarr_command_tests.rs"] @@ -21,6 +23,11 @@ pub enum ReadarrCommand { about = "Commands to fetch details of the resources in your Readarr instance" )] Get(ReadarrGetCommand), + #[command( + subcommand, + about = "Commands to list attributes from your Readarr instance" + )] + List(ReadarrListCommand), } impl From for Command { @@ -55,6 +62,11 @@ impl<'a, 'b> CliCommandHandler<'a, 'b, ReadarrCommand> for ReadarrCliHandler<'a, .handle() .await? } + ReadarrCommand::List(list_command) => { + ReadarrListCommandHandler::with(self.app, list_command, self.network) + .handle() + .await? + } }; Ok(result) diff --git a/src/network/readarr_network/mod.rs b/src/network/readarr_network/mod.rs index 7be4c816..17e3a1c0 100644 --- a/src/network/readarr_network/mod.rs +++ b/src/network/readarr_network/mod.rs @@ -13,6 +13,7 @@ mod readarr_network_tests; #[derive(Debug, Eq, PartialEq, Clone)] pub enum ReadarrEvent { + GetDiskSpace, GetStatus, HealthCheck, } @@ -20,6 +21,7 @@ pub enum ReadarrEvent { impl NetworkResource for ReadarrEvent { fn resource(&self) -> &'static str { match &self { + ReadarrEvent::GetDiskSpace => "/diskspace", ReadarrEvent::HealthCheck => "/health", ReadarrEvent::GetStatus => "/system/status", } @@ -38,6 +40,10 @@ impl Network<'_, '_> { readarr_event: ReadarrEvent, ) -> Result { match readarr_event { + ReadarrEvent::GetDiskSpace => self + .get_readarr_diskspace() + .await + .map(ReadarrSerdeable::from), ReadarrEvent::GetStatus => self.get_readarr_status().await.map(ReadarrSerdeable::from), ReadarrEvent::HealthCheck => self .get_readarr_healthcheck() diff --git a/src/network/readarr_network/readarr_network_tests.rs b/src/network/readarr_network/readarr_network_tests.rs index f20aa015..a8703242 100644 --- a/src/network/readarr_network/readarr_network_tests.rs +++ b/src/network/readarr_network/readarr_network_tests.rs @@ -6,6 +6,7 @@ mod tests { use rstest::rstest; #[rstest] + #[case(ReadarrEvent::GetDiskSpace, "/diskspace")] #[case(ReadarrEvent::HealthCheck, "/health")] #[case(ReadarrEvent::GetStatus, "/system/status")] fn test_resource(#[case] event: ReadarrEvent, #[case] expected_uri: &str) { diff --git a/src/network/readarr_network/system/mod.rs b/src/network/readarr_network/system/mod.rs index 1ac5a65b..4660f761 100644 --- a/src/network/readarr_network/system/mod.rs +++ b/src/network/readarr_network/system/mod.rs @@ -1,4 +1,4 @@ -use crate::models::servarr_models::SystemStatus; +use crate::models::servarr_models::{DiskSpace, SystemStatus}; use crate::network::readarr_network::ReadarrEvent; use crate::network::{Network, RequestMethod}; use anyhow::Result; @@ -9,6 +9,23 @@ use log::info; mod readarr_system_network_tests; impl Network<'_, '_> { + pub(in crate::network::readarr_network) async fn get_readarr_diskspace( + &mut self, + ) -> Result> { + info!("Fetching Readarr disk space"); + let event = ReadarrEvent::GetDiskSpace; + + let request_props = self + .request_props_from(event, RequestMethod::Get, None::<()>, None, None) + .await; + + self + .handle_request::<(), Vec>(request_props, |disk_space_vec, mut app| { + app.data.readarr_data.disk_space_vec = disk_space_vec; + }) + .await + } + pub(in crate::network::readarr_network) async fn get_readarr_status( &mut self, ) -> Result { diff --git a/src/network/readarr_network/system/readarr_system_network_tests.rs b/src/network/readarr_network/system/readarr_system_network_tests.rs index dc9de9c6..50de66d9 100644 --- a/src/network/readarr_network/system/readarr_system_network_tests.rs +++ b/src/network/readarr_network/system/readarr_system_network_tests.rs @@ -1,13 +1,82 @@ #[cfg(test)] mod tests { use crate::models::readarr_models::ReadarrSerdeable; - use crate::models::servarr_models::SystemStatus; + use crate::models::servarr_models::{DiskSpace, SystemStatus}; use crate::network::network_tests::test_utils::{MockServarrApi, test_network}; use crate::network::readarr_network::ReadarrEvent; use chrono::DateTime; use pretty_assertions::{assert_eq, assert_str_eq}; use serde_json::json; + #[tokio::test] + async fn test_handle_get_readarr_diskspace_event() { + let (mock, app, _server) = MockServarrApi::get() + .returns(json!([ + { + "path": "/nfs/books/", + "freeSpace": 11039526748160i64, + "totalSpace": 117810875334656i64 + }, + { + "path": "/config", + "label": "", + "freeSpace": 783978655744i64, + "totalSpace": 1004298338304i64 + } + ])) + .build_for(ReadarrEvent::GetDiskSpace) + .await; + app.lock().await.server_tabs.set_index(3); + let mut network = test_network(&app); + let disk_space_vec = vec![ + DiskSpace { + path: Some("/nfs/books/".to_owned()), + free_space: 11039526748160, + total_space: 117810875334656, + }, + DiskSpace { + path: Some("/config".to_owned()), + free_space: 783978655744, + total_space: 1004298338304, + }, + ]; + + let result = network + .handle_readarr_event(ReadarrEvent::GetDiskSpace) + .await; + + mock.assert_async().await; + + let ReadarrSerdeable::DiskSpaces(disk_spaces) = result.unwrap() else { + panic!("Expected DiskSpaces") + }; + + assert_eq!(disk_spaces, disk_space_vec); + assert_eq!( + app.lock().await.data.readarr_data.disk_space_vec, + disk_space_vec + ); + } + + #[tokio::test] + async fn test_handle_get_readarr_diskspace_event_failure() { + let (mock, app, _server) = MockServarrApi::get() + .returns(json!({})) + .status(500) + .build_for(ReadarrEvent::GetDiskSpace) + .await; + app.lock().await.server_tabs.set_index(3); + let mut network = test_network(&app); + + let result = network + .handle_readarr_event(ReadarrEvent::GetDiskSpace) + .await; + + mock.assert_async().await; + assert_err!(result); + assert_is_empty!(app.lock().await.data.readarr_data.disk_space_vec); + } + #[tokio::test] async fn test_handle_get_readarr_status_event() { let (mock, app, _server) = MockServarrApi::get()