Refactored to require handlers to specify the components they rely on and to specify when they are ready. This fixes a lot of bugs with the UI when users try to press buttons while the application is still loading.

src/handlers/radarr_handlers/library/add_movie_handler.rs

@@ -41,6 +41,10 @@ impl<'a, 'b> KeyEventHandler<'a, 'b, ActiveRadarrBlock> for AddMovieHandler<'a,
     self.key
   }
 
+  fn is_ready(&self) -> bool {
+    !self.app.is_loading
+  }
+
   fn handle_scroll_up(&mut self) {
     match self.active_radarr_block {
       ActiveRadarrBlock::AddMovieSearchResults => self

src/handlers/radarr_handlers/library/add_movie_handler_tests.rs

@@ -82,6 +82,62 @@ mod tests {
       );
     }
 
+    #[rstest]
+    fn test_add_movie_search_results_scroll_no_op_when_not_ready(
+      #[values(DEFAULT_KEYBINDINGS.up.key, DEFAULT_KEYBINDINGS.down.key)] key: Key,
+    ) {
+      let mut app = App::default();
+      app.is_loading = true;
+      let mut add_searched_movies = StatefulTable::default();
+      add_searched_movies.set_items(simple_stateful_iterable_vec!(
+        AddMovieSearchResult,
+        HorizontallyScrollableText
+      ));
+      app.data.radarr_data.add_searched_movies = Some(add_searched_movies);
+
+      AddMovieHandler::with(
+        &key,
+        &mut app,
+        &ActiveRadarrBlock::AddMovieSearchResults,
+        &None,
+      )
+      .handle();
+
+      assert_str_eq!(
+        app
+          .data
+          .radarr_data
+          .add_searched_movies
+          .as_ref()
+          .unwrap()
+          .current_selection()
+          .title
+          .to_string(),
+        "Test 1"
+      );
+
+      AddMovieHandler::with(
+        &key,
+        &mut app,
+        &ActiveRadarrBlock::AddMovieSearchResults,
+        &None,
+      )
+      .handle();
+
+      assert_str_eq!(
+        app
+          .data
+          .radarr_data
+          .add_searched_movies
+          .as_ref()
+          .unwrap()
+          .current_selection()
+          .title
+          .to_string(),
+        "Test 1"
+      );
+    }
+
     #[rstest]
     fn test_add_movie_select_monitor_scroll(
       #[values(DEFAULT_KEYBINDINGS.up.key, DEFAULT_KEYBINDINGS.down.key)] key: Key,
@@ -342,6 +398,21 @@ mod tests {
         );
       }
     }
+
+    #[rstest]
+    fn test_add_movie_prompt_scroll_no_op_when_not_ready(#[values(Key::Up, Key::Down)] key: Key) {
+      let mut app = App::default();
+      app.is_loading = true;
+      app.data.radarr_data.selected_block = BlockSelectionState::new(&ADD_MOVIE_SELECTION_BLOCKS);
+      app.data.radarr_data.selected_block.next();
+
+      AddMovieHandler::with(&key, &mut app, &ActiveRadarrBlock::AddMoviePrompt, &None).handle();
+
+      assert_eq!(
+        app.data.radarr_data.selected_block.get_active_block(),
+        &ActiveRadarrBlock::AddMovieSelectMonitor
+      );
+    }
   }
 
   mod test_handle_home_end {
@@ -406,6 +477,60 @@ mod tests {
       );
     }
 
+    #[test]
+    fn test_add_movie_search_results_home_end_no_op_when_not_ready() {
+      let mut app = App::default();
+      app.is_loading = true;
+      let mut add_searched_movies = StatefulTable::default();
+      add_searched_movies.set_items(extended_stateful_iterable_vec!(
+        AddMovieSearchResult,
+        HorizontallyScrollableText
+      ));
+      app.data.radarr_data.add_searched_movies = Some(add_searched_movies);
+
+      AddMovieHandler::with(
+        &DEFAULT_KEYBINDINGS.end.key,
+        &mut app,
+        &ActiveRadarrBlock::AddMovieSearchResults,
+        &None,
+      )
+      .handle();
+
+      assert_str_eq!(
+        app
+          .data
+          .radarr_data
+          .add_searched_movies
+          .as_ref()
+          .unwrap()
+          .current_selection()
+          .title
+          .to_string(),
+        "Test 1"
+      );
+
+      AddMovieHandler::with(
+        &DEFAULT_KEYBINDINGS.home.key,
+        &mut app,
+        &ActiveRadarrBlock::AddMovieSearchResults,
+        &None,
+      )
+      .handle();
+
+      assert_str_eq!(
+        app
+          .data
+          .radarr_data
+          .add_searched_movies
+          .as_ref()
+          .unwrap()
+          .current_selection()
+          .title
+          .to_string(),
+        "Test 1"
+      );
+    }
+
     #[test]
     fn test_add_movie_select_monitor_home_end() {
       let monitor_vec = Vec::from_iter(Monitor::iter());
@@ -970,6 +1095,29 @@ mod tests {
       );
     }
 
