Dark-Alex-17/managarr
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Implemented full system browsing support with logs, events, and tasks.

Browse Source
This commit is contained in:
Dark-Alex-17
2023-08-08 10:50:06 -06:00
parent 460efb2497
commit b2e475200c
25 changed files with 1209 additions and 233 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/handlers/radarr_handlers/mod.rs
+35 -1
View File
@@ -3,7 +3,7 @@ use crate::app::radarr::{
ActiveRadarrBlock, ADD_MOVIE_BLOCKS, COLLECTION_DETAILS_BLOCKS, DELETE_MOVIE_BLOCKS,
DELETE_MOVIE_SELECTION_BLOCKS, EDIT_COLLECTION_BLOCKS, EDIT_COLLECTION_SELECTION_BLOCKS,
EDIT_MOVIE_BLOCKS, EDIT_MOVIE_SELECTION_BLOCKS, FILTER_BLOCKS, MOVIE_DETAILS_BLOCKS,
SEARCH_BLOCKS,
SEARCH_BLOCKS, SYSTEM_DETAILS_BLOCKS,
};
use crate::handlers::radarr_handlers::add_movie_handler::AddMovieHandler;
use crate::handlers::radarr_handlers::collection_details_handler::CollectionDetailsHandler;
@@ -11,6 +11,7 @@ use crate::handlers::radarr_handlers::delete_movie_handler::DeleteMovieHandler;
use crate::handlers::radarr_handlers::edit_collection_handler::EditCollectionHandler;
use crate::handlers::radarr_handlers::edit_movie_handler::EditMovieHandler;
use crate::handlers::radarr_handlers::movie_details_handler::MovieDetailsHandler;
use crate::handlers::radarr_handlers::system_details_handler::SystemDetailsHandler;
use crate::handlers::{handle_clear_errors, handle_prompt_toggle, KeyEventHandler};
use crate::models::{BlockSelectionState, HorizontallyScrollableText, Scrollable};
use crate::network::radarr_network::RadarrEvent;
@@ -23,6 +24,7 @@ mod delete_movie_handler;
mod edit_collection_handler;
mod edit_movie_handler;
mod movie_details_handler;
mod system_details_handler;
#[cfg(test)]
#[path = "radarr_handler_tests.rs"]
@@ -64,6 +66,10 @@ impl<'a, 'b> KeyEventHandler<'a, 'b, ActiveRadarrBlock> for RadarrHandler<'a, 'b
EditCollectionHandler::with(self.key, self.app, self.active_radarr_block, self.context)
.handle()
}
_ if SYSTEM_DETAILS_BLOCKS.contains(self.active_radarr_block) => {
SystemDetailsHandler::with(self.key, self.app, self.active_radarr_block, self.context)
.handle();
}
_ => self.handle_key_event(),
}
}
@@ -564,6 +570,34 @@ impl<'a, 'b> KeyEventHandler<'a, 'b, ActiveRadarrBlock> for RadarrHandler<'a, 'b
}
_ => (),
},
ActiveRadarrBlock::System => match self.key {
_ if *key == DEFAULT_KEYBINDINGS.refresh.key => {
self.app.should_refresh = true;
}
_ if *key == DEFAULT_KEYBINDINGS.update.key => {
self
.app
.push_navigation_stack(ActiveRadarrBlock::SystemQueue.into());
}
_ if *key == DEFAULT_KEYBINDINGS.logs.key => {
self
.app
.push_navigation_stack(ActiveRadarrBlock::SystemLogs.into());
self
.app
.data
.radarr_data
.log_details
.set_items(self.app.data.radarr_data.logs.items.to_vec());
self.app.data.radarr_data.log_details.scroll_to_bottom();
}
_ if *key == DEFAULT_KEYBINDINGS.tasks.key => {
self
.app
.push_navigation_stack(ActiveRadarrBlock::SystemTasks.into());
}
_ => (),
},
ActiveRadarrBlock::AddRootFolderPrompt => {
handle_text_box_keys!(self, key, self.app.data.radarr_data.edit_path)
}
src/handlers/radarr_handlers/movie_details_handler_tests.rs
+3 -3
View File
@@ -625,7 +625,7 @@ mod tests {
let release_a = Release {
protocol: "Protocol A".to_owned(),
age: Number::from(1),
title: HorizontallyScrollableText::from("Title A".to_owned()),
title: HorizontallyScrollableText::from("Title A"),
indexer: "Indexer A".to_owned(),
size: Number::from(1),
rejected: true,
@@ -643,7 +643,7 @@ mod tests {
let release_b = Release {
protocol: "Protocol B".to_owned(),
age: Number::from(2),
title: HorizontallyScrollableText::from("Title B".to_owned()),
title: HorizontallyScrollableText::from("Title B"),
indexer: "Indexer B".to_owned(),
size: Number::from(2),
rejected: false,
@@ -661,7 +661,7 @@ mod tests {
let release_c = Release {
protocol: "Protocol C".to_owned(),
age: Number::from(3),
title: HorizontallyScrollableText::from("Title C".to_owned()),
title: HorizontallyScrollableText::from("Title C"),
indexer: "Indexer C".to_owned(),
size: Number::from(3),
rejected: false,
src/handlers/radarr_handlers/radarr_handler_tests.rs
+65 -2
View File
@@ -754,7 +754,7 @@ mod tests {
let mut app = App::default();
app.push_navigation_stack(ActiveRadarrBlock::RootFolders.into());
app.push_navigation_stack(ActiveRadarrBlock::AddRootFolderPrompt.into());
app.data.radarr_data.edit_path = HorizontallyScrollableText::from("/nfs/test".to_owned());
app.data.radarr_data.edit_path = HorizontallyScrollableText::from("/nfs/test");
app.should_ignore_quit_key = true;
RadarrHandler::with(
@@ -921,6 +921,7 @@ mod tests {
ActiveRadarrBlock::Collections,
ActiveRadarrBlock::UpdateAllCollectionsPrompt
)]
#[case(ActiveRadarrBlock::System, ActiveRadarrBlock::SystemQueue)]
fn test_update_key(
#[case] active_radarr_block: ActiveRadarrBlock,
#[case] expected_radarr_block: ActiveRadarrBlock,
@@ -944,7 +945,8 @@ mod tests {
ActiveRadarrBlock::Movies,
ActiveRadarrBlock::Collections,
ActiveRadarrBlock::Downloads,
ActiveRadarrBlock::RootFolders
ActiveRadarrBlock::RootFolders,
ActiveRadarrBlock::System
)]
active_radarr_block: ActiveRadarrBlock,
) {
@@ -963,6 +965,54 @@ mod tests {
assert!(app.should_refresh);
}
#[test]
fn test_logs_key() {
let mut app = App::default();
app.data.radarr_data.logs.set_items(vec![
HorizontallyScrollableText::from("test 1"),
HorizontallyScrollableText::from("test 2"),
]);
RadarrHandler::with(
&DEFAULT_KEYBINDINGS.logs.key,
&mut app,
&ActiveRadarrBlock::System,
&None,
)
.handle();
assert_eq!(
app.get_current_route(),
&ActiveRadarrBlock::SystemLogs.into()
);
assert_eq!(
app.data.radarr_data.log_details.items,
app.data.radarr_data.logs.items
);
assert_str_eq!(
app.data.radarr_data.log_details.current_selection().text,
"test 2"
);
}
#[test]
fn test_tasks_key() {
let mut app = App::default();
RadarrHandler::with(
&DEFAULT_KEYBINDINGS.tasks.key,
&mut app,
&ActiveRadarrBlock::System,
&None,
)
.handle();
assert_eq!(
app.get_current_route(),
&ActiveRadarrBlock::SystemTasks.into()
);
}
#[test]
fn test_add_root_folder_prompt_backspace_key() {
let mut app = App::default();
@@ -1196,6 +1246,19 @@ mod tests {
assert!(app.data.radarr_data.filter.text.is_empty());
}
#[rstest]
fn test_delegates_system_details_blocks_to_system_details_handler(
#[values(
ActiveRadarrBlock::System,
ActiveRadarrBlock::SystemLogs,
ActiveRadarrBlock::SystemTasks,
ActiveRadarrBlock::SystemQueue
)]
active_radarr_block: ActiveRadarrBlock,
) {
test_handler_delegation!(ActiveRadarrBlock::System, active_radarr_block);
}
#[rstest]
fn test_delegates_add_movie_blocks_to_add_movie_handler(
#[values(
src/handlers/radarr_handlers/system_details_handler.rs
+150
View File
@@ -0,0 +1,150 @@
use crate::app::key_binding::DEFAULT_KEYBINDINGS;
use crate::app::radarr::{ActiveRadarrBlock, SYSTEM_DETAILS_BLOCKS};
use crate::app::App;
use crate::event::Key;
use crate::handlers::{handle_prompt_toggle, KeyEventHandler};
use crate::models::Scrollable;
use crate::network::radarr_network::RadarrEvent;
#[cfg(test)]
#[path = "system_details_handler_tests.rs"]
mod system_details_handler_tests;
pub(super) struct SystemDetailsHandler<'a, 'b> {
key: &'a Key,
app: &'a mut App<'b>,
active_radarr_block: &'a ActiveRadarrBlock,
_context: &'a Option<ActiveRadarrBlock>,
}
impl<'a, 'b> KeyEventHandler<'a, 'b, ActiveRadarrBlock> for SystemDetailsHandler<'a, 'b> {
fn with(
key: &'a Key,
app: &'a mut App<'b>,
active_block: &'a ActiveRadarrBlock,
context: &'a Option<ActiveRadarrBlock>,
) -> SystemDetailsHandler<'a, 'b> {
SystemDetailsHandler {
key,
app,
active_radarr_block: active_block,
_context: context,
}
}
fn get_key(&self) -> &Key {
self.key
}
fn handle_scroll_up(&mut self) {
match self.active_radarr_block {
ActiveRadarrBlock::SystemLogs => self.app.data.radarr_data.log_details.scroll_up(),
ActiveRadarrBlock::SystemTasks => self.app.data.radarr_data.tasks.scroll_up(),
ActiveRadarrBlock::SystemQueue => self.app.data.radarr_data.queued_events.scroll_up(),
_ => (),
}
}
fn handle_scroll_down(&mut self) {
match self.active_radarr_block {
ActiveRadarrBlock::SystemLogs => self.app.data.radarr_data.log_details.scroll_down(),
ActiveRadarrBlock::SystemTasks => self.app.data.radarr_data.tasks.scroll_down(),
ActiveRadarrBlock::SystemQueue => self.app.data.radarr_data.queued_events.scroll_down(),
_ => (),
}
}
fn handle_home(&mut self) {
match self.active_radarr_block {
ActiveRadarrBlock::SystemLogs => self.app.data.radarr_data.log_details.scroll_to_top(),
ActiveRadarrBlock::SystemTasks => self.app.data.radarr_data.tasks.scroll_to_top(),
ActiveRadarrBlock::SystemQueue => self.app.data.radarr_data.queued_events.scroll_to_top(),
_ => (),
}
}
fn handle_end(&mut self) {
match self.active_radarr_block {
ActiveRadarrBlock::SystemLogs => self.app.data.radarr_data.log_details.scroll_to_bottom(),
ActiveRadarrBlock::SystemTasks => self.app.data.radarr_data.tasks.scroll_to_bottom(),
ActiveRadarrBlock::SystemQueue => self.app.data.radarr_data.queued_events.scroll_to_bottom(),
_ => (),
}
}
fn handle_delete(&mut self) {}
fn handle_left_right_action(&mut self) {
let key = self.key;
match self.active_radarr_block {
ActiveRadarrBlock::SystemLogs => match self.key {
_ if *key == DEFAULT_KEYBINDINGS.left.key => {
self
.app
.data
.radarr_data
.log_details
.items
.iter()
.for_each(|log| log.scroll_right());
}
_ if *key == DEFAULT_KEYBINDINGS.right.key => {
self
.app
.data
.radarr_data
.log_details
.items
.iter()
.for_each(|log| log.scroll_left());
}
_ => (),
},
ActiveRadarrBlock::SystemTaskStartConfirmPrompt => handle_prompt_toggle(self.app, self.key),
_ => (),
}
}
fn handle_submit(&mut self) {
match self.active_radarr_block {
ActiveRadarrBlock::SystemTasks => {
self
.app
.push_navigation_stack(ActiveRadarrBlock::SystemTaskStartConfirmPrompt.into());
}
ActiveRadarrBlock::SystemTaskStartConfirmPrompt => {
if self.app.data.radarr_data.prompt_confirm {
self.app.data.radarr_data.prompt_confirm_action = Some(RadarrEvent::StartTask);
}
self.app.pop_navigation_stack();
}
_ => (),
}
}
fn handle_esc(&mut self) {
match self.active_radarr_block {
ActiveRadarrBlock::SystemLogs
| ActiveRadarrBlock::SystemTasks
| ActiveRadarrBlock::SystemQueue => {
self.app.data.radarr_data.reset_log_details_list();
self.app.pop_navigation_stack()
}
ActiveRadarrBlock::SystemTaskStartConfirmPrompt => {
self.app.pop_navigation_stack();
self.app.data.radarr_data.prompt_confirm = false;
}
_ => (),
}
}
fn handle_char_key_event(&mut self) {
if SYSTEM_DETAILS_BLOCKS.contains(self.active_radarr_block)
&& self.key == &DEFAULT_KEYBINDINGS.refresh.key
{
self.app.should_refresh = true;
}
}
}
src/handlers/radarr_handlers/system_details_handler_tests.rs
+409
View File
@@ -0,0 +1,409 @@
#[cfg(test)]
mod tests {
use pretty_assertions::assert_str_eq;
use crate::app::key_binding::DEFAULT_KEYBINDINGS;
use crate::app::radarr::ActiveRadarrBlock;
use crate::app::App;
use crate::event::Key;
use crate::handlers::radarr_handlers::system_details_handler::SystemDetailsHandler;
use crate::handlers::KeyEventHandler;
use crate::models::radarr_models::{QueueEvent, Task};
mod test_handle_scroll_up_and_down {
use rstest::rstest;
use crate::models::HorizontallyScrollableText;
use crate::{simple_stateful_iterable_vec, test_iterable_scroll};
use super::*;
test_iterable_scroll!(
test_log_details_scroll,
SystemDetailsHandler,
log_details,
simple_stateful_iterable_vec!(HorizontallyScrollableText, String, text),
ActiveRadarrBlock::SystemLogs,
None,
text
);
test_iterable_scroll!(
test_tasks_scroll,
SystemDetailsHandler,
tasks,
simple_stateful_iterable_vec!(Task, String, name),
ActiveRadarrBlock::SystemTasks,
None,
name
);
test_iterable_scroll!(
test_queued_events_scroll,
SystemDetailsHandler,
queued_events,
simple_stateful_iterable_vec!(QueueEvent, String, name),
ActiveRadarrBlock::SystemQueue,
None,
name
);
}
mod test_handle_home_end {
use crate::models::HorizontallyScrollableText;
use crate::{extended_stateful_iterable_vec, test_iterable_home_and_end};
use super::*;
test_iterable_home_and_end!(
test_log_details_home_end,
SystemDetailsHandler,
log_details,
extended_stateful_iterable_vec!(HorizontallyScrollableText, String, text),
ActiveRadarrBlock::SystemLogs,
None,
text
);
test_iterable_home_and_end!(
test_tasks_home_end,
SystemDetailsHandler,
tasks,
extended_stateful_iterable_vec!(Task, String, name),
ActiveRadarrBlock::SystemTasks,
None,
name
);
test_iterable_home_and_end!(
test_queued_events_home_end,
SystemDetailsHandler,
queued_events,
extended_stateful_iterable_vec!(QueueEvent, String, name),
ActiveRadarrBlock::SystemQueue,
None,
name
);
}
mod test_handle_left_right_action {
use super::*;
use pretty_assertions::assert_eq;
use rstest::rstest;
#[test]
fn test_handle_log_details_left_right() {
let active_radarr_block = ActiveRadarrBlock::SystemLogs;
let mut app = App::default();
app
.data
.radarr_data
.log_details
.set_items(vec!["t1".into(), "t22".into()]);
SystemDetailsHandler::with(
&DEFAULT_KEYBINDINGS.left.key,
&mut app,
&active_radarr_block,
&None,
)
.handle();
assert_eq!(app.data.radarr_data.log_details.items[0].to_string(), "t1");
assert_eq!(app.data.radarr_data.log_details.items[1].to_string(), "t22");
SystemDetailsHandler::with(
&DEFAULT_KEYBINDINGS.right.key,
&mut app,
&active_radarr_block,
&None,
)
.handle();
assert_eq!(app.data.radarr_data.log_details.items[0].to_string(), "1");
assert_eq!(app.data.radarr_data.log_details.items[1].to_string(), "22");
SystemDetailsHandler::with(
&DEFAULT_KEYBINDINGS.right.key,
&mut app,
&active_radarr_block,
&None,
)
.handle();
assert_eq!(app.data.radarr_data.log_details.items[0].to_string(), "");
assert_eq!(app.data.radarr_data.log_details.items[1].to_string(), "2");
SystemDetailsHandler::with(
&DEFAULT_KEYBINDINGS.right.key,
&mut app,
&active_radarr_block,
&None,
)
.handle();
assert_eq!(app.data.radarr_data.log_details.items[0].to_string(), "");
assert_eq!(app.data.radarr_data.log_details.items[1].to_string(), "");
SystemDetailsHandler::with(
&DEFAULT_KEYBINDINGS.right.key,
&mut app,
&active_radarr_block,
&None,
)
.handle();
assert_eq!(app.data.radarr_data.log_details.items[0].to_string(), "");
assert_eq!(app.data.radarr_data.log_details.items[1].to_string(), "");
SystemDetailsHandler::with(
&DEFAULT_KEYBINDINGS.left.key,
&mut app,
&active_radarr_block,
&None,
)
.handle();
assert_eq!(app.data.radarr_data.log_details.items[0].to_string(), "1");
assert_eq!(app.data.radarr_data.log_details.items[1].to_string(), "2");
SystemDetailsHandler::with(
&DEFAULT_KEYBINDINGS.left.key,
&mut app,
&active_radarr_block,
&None,
)
.handle();
assert_eq!(app.data.radarr_data.log_details.items[0].to_string(), "t1");
assert_eq!(app.data.radarr_data.log_details.items[1].to_string(), "22");
SystemDetailsHandler::with(
&DEFAULT_KEYBINDINGS.left.key,
&mut app,
&active_radarr_block,
&None,
)
.handle();
assert_eq!(app.data.radarr_data.log_details.items[0].to_string(), "t1");
assert_eq!(app.data.radarr_data.log_details.items[1].to_string(), "t22");
}
#[rstest]
fn test_left_right_prompt_toggle(
#[values(DEFAULT_KEYBINDINGS.left.key, DEFAULT_KEYBINDINGS.right.key)] key: Key,
) {
let mut app = App::default();
SystemDetailsHandler::with(
&key,
&mut app,
&ActiveRadarrBlock::SystemTaskStartConfirmPrompt,
&None,
)
.handle();
assert!(app.data.radarr_data.prompt_confirm);
SystemDetailsHandler::with(
&key,
&mut app,
&ActiveRadarrBlock::SystemTaskStartConfirmPrompt,
&None,
)
.handle();
assert!(!app.data.radarr_data.prompt_confirm);
}
}
mod test_handle_submit {
use crate::network::radarr_network::RadarrEvent;
use pretty_assertions::assert_eq;
use super::*;
const SUBMIT_KEY: Key = DEFAULT_KEYBINDINGS.submit.key;
#[test]
fn test_system_tasks_submit() {
let mut app = App::default();
SystemDetailsHandler::with(
&SUBMIT_KEY,
&mut app,
&ActiveRadarrBlock::SystemTasks,
&None,
)
.handle();
assert_eq!(
app.get_current_route(),
&ActiveRadarrBlock::SystemTaskStartConfirmPrompt.into()
);
}
#[test]
fn test_system_tasks_start_task_prompt_confirm_submit() {
let mut app = App::default();
app.data.radarr_data.prompt_confirm = true;
app.push_navigation_stack(ActiveRadarrBlock::SystemTasks.into());
app.push_navigation_stack(ActiveRadarrBlock::SystemTaskStartConfirmPrompt.into());
SystemDetailsHandler::with(
&SUBMIT_KEY,
&mut app,
&ActiveRadarrBlock::SystemTaskStartConfirmPrompt,
&None,
)
.handle();
assert!(app.data.radarr_data.prompt_confirm);
assert_eq!(
app.data.radarr_data.prompt_confirm_action,
Some(RadarrEvent::StartTask)
);
assert_eq!(
app.get_current_route(),
&ActiveRadarrBlock::SystemTasks.into()
);
}
#[test]
fn test_system_tasks_start_task_prompt_decline_submit() {
let mut app = App::default();
app.push_navigation_stack(ActiveRadarrBlock::SystemTasks.into());
app.push_navigation_stack(ActiveRadarrBlock::SystemTaskStartConfirmPrompt.into());
SystemDetailsHandler::with(
&SUBMIT_KEY,
&mut app,
&ActiveRadarrBlock::SystemTaskStartConfirmPrompt,
&None,
)
.handle();
assert!(!app.data.radarr_data.prompt_confirm);
assert_eq!(app.data.radarr_data.prompt_confirm_action, None);
assert_eq!(
app.get_current_route(),
&ActiveRadarrBlock::SystemTasks.into()
);
}
}
mod test_handle_esc {
use crate::models::HorizontallyScrollableText;
use pretty_assertions::assert_eq;
use super::*;
const ESC_KEY: Key = DEFAULT_KEYBINDINGS.esc.key;
#[test]
fn test_esc_system_logs() {
let mut app = App::default();
app
.data
.radarr_data
.log_details
.set_items(vec![HorizontallyScrollableText::from("test")]);
app.push_navigation_stack(ActiveRadarrBlock::System.into());
app.push_navigation_stack(ActiveRadarrBlock::SystemLogs.into());
app
.data
.radarr_data
.log_details
.set_items(vec![HorizontallyScrollableText::default()]);
SystemDetailsHandler::with(&ESC_KEY, &mut app, &ActiveRadarrBlock::SystemLogs, &None)
.handle();
assert_eq!(app.get_current_route(), &ActiveRadarrBlock::System.into());
assert!(app.data.radarr_data.log_details.items.is_empty());
}
#[test]
fn test_esc_system_tasks() {
let mut app = App::default();
app.push_navigation_stack(ActiveRadarrBlock::System.into());
app.push_navigation_stack(ActiveRadarrBlock::SystemTasks.into());
app.data.radarr_data.tasks.set_items(vec![Task::default()]);
SystemDetailsHandler::with(&ESC_KEY, &mut app, &ActiveRadarrBlock::SystemTasks, &None)
.handle();
assert_eq!(app.get_current_route(), &ActiveRadarrBlock::System.into());
}
#[test]
fn test_esc_system_queue() {
let mut app = App::default();
app.push_navigation_stack(ActiveRadarrBlock::System.into());
app.push_navigation_stack(ActiveRadarrBlock::SystemQueue.into());
app
.data
.radarr_data
.queued_events
.set_items(vec![QueueEvent::default()]);
SystemDetailsHandler::with(&ESC_KEY, &mut app, &ActiveRadarrBlock::SystemQueue, &None)
.handle();
assert_eq!(app.get_current_route(), &ActiveRadarrBlock::System.into());
}
#[test]
fn test_system_tasks_start_task_prompt_esc() {
let mut app = App::default();
app.push_navigation_stack(ActiveRadarrBlock::SystemTasks.into());
app.push_navigation_stack(ActiveRadarrBlock::SystemTaskStartConfirmPrompt.into());
app.data.radarr_data.prompt_confirm = true;
SystemDetailsHandler::with(
&ESC_KEY,
&mut app,
&ActiveRadarrBlock::SystemTaskStartConfirmPrompt,
&None,
)
.handle();
assert_eq!(
app.get_current_route(),
&ActiveRadarrBlock::SystemTasks.into()
);
assert!(!app.data.radarr_data.prompt_confirm);
}
}
mod test_handle_key_char {
use rstest::rstest;
use super::*;
#[rstest]
fn test_refresh_key(
#[values(
ActiveRadarrBlock::SystemLogs,
ActiveRadarrBlock::SystemTasks,
ActiveRadarrBlock::SystemQueue
)]
active_radarr_block: ActiveRadarrBlock,
) {
let mut app = App::default();
app.push_navigation_stack(active_radarr_block.into());
SystemDetailsHandler::with(
&DEFAULT_KEYBINDINGS.refresh.key,
&mut app,
&active_radarr_block,
&None,
)
.handle();
assert_eq!(app.get_current_route(), &active_radarr_block.into());
assert!(app.should_refresh);
}
}
}