feat(readarr): add authors to Readarr and expose the command on the CLI

This commit is contained in:
Dark-Alex-17 committed 2026-08-26 17:17:41 -06:00
1 parent 9238c1b9d2
commit e514e9b6cc
8 files changed
+644 -9

No files matched your search

+93 -1
View File
@@ -8,7 +8,9 @@ use super::ReadarrCommand;
use crate::{
app::App,
cli::{CliCommandHandler, Command},
models::readarr_models::{AddReadarrRootFolderBody, MonitorType, NewItemMonitorType},
models::readarr_models::{
AddAuthorBody, AddAuthorOptions, AddReadarrRootFolderBody, MonitorType, NewItemMonitorType,
},
network::{NetworkTrait, readarr_network::ReadarrEvent},
};
@@ -18,6 +20,63 @@ mod add_command_handler_tests;
#[derive(Debug, Clone, PartialEq, Eq, Subcommand)]
pub enum ReadarrAddCommand {
#[command(about = "Add a new author to your Readarr library")]
Author {
#[arg(
long,
help = "The Goodreads foreign author ID of the author you wish to add to your library",
required = true
)]
foreign_author_id: String,
#[arg(long, help = "The name of the author", required = true)]
author_name: String,
#[arg(
long,
help = "The root folder path where all author data and metadata should live",
required = true
)]
root_folder_path: String,
#[arg(
long,
help = "The ID of the quality profile to use for this author",
required = true
)]
quality_profile_id: i64,
#[arg(
long,
help = "The ID of the metadata profile to use for this author",
required = true
)]
metadata_profile_id: i64,
#[arg(long, help = "Disable monitoring for this author")]
disable_monitoring: bool,
#[arg(
long,
help = "Tag IDs to tag the author with",
value_parser,
action = ArgAction::Append
)]
tag: Vec<i64>,
#[arg(
long,
help = "What Readarr should monitor for this author",
value_enum,
default_value_t = MonitorType::default()
)]
monitor: MonitorType,
#[arg(
long,
help = "How Readarr should monitor new items for this author",
value_enum,
default_value_t = NewItemMonitorType::default()
)]
monitor_new_items: NewItemMonitorType,
#[arg(
long,
help = "Tell Readarr to not start a search for missing books once the author is added to your library"
)]
no_search_for_missing_books: bool,
},
#[command(about = "Add a new root folder")]
RootFolder {
#[arg(long, help = "The name of the root folder", required = true)]
@@ -92,6 +151,39 @@ impl<'a, 'b> CliCommandHandler<'a, 'b, ReadarrAddCommand> for ReadarrAddCommandH
async fn handle(self) -> Result<String> {
let result = match self.command {
ReadarrAddCommand::Author {
foreign_author_id,
author_name,
root_folder_path,
quality_profile_id,
metadata_profile_id,
disable_monitoring,
tag: tags,
monitor,
monitor_new_items,
no_search_for_missing_books,
} => {
let body = AddAuthorBody {
foreign_author_id,
author_name,
monitored: !disable_monitoring,
root_folder_path,
quality_profile_id,
metadata_profile_id,
tags,
tag_input_string: None,
add_options: AddAuthorOptions {
monitor,
monitor_new_items,
search_for_missing_books: !no_search_for_missing_books,
},
};
let resp = self
.network
.handle_network_event(ReadarrEvent::AddAuthor(body).into())
.await?;
serde_json::to_string_pretty(&resp)?
}
ReadarrAddCommand::RootFolder {
name,
root_folder_path,
+367 -1
View File
@@ -27,6 +27,321 @@ mod tests {
use super::*;
use pretty_assertions::assert_eq;
#[test]
fn test_add_author_requires_arguments() {
let result = Cli::command().try_get_matches_from(["managarr", "readarr", "add", "author"]);
assert_err!(&result);
assert_eq!(
result.unwrap_err().kind(),
ErrorKind::MissingRequiredArgument
);
}
#[test]
fn test_add_author_requires_foreign_author_id() {
let result = Cli::command().try_get_matches_from([
"managarr",
"readarr",
"add",
"author",
"--author-name",
"Test",
"--root-folder-path",
"/nfs/books",
"--quality-profile-id",
"1",
"--metadata-profile-id",
"1",
]);
assert_err!(&result);
assert_eq!(
result.unwrap_err().kind(),
ErrorKind::MissingRequiredArgument
);
}
#[test]
fn test_add_author_requires_author_name() {
let result = Cli::command().try_get_matches_from([
"managarr",
"readarr",
"add",
"author",
"--foreign-author-id",
"test-id",
"--root-folder-path",
"/nfs/books",
"--quality-profile-id",
"1",
"--metadata-profile-id",
"1",
]);
assert_err!(&result);
assert_eq!(
result.unwrap_err().kind(),
ErrorKind::MissingRequiredArgument
);
}
#[test]
fn test_add_author_requires_root_folder_path() {
let result = Cli::command().try_get_matches_from([
"managarr",
"readarr",
"add",
"author",
"--foreign-author-id",
"test-id",
"--author-name",
"Test",
"--quality-profile-id",
"1",
"--metadata-profile-id",
"1",
]);
assert_err!(&result);
assert_eq!(
result.unwrap_err().kind(),
ErrorKind::MissingRequiredArgument
);
}
#[test]
fn test_add_author_requires_quality_profile_id() {
let result = Cli::command().try_get_matches_from([
"managarr",
"readarr",
"add",
"author",
"--foreign-author-id",
"test-id",
"--author-name",
"Test",
"--root-folder-path",
"/nfs/books",
"--metadata-profile-id",
"1",
]);
assert_err!(&result);
assert_eq!(
result.unwrap_err().kind(),
ErrorKind::MissingRequiredArgument
);
}
#[test]
fn test_add_author_requires_metadata_profile_id() {
let result = Cli::command().try_get_matches_from([
"managarr",
"readarr",
"add",
"author",
"--foreign-author-id",
"test-id",
"--author-name",
"Test",
"--root-folder-path",
"/nfs/books",
"--quality-profile-id",
"1",
]);
assert_err!(&result);
assert_eq!(
result.unwrap_err().kind(),
ErrorKind::MissingRequiredArgument
);
}
#[test]
fn test_add_author_success_with_required_args_only() {
let expected_args = ReadarrAddCommand::Author {
foreign_author_id: "test-id".to_owned(),
author_name: "Test Author".to_owned(),
root_folder_path: "/nfs/books".to_owned(),
quality_profile_id: 1,
metadata_profile_id: 1,
disable_monitoring: false,
tag: vec![],
monitor: MonitorType::default(),
monitor_new_items: NewItemMonitorType::default(),
no_search_for_missing_books: false,
};
let result = Cli::try_parse_from([
"managarr",
"readarr",
"add",
"author",
"--foreign-author-id",
"test-id",
"--author-name",
"Test Author",
"--root-folder-path",
"/nfs/books",
"--quality-profile-id",
"1",
"--metadata-profile-id",
"1",
]);
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);
}
#[test]
fn test_add_author_success_with_all_args() {
let expected_args = ReadarrAddCommand::Author {
foreign_author_id: "test-id".to_owned(),
author_name: "Test Author".to_owned(),
root_folder_path: "/nfs/books".to_owned(),
quality_profile_id: 1,
metadata_profile_id: 2,
disable_monitoring: true,
tag: vec![1, 2],
monitor: MonitorType::Future,
monitor_new_items: NewItemMonitorType::New,
no_search_for_missing_books: true,
};
let result = Cli::try_parse_from([
"managarr",
"readarr",
"add",
"author",
"--foreign-author-id",
"test-id",
"--author-name",
"Test Author",
"--root-folder-path",
"/nfs/books",
"--quality-profile-id",
"1",
"--metadata-profile-id",
"2",
"--disable-monitoring",
"--tag",
"1",
"--tag",
"2",
"--monitor",
"future",
"--monitor-new-items",
"new",
"--no-search-for-missing-books",
]);
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);
}
#[test]
fn test_add_author_monitor_type_validation() {
let result = Cli::command().try_get_matches_from([
"managarr",
"readarr",
"add",
"author",
"--foreign-author-id",
"test-id",
"--author-name",
"Test Author",
"--root-folder-path",
"/nfs/books",
"--quality-profile-id",
"1",
"--metadata-profile-id",
"2",
"--monitor",
"test",
]);
assert_err!(&result);
assert_eq!(result.unwrap_err().kind(), ErrorKind::InvalidValue);
}
#[test]
fn test_add_author_new_item_monitor_type_validation() {
let result = Cli::command().try_get_matches_from([
"managarr",
"readarr",
"add",
"author",
"--foreign-author-id",
"test-id",
"--author-name",
"Test Author",
"--root-folder-path",
"/nfs/books",
"--quality-profile-id",
"1",
"--metadata-profile-id",
"2",
"--monitor-new-items",
"test",
]);
assert_err!(&result);
assert_eq!(result.unwrap_err().kind(), ErrorKind::InvalidValue);
}
#[test]
fn test_add_author_tags_is_repeatable() {
let expected_args = ReadarrAddCommand::Author {
foreign_author_id: "test-id".to_owned(),
author_name: "Test Author".to_owned(),
root_folder_path: "/nfs/books".to_owned(),
quality_profile_id: 1,
metadata_profile_id: 2,
disable_monitoring: false,
tag: vec![1, 2],
monitor: MonitorType::default(),
monitor_new_items: NewItemMonitorType::default(),
no_search_for_missing_books: false,
};
let result = Cli::try_parse_from([
"managarr",
"readarr",
"add",
"author",
"--foreign-author-id",
"test-id",
"--author-name",
"Test Author",
"--root-folder-path",
"/nfs/books",
"--quality-profile-id",
"1",
"--metadata-profile-id",
"2",
"--tag",
"1",
"--tag",
"2",
]);
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);
}
#[test]
fn test_add_root_folder_requires_arguments() {
let result =
@@ -113,7 +428,8 @@ mod tests {
use crate::cli::readarr::add_command_handler::{ReadarrAddCommand, ReadarrAddCommandHandler};
use crate::models::Serdeable;
use crate::models::readarr_models::{
AddReadarrRootFolderBody, MonitorType, NewItemMonitorType, ReadarrSerdeable,
AddAuthorBody, AddAuthorOptions, AddReadarrRootFolderBody, MonitorType, NewItemMonitorType,
ReadarrSerdeable,
};
use crate::network::readarr_network::ReadarrEvent;
use crate::{
@@ -121,6 +437,56 @@ mod tests {
network::{MockNetworkTrait, NetworkEvent},
};
#[tokio::test]
async fn test_handle_add_author_command() {
let expected_body = AddAuthorBody {
foreign_author_id: "test-id".to_owned(),
author_name: "Test Author".to_owned(),
monitored: false,
root_folder_path: "/nfs/books".to_owned(),
quality_profile_id: 1,
metadata_profile_id: 1,
tags: vec![1, 2],
tag_input_string: None,
add_options: AddAuthorOptions {
monitor: MonitorType::All,
monitor_new_items: NewItemMonitorType::All,
search_for_missing_books: false,
},
};
let mut mock_network = MockNetworkTrait::new();
mock_network
.expect_handle_network_event()
.with(eq::<NetworkEvent>(
ReadarrEvent::AddAuthor(expected_body).into(),
))
.times(1)
.returning(|_| {
Ok(Serdeable::Readarr(ReadarrSerdeable::Value(
json!({"testResponse": "response"}),
)))
});
let app_arc = Arc::new(Mutex::new(App::test_default()));
let add_author_command = ReadarrAddCommand::Author {
foreign_author_id: "test-id".to_owned(),
author_name: "Test Author".to_owned(),
root_folder_path: "/nfs/books".to_owned(),
quality_profile_id: 1,
metadata_profile_id: 1,
disable_monitoring: true,
tag: vec![1, 2],
monitor: MonitorType::All,
monitor_new_items: NewItemMonitorType::All,
no_search_for_missing_books: true,
};
let result = ReadarrAddCommandHandler::with(&app_arc, add_author_command, &mut mock_network)
.handle()
.await;
assert_ok!(&result);
}
#[tokio::test]
async fn test_handle_add_root_folder_command() {
let expected_root_folder_path = "/nfs/test".to_owned();