+    #[test]
+    fn test_add_movie_search_results_submit_no_op_when_not_ready() {
+      let mut app = App::default();
+      app.is_loading = true;
+      app.push_navigation_stack(ActiveRadarrBlock::AddMovieSearchResults.into());
+      let mut add_searched_movies = StatefulTable::default();
+      add_searched_movies.set_items(vec![AddMovieSearchResult::default()]);
+
+      AddMovieHandler::with(
+        &SUBMIT_KEY,
+        &mut app,
+        &ActiveRadarrBlock::AddMovieSearchResults,
+        &None,
+      )
+      .handle();
+
+      assert_eq!(
+        app.get_current_route(),
+        &ActiveRadarrBlock::AddMovieSearchResults.into()
+      );
+      assert!(app.data.radarr_data.add_movie_modal.is_none());
+    }
+
     #[test]
     fn test_add_movie_search_results_submit_does_nothing_on_empty_table() {
       let mut app = App::default();
@@ -1155,9 +1303,10 @@ mod tests {
 
     const ESC_KEY: Key = DEFAULT_KEYBINDINGS.esc.key;
 
-    #[test]
-    fn test_add_movie_search_input_esc() {
+    #[rstest]
+    fn test_add_movie_search_input_esc(#[values(true, false)] is_ready: bool) {
       let mut app = App::default();
+      app.is_loading = is_ready;
       app.data.radarr_data = create_test_radarr_data();
       app.should_ignore_quit_key = true;
       app.push_navigation_stack(ActiveRadarrBlock::AddMovieSearchInput.into());
@@ -1447,4 +1596,34 @@ mod tests {
       }
     });
   }
+
+  #[test]
+  fn test_add_movie_handler_is_not_ready_when_loading() {
+    let mut app = App::default();
+    app.is_loading = true;
+
+    let handler = AddMovieHandler::with(
+      &DEFAULT_KEYBINDINGS.esc.key,
+      &mut app,
+      &ActiveRadarrBlock::AddMoviePrompt,
+      &None,
+    );
+
+    assert!(!handler.is_ready());
+  }
+
+  #[test]
+  fn test_add_movie_handler_is_ready_when_not_loading() {
+    let mut app = App::default();
+    app.is_loading = false;
+
+    let handler = AddMovieHandler::with(
+      &DEFAULT_KEYBINDINGS.esc.key,
+      &mut app,
+      &ActiveRadarrBlock::AddMoviePrompt,
+      &None,
+    );
+
+    assert!(handler.is_ready());
+  }
 }

src/handlers/radarr_handlers/library/delete_movie_handler.rs

@@ -38,6 +38,10 @@ impl<'a, 'b> KeyEventHandler<'a, 'b, ActiveRadarrBlock> for DeleteMovieHandler<'
     self.key
   }
 
+  fn is_ready(&self) -> bool {
+    !self.app.is_loading
+  }
+
   fn handle_scroll_up(&mut self) {
     if *self.active_radarr_block == ActiveRadarrBlock::DeleteMoviePrompt {
       self.app.data.radarr_data.selected_block.previous();

src/handlers/radarr_handlers/library/delete_movie_handler_tests.rs

@@ -40,6 +40,25 @@ mod tests {
         );
       }
     }
