From b9fa3b36c012cb1e7bb896f698f3604ac84eb526 Mon Sep 17 00:00:00 2001 From: Alex Clarke Date: Thu, 20 Aug 2026 22:47:41 -0600 Subject: [PATCH] feat(readarr): add Readarr tags and expose the command on the CLI --- src/cli/readarr/add_command_handler.rs | 65 +++++++++++ src/cli/readarr/add_command_handler_tests.rs | 101 ++++++++++++++++++ src/cli/readarr/mod.rs | 12 +++ src/network/readarr_network/mod.rs | 26 ++++- .../readarr_network/readarr_network_tests.rs | 65 +++++++++++ 5 files changed, 268 insertions(+), 1 deletion(-) create mode 100644 src/cli/readarr/add_command_handler.rs create mode 100644 src/cli/readarr/add_command_handler_tests.rs diff --git a/src/cli/readarr/add_command_handler.rs b/src/cli/readarr/add_command_handler.rs new file mode 100644 index 00000000..025cf6d6 --- /dev/null +++ b/src/cli/readarr/add_command_handler.rs @@ -0,0 +1,65 @@ +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 = "add_command_handler_tests.rs"] +mod add_command_handler_tests; + +#[derive(Debug, Clone, PartialEq, Eq, Subcommand)] +pub enum ReadarrAddCommand { + #[command(about = "Add new tag")] + Tag { + #[arg(long, help = "The name of the tag to be added", required = true)] + name: String, + }, +} + +impl From for Command { + fn from(value: ReadarrAddCommand) -> Self { + Command::Readarr(ReadarrCommand::Add(value)) + } +} + +pub(super) struct ReadarrAddCommandHandler<'a, 'b> { + _app: &'a Arc>>, + command: ReadarrAddCommand, + network: &'a mut dyn NetworkTrait, +} + +impl<'a, 'b> CliCommandHandler<'a, 'b, ReadarrAddCommand> for ReadarrAddCommandHandler<'a, 'b> { + fn with( + app: &'a Arc>>, + command: ReadarrAddCommand, + network: &'a mut dyn NetworkTrait, + ) -> Self { + ReadarrAddCommandHandler { + _app: app, + command, + network, + } + } + + async fn handle(self) -> Result { + let result = match self.command { + ReadarrAddCommand::Tag { name } => { + let resp = self + .network + .handle_network_event(ReadarrEvent::AddTag(name).into()) + .await?; + serde_json::to_string_pretty(&resp)? + } + }; + + Ok(result) + } +} diff --git a/src/cli/readarr/add_command_handler_tests.rs b/src/cli/readarr/add_command_handler_tests.rs new file mode 100644 index 00000000..21ac0c34 --- /dev/null +++ b/src/cli/readarr/add_command_handler_tests.rs @@ -0,0 +1,101 @@ +#[cfg(test)] +mod tests { + use clap::{CommandFactory, Parser, error::ErrorKind}; + + use crate::{ + Cli, + cli::{ + Command, + readarr::{ReadarrCommand, add_command_handler::ReadarrAddCommand}, + }, + }; + use pretty_assertions::assert_eq; + + #[test] + fn test_readarr_add_command_from() { + let command = ReadarrAddCommand::Tag { + name: String::new(), + }; + + let result = Command::from(command.clone()); + + assert_eq!(result, Command::Readarr(ReadarrCommand::Add(command))); + } + + mod cli { + use super::*; + use pretty_assertions::assert_eq; + + #[test] + fn test_add_tag_requires_arguments() { + let result = Cli::command().try_get_matches_from(["managarr", "readarr", "add", "tag"]); + + assert_err!(&result); + assert_eq!( + result.unwrap_err().kind(), + ErrorKind::MissingRequiredArgument + ); + } + + #[test] + fn test_add_tag_success() { + let expected_args = ReadarrAddCommand::Tag { + name: "test".to_owned(), + }; + + let result = Cli::try_parse_from(["managarr", "readarr", "add", "tag", "--name", "test"]); + + assert_ok!(&result); + + let Some(Command::Readarr(ReadarrCommand::Add(add_command))) = result.unwrap().command else { + panic!("Unexpected command type"); + }; + assert_eq!(add_command, expected_args); + } + } + + mod handler { + use std::sync::Arc; + + use mockall::predicate::eq; + use serde_json::json; + use tokio::sync::Mutex; + + use crate::cli::CliCommandHandler; + use crate::cli::readarr::add_command_handler::{ReadarrAddCommand, ReadarrAddCommandHandler}; + use crate::models::Serdeable; + use crate::models::readarr_models::ReadarrSerdeable; + use crate::network::readarr_network::ReadarrEvent; + use crate::{ + app::App, + network::{MockNetworkTrait, NetworkEvent}, + }; + + #[tokio::test] + async fn test_handle_add_tag_command() { + let expected_tag_name = "test".to_owned(); + let mut mock_network = MockNetworkTrait::new(); + mock_network + .expect_handle_network_event() + .with(eq::( + ReadarrEvent::AddTag(expected_tag_name.clone()).into(), + )) + .times(1) + .returning(|_| { + Ok(Serdeable::Readarr(ReadarrSerdeable::Value( + json!({"testResponse": "response"}), + ))) + }); + let app_arc = Arc::new(Mutex::new(App::test_default())); + let add_tag_command = ReadarrAddCommand::Tag { + name: expected_tag_name, + }; + + let result = ReadarrAddCommandHandler::with(&app_arc, add_tag_command, &mut mock_network) + .handle() + .await; + + assert_ok!(&result); + } + } +} diff --git a/src/cli/readarr/mod.rs b/src/cli/readarr/mod.rs index 0fdafc66..e6f421a1 100644 --- a/src/cli/readarr/mod.rs +++ b/src/cli/readarr/mod.rs @@ -1,5 +1,6 @@ use std::sync::Arc; +use add_command_handler::{ReadarrAddCommand, ReadarrAddCommandHandler}; use anyhow::Result; use clap::Subcommand; use get_command_handler::{ReadarrGetCommand, ReadarrGetCommandHandler}; @@ -11,6 +12,7 @@ use crate::models::readarr_models::ReadarrTaskName; use crate::network::readarr_network::ReadarrEvent; use crate::{app::App, network::NetworkTrait}; +mod add_command_handler; mod get_command_handler; mod list_command_handler; @@ -20,6 +22,11 @@ mod readarr_command_tests; #[derive(Debug, Clone, PartialEq, Eq, Subcommand)] pub enum ReadarrCommand { + #[command( + subcommand, + about = "Commands to add or create new resources within your Readarr instance" + )] + Add(ReadarrAddCommand), #[command( subcommand, about = "Commands to fetch details of the resources in your Readarr instance" @@ -69,6 +76,11 @@ impl<'a, 'b> CliCommandHandler<'a, 'b, ReadarrCommand> for ReadarrCliHandler<'a, async fn handle(self) -> Result { let result = match self.command { + ReadarrCommand::Add(add_command) => { + ReadarrAddCommandHandler::with(self.app, add_command, self.network) + .handle() + .await? + } ReadarrCommand::Get(get_command) => { ReadarrGetCommandHandler::with(self.app, get_command, self.network) .handle() diff --git a/src/network/readarr_network/mod.rs b/src/network/readarr_network/mod.rs index d895d059..7846c42b 100644 --- a/src/network/readarr_network/mod.rs +++ b/src/network/readarr_network/mod.rs @@ -1,5 +1,6 @@ use anyhow::Result; use log::info; +use serde_json::{Value, json}; use super::{NetworkEvent, NetworkResource}; use crate::models::readarr_models::{ReadarrSerdeable, ReadarrTaskName}; @@ -15,6 +16,7 @@ mod readarr_network_tests; #[derive(Debug, Eq, PartialEq, Clone)] pub enum ReadarrEvent { + AddTag(String), GetDiskSpace, GetHostConfig, GetLogs(u64), @@ -44,7 +46,7 @@ impl NetworkResource for ReadarrEvent { ReadarrEvent::GetRootFolders => "/rootfolder", ReadarrEvent::GetStatus => "/system/status", ReadarrEvent::GetTasks => "/system/task", - ReadarrEvent::GetTags => "/tag", + ReadarrEvent::AddTag(_) | ReadarrEvent::GetTags => "/tag", ReadarrEvent::GetUpdates => "/update", } } @@ -62,6 +64,7 @@ impl Network<'_, '_> { readarr_event: ReadarrEvent, ) -> Result { match readarr_event { + ReadarrEvent::AddTag(tag) => self.add_readarr_tag(tag).await.map(ReadarrSerdeable::from), ReadarrEvent::GetDiskSpace => self .get_readarr_diskspace() .await @@ -177,4 +180,25 @@ impl Network<'_, '_> { }) .await } + + async fn add_readarr_tag(&mut self, tag: String) -> Result { + info!("Adding a new Readarr tag"); + let event = ReadarrEvent::AddTag(String::new()); + + let request_props = self + .request_props_from( + event, + RequestMethod::Post, + Some(json!({ "label": tag })), + None, + None, + ) + .await; + + self + .handle_request::(request_props, |tag, mut app| { + app.data.readarr_data.tags_map.insert(tag.id, tag.label); + }) + .await + } } diff --git a/src/network/readarr_network/readarr_network_tests.rs b/src/network/readarr_network/readarr_network_tests.rs index 427f01a1..d224694d 100644 --- a/src/network/readarr_network/readarr_network_tests.rs +++ b/src/network/readarr_network/readarr_network_tests.rs @@ -22,6 +22,7 @@ mod tests { #[case(ReadarrEvent::GetRootFolders, "/rootfolder")] #[case(ReadarrEvent::GetStatus, "/system/status")] #[case(ReadarrEvent::GetTasks, "/system/task")] + #[case(ReadarrEvent::AddTag(String::new()), "/tag")] #[case(ReadarrEvent::GetTags, "/tag")] #[case(ReadarrEvent::GetUpdates, "/update")] fn test_resource(#[case] event: ReadarrEvent, #[case] expected_uri: &str) { @@ -345,4 +346,68 @@ mod tests { assert_err!(result); assert_eq!(app.lock().await.data.readarr_data.tags_map, seeded_map); } + + #[tokio::test] + async fn test_handle_add_readarr_tag_event() { + let tag_json = json!({ + "id": 2, + "label": "managarr-verify" + }); + let response: Tag = serde_json::from_value(tag_json.clone()).unwrap(); + let (mock, app, _server) = MockServarrApi::post() + .with_request_body(json!({ "label": "managarr-verify" })) + .returns(tag_json) + .build_for(ReadarrEvent::AddTag("managarr-verify".to_owned())) + .await; + { + let mut app = app.lock().await; + app.server_tabs.set_index(3); + app.data.readarr_data.tags_map = BiMap::from_iter([(1i64, "huntarr-missing".to_owned())]); + } + let mut network = test_network(&app); + + let result = network + .handle_readarr_event(ReadarrEvent::AddTag("managarr-verify".to_owned())) + .await; + + mock.assert_async().await; + + let ReadarrSerdeable::Tag(tag) = result.unwrap() else { + panic!("Expected Tag"); + }; + + assert_eq!(tag, response); + assert_eq!( + app.lock().await.data.readarr_data.tags_map, + BiMap::from_iter([ + (1i64, "huntarr-missing".to_owned()), + (2i64, "managarr-verify".to_owned()) + ]) + ); + } + + #[tokio::test] + async fn test_handle_add_readarr_tag_event_failure() { + let seeded_map = BiMap::from_iter([(1i64, "huntarr-missing".to_owned())]); + let (mock, app, _server) = MockServarrApi::post() + .with_request_body(json!({ "label": "managarr-verify" })) + .returns(json!({})) + .status(500) + .build_for(ReadarrEvent::AddTag("managarr-verify".to_owned())) + .await; + { + let mut app = app.lock().await; + app.server_tabs.set_index(3); + app.data.readarr_data.tags_map = seeded_map.clone(); + } + let mut network = test_network(&app); + + let result = network + .handle_readarr_event(ReadarrEvent::AddTag("managarr-verify".to_owned())) + .await; + + mock.assert_async().await; + assert_err!(result); + assert_eq!(app.lock().await.data.readarr_data.tags_map, seeded_map); + } }