+
+    #[rstest]
+    fn test_delete_movie_prompt_scroll_no_op_when_not_ready(
+      #[values(Key::Up, Key::Down)] key: Key,
+    ) {
+      let mut app = App::default();
+      app.is_loading = true;
+      app.data.radarr_data.selected_block =
+        BlockSelectionState::new(&DELETE_MOVIE_SELECTION_BLOCKS);
+      app.data.radarr_data.selected_block.next();
+
+      DeleteMovieHandler::with(&key, &mut app, &ActiveRadarrBlock::DeleteMoviePrompt, &None)
+        .handle();
+
+      assert_eq!(
+        app.data.radarr_data.selected_block.get_active_block(),
+        &ActiveRadarrBlock::DeleteMovieToggleAddListExclusion
+      );
+    }
   }
 
   mod test_handle_left_right_action {
@@ -139,6 +158,35 @@ mod tests {
       assert!(app.data.radarr_data.add_list_exclusion);
     }
 
+    #[test]
+    fn test_delete_movie_confirm_prompt_prompt_confirmation_submit_no_op_when_not_ready() {
+      let mut app = App::default();
+      app.is_loading = true;
+      app.push_navigation_stack(ActiveRadarrBlock::Movies.into());
+      app.push_navigation_stack(ActiveRadarrBlock::DeleteMoviePrompt.into());
+      app.data.radarr_data.prompt_confirm = true;
+      app.data.radarr_data.delete_movie_files = true;
+      app.data.radarr_data.add_list_exclusion = true;
+
+      DeleteMovieHandler::with(
+        &SUBMIT_KEY,
+        &mut app,
+        &ActiveRadarrBlock::DeleteMoviePrompt,
+        &None,
+      )
+      .handle();
+
+      assert_eq!(
+        app.get_current_route(),
+        &ActiveRadarrBlock::DeleteMoviePrompt.into()
+      );
+      assert_eq!(app.data.radarr_data.prompt_confirm_action, None);
+      assert!(!app.should_refresh);
+      assert!(app.data.radarr_data.prompt_confirm);
+      assert!(app.data.radarr_data.delete_movie_files);
+      assert!(app.data.radarr_data.add_list_exclusion);
+    }
+
     #[test]
     fn test_delete_movie_toggle_delete_files_submit() {
       let current_route = ActiveRadarrBlock::DeleteMoviePrompt.into();
@@ -173,12 +221,14 @@ mod tests {
 
   mod test_handle_esc {
     use super::*;
+    use rstest::rstest;
 
     const ESC_KEY: Key = DEFAULT_KEYBINDINGS.esc.key;
 
-    #[test]
-    fn test_delete_movie_prompt_esc() {
+    #[rstest]
+    fn test_delete_movie_prompt_esc(#[values(true, false)] is_ready: bool) {
       let mut app = App::default();
+      app.is_loading = is_ready;
       app.push_navigation_stack(ActiveRadarrBlock::Movies.into());
       app.push_navigation_stack(ActiveRadarrBlock::DeleteMoviePrompt.into());
       app.data.radarr_data.prompt_confirm = true;
@@ -210,4 +260,34 @@ mod tests {
       }
     });
   }
+
+  #[test]
+  fn test_delete_movie_handler_not_ready_when_loading() {
+    let mut app = App::default();
+    app.is_loading = true;
+
+    let handler = DeleteMovieHandler::with(
+      &DEFAULT_KEYBINDINGS.esc.key,
+      &mut app,
+      &ActiveRadarrBlock::DeleteMoviePrompt,
+      &None,
+    );
+
+    assert!(!handler.is_ready());
+  }
+
+  #[test]
+  fn test_delete_movie_handler_ready_when_not_loading() {
+    let mut app = App::default();
+    app.is_loading = false;
+
+    let handler = DeleteMovieHandler::with(
+      &DEFAULT_KEYBINDINGS.esc.key,
+      &mut app,
+      &ActiveRadarrBlock::DeleteMoviePrompt,
+      &None,
+    );
+
+    assert!(handler.is_ready());
+  }
 }

src/handlers/radarr_handlers/library/edit_movie_handler.rs

@@ -41,6 +41,10 @@ impl<'a, 'b> KeyEventHandler<'a, 'b, ActiveRadarrBlock> for EditMovieHandler<'a,
     self.key
   }
 
+  fn is_ready(&self) -> bool {
+    !self.app.is_loading && self.app.data.radarr_data.edit_movie_modal.is_some()
+  }
+
   fn handle_scroll_up(&mut self) {
     match self.active_radarr_block {
       ActiveRadarrBlock::EditMovieSelectMinimumAvailability => self

src/handlers/radarr_handlers/library/edit_movie_handler_tests.rs

@@ -9,6 +9,7 @@ mod tests {
   use crate::handlers::radarr_handlers::library::edit_movie_handler::EditMovieHandler;
   use crate::handlers::KeyEventHandler;
   use crate::models::radarr_models::MinimumAvailability;
+  use crate::models::servarr_data::radarr::modals::EditMovieModal;
   use crate::models::servarr_data::radarr::radarr_data::{ActiveRadarrBlock, EDIT_MOVIE_BLOCKS};
 
   mod test_handle_scroll_up_and_down {
@@ -144,6 +145,7 @@ mod tests {
     #[rstest]
     fn test_edit_movie_prompt_scroll(#[values(Key::Up, Key::Down)] key: Key) {
       let mut app = App::default();
+      app.data.radarr_data.edit_movie_modal = Some(EditMovieModal::default());
       app.data.radarr_data.selected_block = BlockSelectionState::new(&EDIT_MOVIE_SELECTION_BLOCKS);
       app.data.radarr_data.selected_block.next();
 
@@ -161,6 +163,22 @@ mod tests {
         );
       }
     }
+
+    #[rstest]
+    fn test_edit_movie_prompt_scroll_no_op_when_not_ready(#[values(Key::Up, Key::Down)] key: Key) {
+      let mut app = App::default();
+      app.is_loading = true;
+      app.data.radarr_data.edit_movie_modal = Some(EditMovieModal::default());
+      app.data.radarr_data.selected_block = BlockSelectionState::new(&EDIT_MOVIE_SELECTION_BLOCKS);
+      app.data.radarr_data.selected_block.next();
+
+      EditMovieHandler::with(&key, &mut app, &ActiveRadarrBlock::EditMoviePrompt, &None).handle();
+
+      assert_eq!(
+        app.data.radarr_data.selected_block.get_active_block(),
+        &ActiveRadarrBlock::EditMovieSelectMinimumAvailability
+      );
+    }
   }
 
   mod test_handle_home_end {
@@ -596,6 +614,7 @@ mod tests {
     #[test]
     fn test_edit_movie_prompt_prompt_decline_submit() {
       let mut app = App::default();
+      app.data.radarr_data.edit_movie_modal = Some(EditMovieModal::default());
       app.push_navigation_stack(ActiveRadarrBlock::Movies.into());
       app.push_navigation_stack(ActiveRadarrBlock::EditMoviePrompt.into());
       app.data.radarr_data.selected_block = BlockSelectionState::new(&EDIT_MOVIE_SELECTION_BLOCKS);
@@ -648,6 +667,31 @@ mod tests {
       assert!(app.should_refresh);
     }
 
+    #[test]
+    fn test_edit_movie_confirm_prompt_prompt_confirmation_submit_no_op_when_not_ready() {
+      let mut app = App::default();
+      app.is_loading = true;
+      app.data.radarr_data.edit_movie_modal = Some(EditMovieModal::default());
+      app.push_navigation_stack(ActiveRadarrBlock::Movies.into());
+      app.push_navigation_stack(ActiveRadarrBlock::EditMoviePrompt.into());
+      app.data.radarr_data.prompt_confirm = true;
+
+      EditMovieHandler::with(
+        &SUBMIT_KEY,
+        &mut app,
+        &ActiveRadarrBlock::EditMoviePrompt,
+        &None,
+      )
+      .handle();
+
+      assert_eq!(
+        app.get_current_route(),
+        &ActiveRadarrBlock::EditMoviePrompt.into()
+      );
+      assert_eq!(app.data.radarr_data.prompt_confirm_action, None);
+      assert!(!app.should_refresh);
+    }
+
     #[test]
     fn test_edit_movie_toggle_monitored_submit() {
       let current_route = Route::from((
@@ -710,6 +754,7 @@ mod tests {
       #[case] index: usize,
     ) {
       let mut app = App::default();
+      app.data.radarr_data.edit_movie_modal = Some(EditMovieModal::default());
       app.push_navigation_stack(
         (
           ActiveRadarrBlock::EditMoviePrompt,
@@ -741,6 +786,43 @@ mod tests {
       }
     }
 
+    #[rstest]
+    fn test_edit_movie_prompt_selected_block_submit_no_op_when_not_ready(
+      #[values(1, 2, 3, 4)] index: usize,
+    ) {
+      let mut app = App::default();
+      app.is_loading = true;
+      app.data.radarr_data.edit_movie_modal = Some(EditMovieModal::default());
+      app.push_navigation_stack(
+        (
+          ActiveRadarrBlock::EditMoviePrompt,
+          Some(ActiveRadarrBlock::Movies),
+        )
+          .into(),
+      );
+      app.data.radarr_data.selected_block = BlockSelectionState::new(&EDIT_MOVIE_SELECTION_BLOCKS);
+      app.data.radarr_data.selected_block.set_index(index);
+
+      EditMovieHandler::with(
+        &SUBMIT_KEY,
+        &mut app,
+        &ActiveRadarrBlock::EditMoviePrompt,
+        &Some(ActiveRadarrBlock::Movies),
+      )
+      .handle();
+
+      assert_eq!(
+        app.get_current_route(),
+        &(
+          ActiveRadarrBlock::EditMoviePrompt,
+          Some(ActiveRadarrBlock::Movies),
+        )
+          .into()
+      );
+      assert_eq!(app.data.radarr_data.prompt_confirm_action, None);
+      assert!(!app.should_ignore_quit_key);
+    }
+
     #[rstest]
     fn test_edit_movie_prompt_selecting_preferences_blocks_submit(
       #[values(
@@ -752,6 +834,7 @@ mod tests {
       active_radarr_block: ActiveRadarrBlock,
     ) {
       let mut app = App::default();
+      app.data.radarr_data.edit_movie_modal = Some(EditMovieModal::default());
       app.push_navigation_stack(ActiveRadarrBlock::EditMoviePrompt.into());
       app.push_navigation_stack(active_radarr_block.into());
 
@@ -838,8 +921,10 @@ mod tests {
         ActiveRadarrBlock::EditMovieSelectQualityProfile
       )]
       active_radarr_block: ActiveRadarrBlock,
+      #[values(true, false)] is_ready: bool,
     ) {
       let mut app = App::default();
+      app.is_loading = is_ready;
       app.data.radarr_data = create_test_radarr_data();
       app.push_navigation_stack(active_radarr_block.into());
 
@@ -974,4 +1059,50 @@ mod tests {
       }
     });
   }
+
+  #[test]
+  fn test_edit_movie_handler_is_not_ready_when_loading() {
+    let mut app = App::default();
+    app.is_loading = true;
+
+    let handler = EditMovieHandler::with(
+      &DEFAULT_KEYBINDINGS.esc.key,
+      &mut app,
+      &ActiveRadarrBlock::EditMoviePrompt,
+      &None,
+    );
+
+    assert!(!handler.is_ready());
+  }
+
+  #[test]
+  fn test_edit_movie_handler_is_not_ready_when_edit_movie_modal_is_none() {
+    let mut app = App::default();
+    app.is_loading = false;
+
+    let handler = EditMovieHandler::with(
+      &DEFAULT_KEYBINDINGS.esc.key,
+      &mut app,
+      &ActiveRadarrBlock::EditMoviePrompt,
+      &None,
+    );
+
+    assert!(!handler.is_ready());
+  }
+
+  #[test]
+  fn test_edit_movie_handler_is_ready_when_edit_movie_modal_is_some() {
+    let mut app = App::default();
+    app.is_loading = false;
+    app.data.radarr_data.edit_movie_modal = Some(EditMovieModal::default());
+
+    let handler = EditMovieHandler::with(
+      &DEFAULT_KEYBINDINGS.esc.key,
+      &mut app,
+      &ActiveRadarrBlock::EditMoviePrompt,
+      &None,
+    );
+
+    assert!(handler.is_ready());
+  }
 }

src/handlers/radarr_handlers/library/library_handler_tests.rs

@@ -36,6 +36,48 @@ mod tests {
       to_string
     );
 
+    #[rstest]
+    fn test_movies_scroll_no_op_when_not_ready(
+      #[values(DEFAULT_KEYBINDINGS.up.key, DEFAULT_KEYBINDINGS.down.key)] key: Key,
+    ) {
+      let mut app = App::default();
+      app.is_loading = true;
+      app
+        .data
+        .radarr_data
+        .movies
+        .set_items(simple_stateful_iterable_vec!(
+          Movie,
+          HorizontallyScrollableText
+        ));
+
+      LibraryHandler::with(&key, &mut app, &ActiveRadarrBlock::Movies, &None).handle();
+
+      assert_str_eq!(
+        app
+          .data
+          .radarr_data
+          .movies
+          .current_selection()
+          .title
+          .to_string(),
+        "Test 1"
+      );
+
+      LibraryHandler::with(&key, &mut app, &ActiveRadarrBlock::Movies, &None).handle();
+
+      assert_str_eq!(
+        app
+          .data
+          .radarr_data
+          .movies
+          .current_selection()
+          .title
+          .to_string(),
+        "Test 1"
+      );
+    }
+
     #[rstest]
     fn test_movies_sort_scroll(
       #[values(DEFAULT_KEYBINDINGS.up.key, DEFAULT_KEYBINDINGS.down.key)] key: Key,
@@ -100,9 +142,66 @@ mod tests {
       to_string
     );
 
+    #[test]
+    fn test_movies_home_end_no_op_when_not_ready() {
+      let mut app = App::default();
+      app.is_loading = true;
+      app
+        .data
+        .radarr_data
+        .movies
+        .set_items(extended_stateful_iterable_vec!(
+          Movie,
+          HorizontallyScrollableText
+        ));
+
+      LibraryHandler::with(
+        &DEFAULT_KEYBINDINGS.end.key,
+        &mut app,
+        &ActiveRadarrBlock::Movies,
+        &None,
+      )
+      .handle();
+
+      assert_str_eq!(
+        app
+          .data
+          .radarr_data
+          .movies
+          .current_selection()
+          .title
+          .to_string(),
+        "Test 1"
+      );
+
+      LibraryHandler::with(
+        &DEFAULT_KEYBINDINGS.home.key,
+        &mut app,
+        &ActiveRadarrBlock::Movies,
+        &None,
+      )
+      .handle();
+
+      assert_str_eq!(
+        app
+          .data
+          .radarr_data
+          .movies
+          .current_selection()
+          .title
+          .to_string(),
+        "Test 1"
+      );
+    }
+
     #[test]
     fn test_movie_search_box_home_end_keys() {
       let mut app = App::default();
+      app
+        .data
+        .radarr_data
+        .movies
+        .set_items(vec![Movie::default()]);
       app.data.radarr_data.movies.search = Some("Test".into());
 
       LibraryHandler::with(
@@ -151,6 +250,11 @@ mod tests {
     #[test]
     fn test_movie_filter_box_home_end_keys() {
       let mut app = App::default();
+      app
+        .data
+        .radarr_data
+        .movies
+        .set_items(vec![Movie::default()]);
       app.data.radarr_data.movies.filter = Some("Test".into());
 
       LibraryHandler::with(
@@ -257,6 +361,11 @@ mod tests {
     #[test]
     fn test_movies_delete() {
       let mut app = App::default();
+      app
+        .data
+        .radarr_data
+        .movies
+        .set_items(vec![Movie::default()]);
 
       assert_delete_prompt!(
         LibraryHandler,
@@ -269,6 +378,22 @@ mod tests {
         &DELETE_MOVIE_SELECTION_BLOCKS
       );
     }
+
+    #[test]
+    fn test_movies_delete_no_op_when_not_ready() {
+      let mut app = App::default();
+      app.is_loading = true;
+      app.push_navigation_stack(ActiveRadarrBlock::Movies.into());
+      app
+        .data
+        .radarr_data
+        .movies
+        .set_items(vec![Movie::default()]);
+
+      LibraryHandler::with(&DELETE_KEY, &mut app, &ActiveRadarrBlock::Movies, &None).handle();
+
+      assert_eq!(app.get_current_route(), &ActiveRadarrBlock::Movies.into());
+    }
   }
 
   mod test_handle_left_right_action {
@@ -277,9 +402,10 @@ mod tests {
 
     use super::*;
 
-    #[test]
-    fn test_movie_tab_left() {
+    #[rstest]
+    fn test_movie_tab_left(#[values(true, false)] is_ready: bool) {
       let mut app = App::default();
+      app.is_loading = is_ready;
       app.data.radarr_data.main_tabs.set_index(0);
 
       LibraryHandler::with(
@@ -297,9 +423,10 @@ mod tests {
       assert_eq!(app.get_current_route(), &ActiveRadarrBlock::System.into());
     }
 
-    #[test]
-    fn test_movie_tab_right() {
+    #[rstest]
+    fn test_movie_tab_right(#[values(true, false)] is_ready: bool) {
       let mut app = App::default();
+      app.is_loading = is_ready;
       app.data.radarr_data.main_tabs.set_index(0);
 
       LibraryHandler::with(
@@ -457,6 +584,11 @@ mod tests {
     #[test]
     fn test_movie_details_submit() {
       let mut app = App::default();
+      app
+        .data
+        .radarr_data
+        .movies
+        .set_items(vec![Movie::default()]);
 
       LibraryHandler::with(&SUBMIT_KEY, &mut app, &ActiveRadarrBlock::Movies, &None).handle();
 
@@ -466,6 +598,22 @@ mod tests {
       );
     }
 
+    #[test]
+    fn test_movie_details_submit_no_op_when_not_ready() {
+      let mut app = App::default();
+      app.is_loading = true;
+      app.push_navigation_stack(ActiveRadarrBlock::Movies.into());
+      app
+        .data
+        .radarr_data
+        .movies
+        .set_items(vec![Movie::default()]);
+
+      LibraryHandler::with(&SUBMIT_KEY, &mut app, &ActiveRadarrBlock::Movies, &None).handle();
+
+      assert_eq!(app.get_current_route(), &ActiveRadarrBlock::Movies.into());
+    }
+
     #[test]
     fn test_search_movie_submit() {
       let mut app = App::default();
@@ -532,6 +680,11 @@ mod tests {
     #[test]
     fn test_search_filtered_movies_submit() {
       let mut app = App::default();
+      app
+        .data
+        .radarr_data
+        .movies
+        .set_items(vec![Movie::default()]);
       app.push_navigation_stack(ActiveRadarrBlock::Movies.into());
       app.push_navigation_stack(ActiveRadarrBlock::SearchMovie.into());
       app
@@ -636,6 +789,11 @@ mod tests {
     #[test]
     fn test_update_all_movies_prompt_confirm_submit() {
       let mut app = App::default();
+      app
+        .data
+        .radarr_data
+        .movies
+        .set_items(vec![Movie::default()]);
       app.data.radarr_data.prompt_confirm = true;
       app.push_navigation_stack(ActiveRadarrBlock::Movies.into());
       app.push_navigation_stack(ActiveRadarrBlock::UpdateAllMoviesPrompt.into());
@@ -659,6 +817,11 @@ mod tests {
     #[test]
     fn test_update_all_movies_prompt_decline_submit() {
       let mut app = App::default();
+      app
+        .data
+        .radarr_data
+        .movies
+        .set_items(vec![Movie::default()]);
       app.push_navigation_stack(ActiveRadarrBlock::Movies.into());
       app.push_navigation_stack(ActiveRadarrBlock::UpdateAllMoviesPrompt.into());
 
@@ -793,9 +956,10 @@ mod tests {
       assert_eq!(app.get_current_route(), &ActiveRadarrBlock::Movies.into());
     }
 
-    #[test]
-    fn test_default_esc() {
+    #[rstest]
+    fn test_default_esc(#[values(true, false)] is_ready: bool) {
       let mut app = App::default();
+      app.is_loading = is_ready;
       app.error = "test error".to_owned().into();
       app.push_navigation_stack(ActiveRadarrBlock::Movies.into());
       app.push_navigation_stack(ActiveRadarrBlock::Movies.into());
@@ -831,14 +995,18 @@ mod tests {
       RadarrData, EDIT_MOVIE_SELECTION_BLOCKS,
     };
 
-    use crate::models::stateful_table::StatefulTable;
-    use crate::{assert_refresh_key, test_edit_movie_key};
+    use crate::test_edit_movie_key;
 
     use super::*;
 
     #[test]
     fn test_search_movies_key() {
       let mut app = App::default();
+      app
+        .data
+        .radarr_data
+        .movies
+        .set_items(vec![Movie::default()]);
 
       LibraryHandler::with(
         &DEFAULT_KEYBINDINGS.search.key,
@@ -859,10 +1027,38 @@ mod tests {
       );
     }
 
+    #[test]
+    fn test_search_movies_key_no_op_when_not_ready() {
+      let mut app = App::default();
+      app.is_loading = true;
+      app.push_navigation_stack(ActiveRadarrBlock::Movies.into());
+      app
+        .data
+        .radarr_data
+        .movies
+        .set_items(vec![Movie::default()]);
+
+      LibraryHandler::with(
+        &DEFAULT_KEYBINDINGS.search.key,
+        &mut app,
+        &ActiveRadarrBlock::Movies,
+        &None,
+      )
+      .handle();
+
+      assert_eq!(app.get_current_route(), &ActiveRadarrBlock::Movies.into());
+      assert!(!app.should_ignore_quit_key);
+      assert_eq!(app.data.radarr_data.movies.search, None);
+    }
+
     #[test]
     fn test_filter_movies_key() {
       let mut app = App::default();
-      app.data.radarr_data.movies = StatefulTable::default();
+      app
+        .data
+        .radarr_data
+        .movies
+        .set_items(vec![Movie::default()]);
 
       LibraryHandler::with(
         &DEFAULT_KEYBINDINGS.filter.key,
@@ -880,13 +1076,41 @@ mod tests {
       assert!(app.data.radarr_data.movies.filter.is_some());
     }
 
+    #[test]
+    fn test_filter_movies_key_no_op_when_not_ready() {
+      let mut app = App::default();
+      app.is_loading = true;
+      app.push_navigation_stack(ActiveRadarrBlock::Movies.into());
+      app
+        .data
+        .radarr_data
+        .movies
+        .set_items(vec![Movie::default()]);
+
+      LibraryHandler::with(
+        &DEFAULT_KEYBINDINGS.filter.key,
+        &mut app,
+        &ActiveRadarrBlock::Movies,
+        &None,
+      )
+      .handle();
+
+      assert_eq!(app.get_current_route(), &ActiveRadarrBlock::Movies.into());
+      assert!(!app.should_ignore_quit_key);
+      assert!(app.data.radarr_data.movies.filter.is_none());
+    }
+
     #[test]
     fn test_filter_movies_key_resets_previous_filter() {
       let mut app = App::default();
       app.should_ignore_quit_key = true;
       app.push_navigation_stack(ActiveRadarrBlock::Movies.into());
       app.data.radarr_data = create_test_radarr_data();
-      app.data.radarr_data.movies = StatefulTable::default();
+      app
+        .data
+        .radarr_data
+        .movies
+        .set_items(vec![Movie::default()]);
       app.data.radarr_data.movies.filter = Some("Test".into());
 
       LibraryHandler::with(
@@ -913,6 +1137,11 @@ mod tests {
     #[test]
     fn test_movie_add_key() {
       let mut app = App::default();
+      app
+        .data
+        .radarr_data
+        .movies
+        .set_items(vec![Movie::default()]);
 
       LibraryHandler::with(
         &DEFAULT_KEYBINDINGS.add.key,
@@ -930,6 +1159,30 @@ mod tests {
       assert!(app.data.radarr_data.add_movie_search.is_some());
     }
 
+    #[test]
+    fn test_movie_add_key_no_op_when_not_ready() {
+      let mut app = App::default();
+      app.is_loading = true;
+      app.push_navigation_stack(ActiveRadarrBlock::Movies.into());
+      app
+        .data
+        .radarr_data
+        .movies
+        .set_items(vec![Movie::default()]);
+
+      LibraryHandler::with(
+        &DEFAULT_KEYBINDINGS.add.key,
+        &mut app,
+        &ActiveRadarrBlock::Movies,
+        &None,
+      )
+      .handle();
+
+      assert_eq!(app.get_current_route(), &ActiveRadarrBlock::Movies.into());
+      assert!(!app.should_ignore_quit_key);
+      assert!(app.data.radarr_data.add_movie_search.is_none());
+    }
+
     #[test]
     fn test_movie_edit_key() {
       test_edit_movie_key!(
@@ -939,9 +1192,37 @@ mod tests {
       );
     }
 
+    #[test]
+    fn test_movie_edit_key_no_op_when_not_ready() {
+      let mut app = App::default();
+      app.is_loading = true;
+      app.push_navigation_stack(ActiveRadarrBlock::Movies.into());
+      app
+        .data
+        .radarr_data
+        .movies
+        .set_items(vec![Movie::default()]);
+
+      LibraryHandler::with(
+        &DEFAULT_KEYBINDINGS.edit.key,
+        &mut app,
+        &ActiveRadarrBlock::Movies,
+        &None,
+      )
+      .handle();
+
+      assert_eq!(app.get_current_route(), &ActiveRadarrBlock::Movies.into());
+      assert!(app.data.radarr_data.edit_movie_modal.is_none());
+    }
+
     #[test]
     fn test_update_all_movies_key() {
       let mut app = App::default();
+      app
+        .data
+        .radarr_data
+        .movies
+        .set_items(vec![Movie::default()]);
 
       LibraryHandler::with(
         &DEFAULT_KEYBINDINGS.update.key,
@@ -957,15 +1238,82 @@ mod tests {
       );
     }
 
+    #[test]
+    fn test_update_all_movies_key_no_op_when_not_ready() {
+      let mut app = App::default();
+      app.is_loading = true;
+      app.push_navigation_stack(ActiveRadarrBlock::Movies.into());
+      app
+        .data
+        .radarr_data
+        .movies
+        .set_items(vec![Movie::default()]);
+
+      LibraryHandler::with(
+        &DEFAULT_KEYBINDINGS.update.key,
+        &mut app,
+        &ActiveRadarrBlock::Movies,
+        &None,
+      )
+      .handle();
+
+      assert_eq!(app.get_current_route(), &ActiveRadarrBlock::Movies.into());
+    }
+
     #[test]
     fn test_refresh_movies_key() {
-      assert_refresh_key!(LibraryHandler, ActiveRadarrBlock::Movies);
+      let mut app = App::default();
+      app
+        .data
+        .radarr_data
+        .movies
+        .set_items(vec![Movie::default()]);
+      app.push_navigation_stack(ActiveRadarrBlock::Movies.into());
+
+      LibraryHandler::with(
+        &DEFAULT_KEYBINDINGS.refresh.key,
+        &mut app,
+        &ActiveRadarrBlock::Movies,
+        &None,
+      )
+      .handle();
+
+      assert_eq!(app.get_current_route(), &ActiveRadarrBlock::Movies.into());
+      assert!(app.should_refresh);
+    }
+
+    #[test]
+    fn test_refresh_movies_key_no_op_when_not_ready() {
+      let mut app = App::default();
+      app.is_loading = true;
+      app
+        .data
+        .radarr_data
+        .movies
+        .set_items(vec![Movie::default()]);
+      app.push_navigation_stack(ActiveRadarrBlock::Movies.into());
+
+      LibraryHandler::with(
+        &DEFAULT_KEYBINDINGS.refresh.key,
+        &mut app,
+        &ActiveRadarrBlock::Movies,
+        &None,
+      )
+      .handle();
+
+      assert_eq!(app.get_current_route(), &ActiveRadarrBlock::Movies.into());
+      assert!(!app.should_refresh);
     }
 
     #[test]
     fn test_search_movies_box_backspace_key() {
       let mut app = App::default();
       app.data.radarr_data.movies.search = Some("Test".into());
+      app
+        .data
+        .radarr_data
+        .movies
+        .set_items(vec![Movie::default()]);
 
       LibraryHandler::with(
         &DEFAULT_KEYBINDINGS.backspace.key,
@@ -984,7 +1332,11 @@ mod tests {
     #[test]
     fn test_filter_movies_box_backspace_key() {
       let mut app = App::default();
-      app.data.radarr_data.movies = StatefulTable::default();
+      app
+        .data
+        .radarr_data
+        .movies
+        .set_items(vec![Movie::default()]);
       app.data.radarr_data.movies.filter = Some("Test".into());
 
       LibraryHandler::with(
@@ -1004,6 +1356,11 @@ mod tests {
     #[test]
     fn test_search_movies_box_char_key() {
       let mut app = App::default();
+      app
+        .data
+        .radarr_data
+        .movies
+        .set_items(vec![Movie::default()]);
       app.data.radarr_data.movies.search = Some(HorizontallyScrollableText::default());
 
       LibraryHandler::with(
@@ -1023,7 +1380,11 @@ mod tests {
     #[test]
     fn test_filter_movies_box_char_key() {
       let mut app = App::default();
-      app.data.radarr_data.movies = StatefulTable::default();
+      app
+        .data
+        .radarr_data
+        .movies
+        .set_items(vec![Movie::default()]);
       app.data.radarr_data.movies.filter = Some(HorizontallyScrollableText::default());
 
       LibraryHandler::with(
@@ -1043,6 +1404,11 @@ mod tests {
     #[test]
     fn test_sort_key() {
       let mut app = App::default();
+      app
+        .data
+        .radarr_data
+        .movies
+        .set_items(vec![Movie::default()]);
 
       LibraryHandler::with(
         &DEFAULT_KEYBINDINGS.sort.key,
@@ -1062,6 +1428,29 @@ mod tests {
       );
       assert!(!app.data.radarr_data.movies.sort_asc);
     }
+
+    #[test]
+    fn test_sort_key_no_op_when_not_ready() {
+      let mut app = App::default();
+      app.is_loading = true;
+      app.push_navigation_stack(ActiveRadarrBlock::Movies.into());
+      app
+        .data
+        .radarr_data
+        .movies
+        .set_items(vec![Movie::default()]);
+
+      LibraryHandler::with(
+        &DEFAULT_KEYBINDINGS.sort.key,
+        &mut app,
+        &ActiveRadarrBlock::Movies,
+        &None,
+      )
+      .handle();
+
+      assert_eq!(app.get_current_route(), &ActiveRadarrBlock::Movies.into());
+      assert!(app.data.radarr_data.movies.sort.is_none());
+    }
   }
 
   #[rstest]
@@ -1314,6 +1703,74 @@ mod tests {
     assert_str_eq!(sort_option.name, "Tags");
   }
 
+  #[test]
+  fn test_library_handler_accepts() {
+    let mut library_handler_blocks = Vec::new();
+    library_handler_blocks.extend(LIBRARY_BLOCKS);
+    library_handler_blocks.extend(ADD_MOVIE_BLOCKS);
+    library_handler_blocks.extend(DELETE_MOVIE_BLOCKS);
+    library_handler_blocks.extend(EDIT_MOVIE_BLOCKS);
+    library_handler_blocks.extend(MOVIE_DETAILS_BLOCKS);
+
+    ActiveRadarrBlock::iter().for_each(|active_radarr_block| {
+      if library_handler_blocks.contains(&active_radarr_block) {
+        assert!(LibraryHandler::accepts(&active_radarr_block));
+      } else {
+        assert!(!LibraryHandler::accepts(&active_radarr_block));
+      }
+    });
+  }
+
+  #[test]
+  fn test_library_handler_not_ready_when_loading() {
+    let mut app = App::default();
+    app.is_loading = true;
+
+    let handler = LibraryHandler::with(
+      &DEFAULT_KEYBINDINGS.esc.key,
+      &mut app,
+      &ActiveRadarrBlock::Movies,
+      &None,
+    );
+
+    assert!(!handler.is_ready());
+  }
+
+  #[test]
+  fn test_library_handler_not_ready_when_movies_is_empty() {
+    let mut app = App::default();
+    app.is_loading = false;
+
+    let handler = LibraryHandler::with(
+      &DEFAULT_KEYBINDINGS.esc.key,
+      &mut app,
+      &ActiveRadarrBlock::Movies,
+      &None,
+    );
+
+    assert!(!handler.is_ready());
+  }
+
+  #[test]
+  fn test_library_handler_ready_when_not_loading_and_movies_is_not_empty() {
+    let mut app = App::default();
+    app.is_loading = false;
+    app
+      .data
+      .radarr_data
+      .movies
+      .set_items(vec![Movie::default()]);
+
+    let handler = LibraryHandler::with(
+      &DEFAULT_KEYBINDINGS.esc.key,
+      &mut app,
+      &ActiveRadarrBlock::Movies,
+      &None,
+    );
+
+    assert!(handler.is_ready());
+  }
+
   fn movies_vec() -> Vec<Movie> {
     vec![
       Movie {
@@ -1378,22 +1835,4 @@ mod tests {
       }),
     }]
   }
-
-  #[test]
-  fn test_library_handler_accepts() {
-    let mut library_handler_blocks = Vec::new();
-    library_handler_blocks.extend(LIBRARY_BLOCKS);
-    library_handler_blocks.extend(ADD_MOVIE_BLOCKS);
-    library_handler_blocks.extend(DELETE_MOVIE_BLOCKS);
-    library_handler_blocks.extend(EDIT_MOVIE_BLOCKS);
-    library_handler_blocks.extend(MOVIE_DETAILS_BLOCKS);
-
-    ActiveRadarrBlock::iter().for_each(|active_radarr_block| {
-      if library_handler_blocks.contains(&active_radarr_block) {
-        assert!(LibraryHandler::accepts(&active_radarr_block));
-      } else {
-        assert!(!LibraryHandler::accepts(&active_radarr_block));
-      }
-    });
-  }
 }

src/handlers/radarr_handlers/library/mod.rs

@@ -80,6 +80,10 @@ impl<'a, 'b> KeyEventHandler<'a, 'b, ActiveRadarrBlock> for LibraryHandler<'a, '
     self.key
   }
 
+  fn is_ready(&self) -> bool {
+    !self.app.is_loading && !self.app.data.radarr_data.movies.is_empty()
+  }
+
   fn handle_scroll_up(&mut self) {
     match self.active_radarr_block {
       ActiveRadarrBlock::Movies => self.app.data.radarr_data.movies.scroll_up(),

src/handlers/radarr_handlers/library/movie_details_handler.rs

@@ -46,6 +46,21 @@ impl<'a, 'b> KeyEventHandler<'a, 'b, ActiveRadarrBlock> for MovieDetailsHandler<
     self.key
   }
 
+  fn is_ready(&self) -> bool {
+    let movie_details_modal_is_ready =
+      if let Some(movie_details_modal) = &self.app.data.radarr_data.movie_details_modal {
+        !movie_details_modal.movie_details.is_empty()
+          || !movie_details_modal.movie_history.is_empty()
+          || !movie_details_modal.movie_cast.is_empty()
+          || !movie_details_modal.movie_crew.is_empty()
+          || !movie_details_modal.movie_releases.is_empty()
+      } else {
+        false
+      };
+
+    !self.app.is_loading && movie_details_modal_is_ready
+  }
+
   fn handle_scroll_up(&mut self) {
     match self.active_radarr_block {
       ActiveRadarrBlock::MovieDetails => self