Added tests for models

src/app/radarr.rs

@@ -496,543 +496,543 @@ pub mod radarr_test_utils {
   }
 }
 
-#[cfg(test)]
-mod radarr_data_tests {
-  use pretty_assertions::assert_eq;
-
-  use crate::app::radarr::radarr_test_utils::create_test_radarr_data;
-
-  #[test]
-  fn test_reset_movie_collection_table() {
-    let mut radarr_data = create_test_radarr_data();
-
-    radarr_data.reset_movie_collection_table();
-
-    assert_movie_collection_table_reset!(radarr_data);
-  }
-
-  #[test]
-  fn test_reset_search() {
-    let mut radarr_data = create_test_radarr_data();
-
-    radarr_data.reset_search();
-
-    assert_search_reset!(radarr_data);
-  }
-
-  #[test]
-  fn test_reset_movie_info_tabs() {
-    let mut radarr_data = create_test_radarr_data();
-
-    radarr_data.reset_movie_info_tabs();
-
-    assert_movie_info_tabs_reset!(radarr_data);
-  }
-
-  #[test]
-  fn test_reset_add_movie_selections() {
-    let mut radarr_data = create_test_radarr_data();
-
-    radarr_data.reset_add_movie_selections();
-
-    assert_add_movie_selections_reset!(radarr_data);
-  }
-}
-
-#[cfg(test)]
-mod active_radarr_block_tests {
-  use pretty_assertions::assert_eq;
-
-  use crate::app::radarr::ActiveRadarrBlock;
-
-  #[test]
-  fn test_next_add_prompt_block() {
-    let active_block = ActiveRadarrBlock::AddMovieSelectMonitor.next_add_prompt_block();
-
-    assert_eq!(
-      active_block,
-      ActiveRadarrBlock::AddMovieSelectMinimumAvailability
-    );
-
-    let active_block = active_block.next_add_prompt_block();
-
-    assert_eq!(
-      active_block,
-      ActiveRadarrBlock::AddMovieSelectQualityProfile
-    );
-
-    let active_block = active_block.next_add_prompt_block();
-
-    assert_eq!(active_block, ActiveRadarrBlock::AddMovieConfirmPrompt);
-
-    let active_block = active_block.next_add_prompt_block();
-
-    assert_eq!(active_block, ActiveRadarrBlock::AddMovieSelectMonitor);
-  }
-
-  #[test]
-  fn test_previous_add_prompt_block() {
-    let active_block = ActiveRadarrBlock::AddMovieSelectMonitor.previous_add_prompt_block();
-
-    assert_eq!(active_block, ActiveRadarrBlock::AddMovieConfirmPrompt);
-
-    let active_block = active_block.previous_add_prompt_block();
-
-    assert_eq!(
-      active_block,
-      ActiveRadarrBlock::AddMovieSelectQualityProfile
-    );
-
-    let active_block = active_block.previous_add_prompt_block();
-
-    assert_eq!(
-      active_block,
-      ActiveRadarrBlock::AddMovieSelectMinimumAvailability
-    );
-
-    let active_block = active_block.previous_add_prompt_block();
-
-    assert_eq!(active_block, ActiveRadarrBlock::AddMovieSelectMonitor);
-  }
-}
-
 #[cfg(test)]
 mod tests {
-  use std::time::Duration;
+  mod radarr_data_tests {
+    use pretty_assertions::assert_eq;
 
-  use pretty_assertions::assert_eq;
+    use crate::app::radarr::radarr_test_utils::create_test_radarr_data;
-  use tokio::sync::mpsc;
 
-  use crate::app::radarr::ActiveRadarrBlock;
+    #[test]
-  use crate::app::App;
+    fn test_reset_movie_collection_table() {
-  use crate::models::radarr_models::{Collection, CollectionMovie, Credit, Release};
+      let mut radarr_data = create_test_radarr_data();
-  use crate::models::StatefulTable;
-  use crate::network::radarr_network::RadarrEvent;
-  use crate::network::NetworkEvent;
 
-  #[tokio::test]
+      radarr_data.reset_movie_collection_table();
-  async fn test_dispatch_by_collections_block() {
-    let (mut app, mut sync_network_rx) = construct_app_unit();
 
-    app
+      assert_movie_collection_table_reset!(radarr_data);
-      .dispatch_by_radarr_block(&ActiveRadarrBlock::Collections)
+    }
-      .await;
 
-    assert!(app.is_loading);
+    #[test]
-    assert_eq!(
+    fn test_reset_search() {
-      sync_network_rx.recv().await.unwrap(),
+      let mut radarr_data = create_test_radarr_data();
-      RadarrEvent::GetCollections.into()
+
-    );
+      radarr_data.reset_search();
-    assert!(!app.data.radarr_data.prompt_confirm);
+
-    assert_eq!(app.tick_count, 0);
+      assert_search_reset!(radarr_data);
+    }
+
+    #[test]
+    fn test_reset_movie_info_tabs() {
+      let mut radarr_data = create_test_radarr_data();
+
+      radarr_data.reset_movie_info_tabs();
+
+      assert_movie_info_tabs_reset!(radarr_data);
+    }
+
+    #[test]
+    fn test_reset_add_movie_selections() {
+      let mut radarr_data = create_test_radarr_data();
+
+      radarr_data.reset_add_movie_selections();
+
+      assert_add_movie_selections_reset!(radarr_data);
+    }
   }
 
-  #[tokio::test]
+  mod active_radarr_block_tests {
-  async fn test_dispatch_by_collection_details_block() {
+    use pretty_assertions::assert_eq;
-    let mut app = App::default();
 
-    app.data.radarr_data.collections.set_items(vec![Collection {
+    use crate::app::radarr::ActiveRadarrBlock;
-      movies: Some(vec![CollectionMovie::default()]),
-      ..Collection::default()
-    }]);
 
-    app
+    #[test]
-      .dispatch_by_radarr_block(&ActiveRadarrBlock::CollectionDetails)
+    fn test_next_add_prompt_block() {
-      .await;
+      let active_block = ActiveRadarrBlock::AddMovieSelectMonitor.next_add_prompt_block();
 
-    assert!(!app.is_loading);
+      assert_eq!(
-    assert!(!app.data.radarr_data.collection_movies.items.is_empty());
+        active_block,
-    assert_eq!(app.tick_count, 0);
+        ActiveRadarrBlock::AddMovieSelectMinimumAvailability
+      );
+
+      let active_block = active_block.next_add_prompt_block();
+
+      assert_eq!(
+        active_block,
+        ActiveRadarrBlock::AddMovieSelectQualityProfile
+      );
+
+      let active_block = active_block.next_add_prompt_block();
+
+      assert_eq!(active_block, ActiveRadarrBlock::AddMovieConfirmPrompt);
+
+      let active_block = active_block.next_add_prompt_block();
+
+      assert_eq!(active_block, ActiveRadarrBlock::AddMovieSelectMonitor);
+    }
+
+    #[test]
+    fn test_previous_add_prompt_block() {
+      let active_block = ActiveRadarrBlock::AddMovieSelectMonitor.previous_add_prompt_block();
+
+      assert_eq!(active_block, ActiveRadarrBlock::AddMovieConfirmPrompt);
+
+      let active_block = active_block.previous_add_prompt_block();
+
+      assert_eq!(
+        active_block,
+        ActiveRadarrBlock::AddMovieSelectQualityProfile
+      );
+
+      let active_block = active_block.previous_add_prompt_block();
+
+      assert_eq!(
+        active_block,
+        ActiveRadarrBlock::AddMovieSelectMinimumAvailability
+      );
+
+      let active_block = active_block.previous_add_prompt_block();
+
+      assert_eq!(active_block, ActiveRadarrBlock::AddMovieSelectMonitor);
+    }
   }
 
-  #[tokio::test]
+  mod radarr_tests {
-  async fn test_dispatch_by_downloads_block() {
+    use std::time::Duration;
-    let (mut app, mut sync_network_rx) = construct_app_unit();
 
-    app
+    use pretty_assertions::assert_eq;
-      .dispatch_by_radarr_block(&ActiveRadarrBlock::Downloads)
+    use tokio::sync::mpsc;
-      .await;
 
-    assert!(app.is_loading);
+    use crate::app::radarr::ActiveRadarrBlock;
-    assert_eq!(
+    use crate::app::App;
-      sync_network_rx.recv().await.unwrap(),
+    use crate::models::radarr_models::{Collection, CollectionMovie, Credit, Release};
-      RadarrEvent::GetDownloads.into()
+    use crate::models::StatefulTable;
-    );
+    use crate::network::radarr_network::RadarrEvent;
-    assert!(!app.data.radarr_data.prompt_confirm);
+    use crate::network::NetworkEvent;
-    assert_eq!(app.tick_count, 0);
-  }
 
-  #[tokio::test]
+    #[tokio::test]
-  async fn test_dispatch_by_movies_block() {
+    async fn test_dispatch_by_collections_block() {
-    let (mut app, mut sync_network_rx) = construct_app_unit();
+      let (mut app, mut sync_network_rx) = construct_app_unit();
 
-    app
+      app
-      .dispatch_by_radarr_block(&ActiveRadarrBlock::Movies)
+        .dispatch_by_radarr_block(&ActiveRadarrBlock::Collections)
-      .await;
+        .await;
-
-    assert!(!app.is_loading);
-    assert_eq!(
-      sync_network_rx.recv().await.unwrap(),
-      RadarrEvent::GetMovies.into()
-    );
-    assert_eq!(
-      sync_network_rx.recv().await.unwrap(),
-      RadarrEvent::GetDownloads.into()
-    );
-    assert!(!app.data.radarr_data.prompt_confirm);
-    assert_eq!(app.tick_count, 0);
-  }
-
-  #[tokio::test]
-  async fn test_dispatch_by_add_movie_search_results_block() {
-    let (mut app, mut sync_network_rx) = construct_app_unit();
-
-    app
-      .dispatch_by_radarr_block(&ActiveRadarrBlock::AddMovieSearchResults)
-      .await;
-
-    assert!(app.is_loading);
-    assert_eq!(
-      sync_network_rx.recv().await.unwrap(),
-      RadarrEvent::SearchNewMovie.into()
-    );
-    assert!(!app.data.radarr_data.prompt_confirm);
-    assert_eq!(app.tick_count, 0);
-  }
-
-  #[tokio::test]
-  async fn test_dispatch_by_movie_details_block() {
-    let (mut app, mut sync_network_rx) = construct_app_unit();
-
-    app
-      .dispatch_by_radarr_block(&ActiveRadarrBlock::MovieDetails)
-      .await;
-
-    assert!(app.is_loading);
-    assert_eq!(
-      sync_network_rx.recv().await.unwrap(),
-      RadarrEvent::GetMovieDetails.into()
-    );
-    assert!(!app.data.radarr_data.prompt_confirm);
-    assert_eq!(app.tick_count, 0);
-  }
-
-  #[tokio::test]
-  async fn test_dispatch_by_file_info_block() {
-    let (mut app, mut sync_network_rx) = construct_app_unit();
-
-    app
-      .dispatch_by_radarr_block(&ActiveRadarrBlock::FileInfo)
-      .await;
-
-    assert!(app.is_loading);
-    assert_eq!(
-      sync_network_rx.recv().await.unwrap(),
-      RadarrEvent::GetMovieDetails.into()
-    );
-    assert!(!app.data.radarr_data.prompt_confirm);
-    assert_eq!(app.tick_count, 0);
-  }
-
-  #[tokio::test]
-  async fn test_dispatch_by_movie_history_block() {
-    let (mut app, mut sync_network_rx) = construct_app_unit();
-
-    app
-      .dispatch_by_radarr_block(&ActiveRadarrBlock::MovieHistory)
-      .await;
-
-    assert!(app.is_loading);
-    assert_eq!(
-      sync_network_rx.recv().await.unwrap(),
-      RadarrEvent::GetMovieHistory.into()
-    );
-    assert!(!app.data.radarr_data.prompt_confirm);
-    assert_eq!(app.tick_count, 0);
-  }
-
-  #[tokio::test]
-  async fn test_dispatch_by_cast_crew_blocks() {
-    let (mut app, mut sync_network_rx) = construct_app_unit();
-
-    for active_radarr_block in &[ActiveRadarrBlock::Cast, ActiveRadarrBlock::Crew] {
-      app.data.radarr_data.movie_cast = StatefulTable::default();
-      app.data.radarr_data.movie_crew = StatefulTable::default();
-
-      app.dispatch_by_radarr_block(active_radarr_block).await;
 
       assert!(app.is_loading);
       assert_eq!(
         sync_network_rx.recv().await.unwrap(),
-        RadarrEvent::GetMovieCredits.into()
+        RadarrEvent::GetCollections.into()
       );
       assert!(!app.data.radarr_data.prompt_confirm);
       assert_eq!(app.tick_count, 0);
     }
-  }
 
-  #[tokio::test]
+    #[tokio::test]
-  async fn test_dispatch_by_cast_crew_blocks_movie_cast_non_empty() {
+    async fn test_dispatch_by_collection_details_block() {
-    let (mut app, mut sync_network_rx) = construct_app_unit();
+      let mut app = App::default();
+
+      app.data.radarr_data.collections.set_items(vec![Collection {
+        movies: Some(vec![CollectionMovie::default()]),
+        ..Collection::default()
+      }]);
 
-    for active_radarr_block in &[ActiveRadarrBlock::Cast, ActiveRadarrBlock::Crew] {
       app
-        .data
+        .dispatch_by_radarr_block(&ActiveRadarrBlock::CollectionDetails)
-        .radarr_data
+        .await;
-        .movie_cast
-        .set_items(vec![Credit::default()]);
 
-      app.dispatch_by_radarr_block(active_radarr_block).await;
+      assert!(!app.is_loading);
+      assert!(!app.data.radarr_data.collection_movies.items.is_empty());
+      assert_eq!(app.tick_count, 0);
+    }
+
+    #[tokio::test]
+    async fn test_dispatch_by_downloads_block() {
+      let (mut app, mut sync_network_rx) = construct_app_unit();
+
+      app
+        .dispatch_by_radarr_block(&ActiveRadarrBlock::Downloads)
+        .await;
 
       assert!(app.is_loading);
       assert_eq!(
         sync_network_rx.recv().await.unwrap(),
-        RadarrEvent::GetMovieCredits.into()
+        RadarrEvent::GetDownloads.into()
       );
       assert!(!app.data.radarr_data.prompt_confirm);
       assert_eq!(app.tick_count, 0);
     }
-  }
 
-  #[tokio::test]
+    #[tokio::test]
-  async fn test_dispatch_by_cast_crew_blocks_movie_crew_non_empty() {
+    async fn test_dispatch_by_movies_block() {
-    let (mut app, mut sync_network_rx) = construct_app_unit();
+      let (mut app, mut sync_network_rx) = construct_app_unit();
 
-    for active_radarr_block in &[ActiveRadarrBlock::Cast, ActiveRadarrBlock::Crew] {
       app
-        .data
+        .dispatch_by_radarr_block(&ActiveRadarrBlock::Movies)
-        .radarr_data
+        .await;
-        .movie_crew
-        .set_items(vec![Credit::default()]);
 
-      app.dispatch_by_radarr_block(active_radarr_block).await;
+      assert!(!app.is_loading);
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        RadarrEvent::GetMovies.into()
+      );
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        RadarrEvent::GetDownloads.into()
+      );
+      assert!(!app.data.radarr_data.prompt_confirm);
+      assert_eq!(app.tick_count, 0);
+    }
+
+    #[tokio::test]
+    async fn test_dispatch_by_add_movie_search_results_block() {
+      let (mut app, mut sync_network_rx) = construct_app_unit();
+
+      app
+        .dispatch_by_radarr_block(&ActiveRadarrBlock::AddMovieSearchResults)
+        .await;
 
       assert!(app.is_loading);
       assert_eq!(
         sync_network_rx.recv().await.unwrap(),
-        RadarrEvent::GetMovieCredits.into()
+        RadarrEvent::SearchNewMovie.into()
       );
       assert!(!app.data.radarr_data.prompt_confirm);
       assert_eq!(app.tick_count, 0);
     }
-  }
 
-  #[tokio::test]
+    #[tokio::test]
-  async fn test_dispatch_by_cast_crew_blocks_cast_and_crew_non_empty() {
+    async fn test_dispatch_by_movie_details_block() {
-    let mut app = App::default();
+      let (mut app, mut sync_network_rx) = construct_app_unit();
 
-    for active_radarr_block in &[ActiveRadarrBlock::Cast, ActiveRadarrBlock::Crew] {
+      app
+        .dispatch_by_radarr_block(&ActiveRadarrBlock::MovieDetails)
+        .await;
+
+      assert!(app.is_loading);
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        RadarrEvent::GetMovieDetails.into()
+      );
+      assert!(!app.data.radarr_data.prompt_confirm);
+      assert_eq!(app.tick_count, 0);
+    }
+
+    #[tokio::test]
+    async fn test_dispatch_by_file_info_block() {
+      let (mut app, mut sync_network_rx) = construct_app_unit();
+
+      app
+        .dispatch_by_radarr_block(&ActiveRadarrBlock::FileInfo)
+        .await;
+
+      assert!(app.is_loading);
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        RadarrEvent::GetMovieDetails.into()
+      );
+      assert!(!app.data.radarr_data.prompt_confirm);
+      assert_eq!(app.tick_count, 0);
+    }
+
+    #[tokio::test]
+    async fn test_dispatch_by_movie_history_block() {
+      let (mut app, mut sync_network_rx) = construct_app_unit();
+
+      app
+        .dispatch_by_radarr_block(&ActiveRadarrBlock::MovieHistory)
+        .await;
+
+      assert!(app.is_loading);
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        RadarrEvent::GetMovieHistory.into()
+      );
+      assert!(!app.data.radarr_data.prompt_confirm);
+      assert_eq!(app.tick_count, 0);
+    }
+
+    #[tokio::test]
+    async fn test_dispatch_by_cast_crew_blocks() {
+      let (mut app, mut sync_network_rx) = construct_app_unit();
+
+      for active_radarr_block in &[ActiveRadarrBlock::Cast, ActiveRadarrBlock::Crew] {
+        app.data.radarr_data.movie_cast = StatefulTable::default();
+        app.data.radarr_data.movie_crew = StatefulTable::default();
+
+        app.dispatch_by_radarr_block(active_radarr_block).await;
+
+        assert!(app.is_loading);
+        assert_eq!(
+          sync_network_rx.recv().await.unwrap(),
+          RadarrEvent::GetMovieCredits.into()
+        );
+        assert!(!app.data.radarr_data.prompt_confirm);
+        assert_eq!(app.tick_count, 0);
+      }
+    }
+
+    #[tokio::test]
+    async fn test_dispatch_by_cast_crew_blocks_movie_cast_non_empty() {
+      let (mut app, mut sync_network_rx) = construct_app_unit();
+
+      for active_radarr_block in &[ActiveRadarrBlock::Cast, ActiveRadarrBlock::Crew] {
+        app
+          .data
+          .radarr_data
+          .movie_cast
+          .set_items(vec![Credit::default()]);
+
+        app.dispatch_by_radarr_block(active_radarr_block).await;
+
+        assert!(app.is_loading);
+        assert_eq!(
+          sync_network_rx.recv().await.unwrap(),
+          RadarrEvent::GetMovieCredits.into()
+        );
+        assert!(!app.data.radarr_data.prompt_confirm);
+        assert_eq!(app.tick_count, 0);
+      }
+    }
+
+    #[tokio::test]
+    async fn test_dispatch_by_cast_crew_blocks_movie_crew_non_empty() {
+      let (mut app, mut sync_network_rx) = construct_app_unit();
+
+      for active_radarr_block in &[ActiveRadarrBlock::Cast, ActiveRadarrBlock::Crew] {
+        app
+          .data
+          .radarr_data
+          .movie_crew
+          .set_items(vec![Credit::default()]);
+
+        app.dispatch_by_radarr_block(active_radarr_block).await;
+
+        assert!(app.is_loading);
+        assert_eq!(
+          sync_network_rx.recv().await.unwrap(),
+          RadarrEvent::GetMovieCredits.into()
+        );
+        assert!(!app.data.radarr_data.prompt_confirm);
+        assert_eq!(app.tick_count, 0);
+      }
+    }
+
+    #[tokio::test]
+    async fn test_dispatch_by_cast_crew_blocks_cast_and_crew_non_empty() {
+      let mut app = App::default();
+
+      for active_radarr_block in &[ActiveRadarrBlock::Cast, ActiveRadarrBlock::Crew] {
+        app
+          .data
+          .radarr_data
+          .movie_cast
+          .set_items(vec![Credit::default()]);
+        app
+          .data
+          .radarr_data
+          .movie_crew
+          .set_items(vec![Credit::default()]);
+
+        app.dispatch_by_radarr_block(active_radarr_block).await;
+
+        assert!(!app.is_loading);
+        assert!(!app.data.radarr_data.prompt_confirm);
+        assert_eq!(app.tick_count, 0);
+      }
+    }
+
+    #[tokio::test]
+    async fn test_dispatch_by_manual_search_block() {
+      let (mut app, mut sync_network_rx) = construct_app_unit();
+
+      app
+        .dispatch_by_radarr_block(&ActiveRadarrBlock::ManualSearch)
+        .await;
+
+      assert!(app.is_loading);
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        RadarrEvent::GetReleases.into()
+      );
+      assert!(!app.data.radarr_data.prompt_confirm);
+      assert_eq!(app.tick_count, 0);
+    }
+
+    #[tokio::test]
+    async fn test_dispatch_by_manual_search_block_movie_releases_non_empty() {
+      let mut app = App::default();
       app
         .data
         .radarr_data
-        .movie_cast
+        .movie_releases
-        .set_items(vec![Credit::default()]);
+        .set_items(vec![Release::default()]);
-      app
-        .data
-        .radarr_data
-        .movie_crew
-        .set_items(vec![Credit::default()]);
 
-      app.dispatch_by_radarr_block(active_radarr_block).await;
+      app
+        .dispatch_by_radarr_block(&ActiveRadarrBlock::ManualSearch)
+        .await;
 
       assert!(!app.is_loading);
       assert!(!app.data.radarr_data.prompt_confirm);
       assert_eq!(app.tick_count, 0);
     }
-  }
 
-  #[tokio::test]
+    #[tokio::test]
-  async fn test_dispatch_by_manual_search_block() {
+    async fn test_dispatch_by_manual_search_block_is_loading() {
-    let (mut app, mut sync_network_rx) = construct_app_unit();
+      let mut app = App {
+        is_loading: true,
+        ..App::default()
+      };
 
-    app
+      app
-      .dispatch_by_radarr_block(&ActiveRadarrBlock::ManualSearch)
+        .dispatch_by_radarr_block(&ActiveRadarrBlock::ManualSearch)
-      .await;
+        .await;
 
-    assert!(app.is_loading);
+      assert!(app.is_loading);
-    assert_eq!(
+      assert!(!app.data.radarr_data.prompt_confirm);
-      sync_network_rx.recv().await.unwrap(),
+      assert_eq!(app.tick_count, 0);
-      RadarrEvent::GetReleases.into()
+    }
-    );
-    assert!(!app.data.radarr_data.prompt_confirm);
-    assert_eq!(app.tick_count, 0);
-  }
 
-  #[tokio::test]
+    #[tokio::test]
-  async fn test_dispatch_by_manual_search_block_movie_releases_non_empty() {
+    async fn test_check_for_prompt_action_no_prompt_confirm() {
-    let mut app = App::default();
+      let mut app = App::default();
-    app
+      app.data.radarr_data.prompt_confirm = false;
-      .data
-      .radarr_data
-      .movie_releases
-      .set_items(vec![Release::default()]);
 
-    app
+      app.check_for_prompt_action().await;
-      .dispatch_by_radarr_block(&ActiveRadarrBlock::ManualSearch)
-      .await;
 
-    assert!(!app.is_loading);
+      assert!(!app.data.radarr_data.prompt_confirm);
-    assert!(!app.data.radarr_data.prompt_confirm);
+      assert!(!app.should_refresh);
-    assert_eq!(app.tick_count, 0);
+    }
-  }
 
-  #[tokio::test]
+    #[tokio::test]
-  async fn test_dispatch_by_manual_search_block_is_loading() {
+    async fn test_check_for_prompt_action() {
-    let mut app = App {
+      let (mut app, mut sync_network_rx) = construct_app_unit();
-      is_loading: true,
+      app.data.radarr_data.prompt_confirm_action = Some(RadarrEvent::GetStatus);
-      ..App::default()
-    };
 
-    app
+      app.check_for_prompt_action().await;
-      .dispatch_by_radarr_block(&ActiveRadarrBlock::ManualSearch)
-      .await;
 
-    assert!(app.is_loading);
+      assert!(!app.data.radarr_data.prompt_confirm);
-    assert!(!app.data.radarr_data.prompt_confirm);
+      assert_eq!(
-    assert_eq!(app.tick_count, 0);
+        sync_network_rx.recv().await.unwrap(),
-  }
+        RadarrEvent::GetStatus.into()
+      );
+      assert!(app.should_refresh);
+      assert_eq!(app.data.radarr_data.prompt_confirm_action, None);
+    }
 
-  #[tokio::test]
+    #[tokio::test]
-  async fn test_check_for_prompt_action_no_prompt_confirm() {
+    async fn test_radarr_on_tick_first_render() {
-    let mut app = App::default();
+      let (mut app, mut sync_network_rx) = construct_app_unit();
-    app.data.radarr_data.prompt_confirm = false;
 
-    app.check_for_prompt_action().await;
+      app.radarr_on_tick(ActiveRadarrBlock::Downloads, true).await;
 
-    assert!(!app.data.radarr_data.prompt_confirm);
+      assert_eq!(
-    assert!(!app.should_refresh);
+        sync_network_rx.recv().await.unwrap(),
-  }
+        RadarrEvent::GetQualityProfiles.into()
+      );
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        RadarrEvent::GetRootFolders.into()
+      );
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        RadarrEvent::GetOverview.into()
+      );
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        RadarrEvent::GetStatus.into()
+      );
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        RadarrEvent::GetDownloads.into()
+      );
+      assert!(app.is_loading);
+      assert!(!app.data.radarr_data.prompt_confirm);
+    }
 
-  #[tokio::test]
+    #[tokio::test]
-  async fn test_check_for_prompt_action() {
+    async fn test_radarr_on_tick_not_routing() {
-    let (mut app, mut sync_network_rx) = construct_app_unit();
+      let mut app = App::default();
-    app.data.radarr_data.prompt_confirm_action = Some(RadarrEvent::GetStatus);
 
-    app.check_for_prompt_action().await;
+      app
+        .radarr_on_tick(ActiveRadarrBlock::Downloads, false)
+        .await;
 
-    assert!(!app.data.radarr_data.prompt_confirm);
+      assert!(!app.is_routing);
-    assert_eq!(
+    }
-      sync_network_rx.recv().await.unwrap(),
-      RadarrEvent::GetStatus.into()
-    );
-    assert!(app.should_refresh);
-    assert_eq!(app.data.radarr_data.prompt_confirm_action, None);
-  }
 
-  #[tokio::test]
+    #[tokio::test]
-  async fn test_radarr_on_tick_first_render() {
+    async fn test_radarr_on_tick_routing() {
-    let (mut app, mut sync_network_rx) = construct_app_unit();
+      let (mut app, mut sync_network_rx) = construct_app_unit();
+      app.is_routing = true;
 
-    app.radarr_on_tick(ActiveRadarrBlock::Downloads, true).await;
+      app
+        .radarr_on_tick(ActiveRadarrBlock::Downloads, false)
+        .await;
 
-    assert_eq!(
+      assert_eq!(
-      sync_network_rx.recv().await.unwrap(),
+        sync_network_rx.recv().await.unwrap(),
-      RadarrEvent::GetQualityProfiles.into()
+        RadarrEvent::GetDownloads.into()
-    );
+      );
-    assert_eq!(
+      assert!(app.is_loading);
-      sync_network_rx.recv().await.unwrap(),
+      assert!(!app.data.radarr_data.prompt_confirm);
-      RadarrEvent::GetRootFolders.into()
+    }
-    );
-    assert_eq!(
-      sync_network_rx.recv().await.unwrap(),
-      RadarrEvent::GetOverview.into()
-    );
-    assert_eq!(
-      sync_network_rx.recv().await.unwrap(),
-      RadarrEvent::GetStatus.into()
-    );
-    assert_eq!(
-      sync_network_rx.recv().await.unwrap(),
-      RadarrEvent::GetDownloads.into()
-    );
-    assert!(app.is_loading);
-    assert!(!app.data.radarr_data.prompt_confirm);
-  }
 
-  #[tokio::test]
+    #[tokio::test]
-  async fn test_radarr_on_tick_not_routing() {
+    async fn test_radarr_on_tick_network_tick_frequency() {
-    let mut app = App::default();
+      let (mut app, mut sync_network_rx) = construct_app_unit();
+      app.network_tick_frequency = Duration::from_secs(0);
 
-    app
+      app
-      .radarr_on_tick(ActiveRadarrBlock::Downloads, false)
+        .radarr_on_tick(ActiveRadarrBlock::Downloads, false)
-      .await;
+        .await;
 
-    assert!(!app.is_routing);
+      assert_eq!(
-  }
+        sync_network_rx.recv().await.unwrap(),
+        RadarrEvent::GetDownloads.into()
+      );
+      assert!(app.is_loading);
+      assert!(!app.data.radarr_data.prompt_confirm);
+    }
 
-  #[tokio::test]
+    #[tokio::test]
-  async fn test_radarr_on_tick_routing() {
+    async fn test_populate_movie_collection_table_unfiltered() {
-    let (mut app, mut sync_network_rx) = construct_app_unit();
+      let mut app = App::default();
-    app.is_routing = true;
+      app.data.radarr_data.collections.set_items(vec![Collection {
-
-    app
-      .radarr_on_tick(ActiveRadarrBlock::Downloads, false)
-      .await;
-
-    assert_eq!(
-      sync_network_rx.recv().await.unwrap(),
-      RadarrEvent::GetDownloads.into()
-    );
-    assert!(app.is_loading);
-    assert!(!app.data.radarr_data.prompt_confirm);
-  }
-
-  #[tokio::test]
-  async fn test_radarr_on_tick_network_tick_frequency() {
-    let (mut app, mut sync_network_rx) = construct_app_unit();
-    app.network_tick_frequency = Duration::from_secs(0);
-
-    app
-      .radarr_on_tick(ActiveRadarrBlock::Downloads, false)
-      .await;
-
-    assert_eq!(
-      sync_network_rx.recv().await.unwrap(),
-      RadarrEvent::GetDownloads.into()
-    );
-    assert!(app.is_loading);
-    assert!(!app.data.radarr_data.prompt_confirm);
-  }
-
-  #[tokio::test]
-  async fn test_populate_movie_collection_table_unfiltered() {
-    let mut app = App::default();
-    app.data.radarr_data.collections.set_items(vec![Collection {
-      movies: Some(vec![CollectionMovie::default()]),
-      ..Collection::default()
-    }]);
-
-    app.populate_movie_collection_table().await;
-
-    assert!(!app.data.radarr_data.collection_movies.items.is_empty());
-  }
-
-  #[tokio::test]
-  async fn test_populate_movie_collection_table_filtered() {
-    let mut app = App::default();
-    app
-      .data
-      .radarr_data
-      .filtered_collections
-      .set_items(vec![Collection {
         movies: Some(vec![CollectionMovie::default()]),
         ..Collection::default()
       }]);
 
-    app.populate_movie_collection_table().await;
+      app.populate_movie_collection_table().await;
 
-    assert!(!app.data.radarr_data.collection_movies.items.is_empty());
+      assert!(!app.data.radarr_data.collection_movies.items.is_empty());
-  }
+    }
 
-  fn construct_app_unit() -> (App, mpsc::Receiver<NetworkEvent>) {
+    #[tokio::test]
-    let (sync_network_tx, sync_network_rx) = mpsc::channel::<NetworkEvent>(500);
+    async fn test_populate_movie_collection_table_filtered() {
-    let mut app = App {
+      let mut app = App::default();
-      network_tx: Some(sync_network_tx),
+      app
-      tick_count: 1,
+        .data
-      ..App::default()
+        .radarr_data
-    };
+        .filtered_collections
-    app.data.radarr_data.prompt_confirm = true;
+        .set_items(vec![Collection {
+          movies: Some(vec![CollectionMovie::default()]),
+          ..Collection::default()
+        }]);
 
-    (app, sync_network_rx)
+      app.populate_movie_collection_table().await;
+
+      assert!(!app.data.radarr_data.collection_movies.items.is_empty());
+    }
+
+    fn construct_app_unit() -> (App, mpsc::Receiver<NetworkEvent>) {
+      let (sync_network_tx, sync_network_rx) = mpsc::channel::<NetworkEvent>(500);
+      let mut app = App {
+        network_tx: Some(sync_network_tx),
+        tick_count: 1,
+        ..App::default()
+      };
+      app.data.radarr_data.prompt_confirm = true;
+
+      (app, sync_network_rx)
+    }
   }
 }

src/models/mod.rs

@@ -29,20 +29,12 @@ pub trait Scrollable {
 
 macro_rules! stateful_iterable {
   ($name:ident, $state:ty) => {
+    #[derive(Default)]
     pub struct $name<T> {
       pub state: $state,
       pub items: Vec<T>,
     }
 
-    impl<T> Default for $name<T> {
-      fn default() -> $name<T> {
-        $name {
-          state: <$state>::default(),
-          items: Vec::new(),
-        }
-      }
-    }
-
     impl<T> Scrollable for $name<T> {
       fn scroll_down(&mut self) {
         let selected_row = match self.state.selected() {
@@ -147,7 +139,7 @@ impl ScrollableText {
 
 impl Scrollable for ScrollableText {
   fn scroll_down(&mut self) {
-    if self.offset < self.items.len() as u16 {
+    if self.offset < (self.items.len() - 1) as u16 {
       self.offset += 1;
     }
   }
@@ -228,7 +220,7 @@ impl HorizontallyScrollableText {
   }
 }
 
-#[derive(Clone)]
+#[derive(Clone, PartialEq, Eq, Debug)]
 pub struct TabRoute {
   pub title: String,
   pub route: Route,
@@ -275,3 +267,392 @@ impl TabState {
     }
   }
 }
+
+#[cfg(test)]
+mod tests {
+  use std::cell::RefCell;
+
+  use pretty_assertions::{assert_eq, assert_str_eq};
+
+  use crate::app::radarr::ActiveRadarrBlock;
+  use crate::models::{
+    HorizontallyScrollableText, Scrollable, ScrollableText, StatefulTable, TabRoute, TabState,
+  };
+
+  #[test]
+  fn test_stateful_table_scroll() {
+    let mut stateful_table = create_test_stateful_table();
+
+    assert_eq!(stateful_table.state.selected(), Some(0));
+
+    stateful_table.scroll_down();
+
+    assert_eq!(stateful_table.state.selected(), Some(1));
+
+    stateful_table.scroll_down();
+
+    assert_eq!(stateful_table.state.selected(), Some(0));
+
+    stateful_table.scroll_up();
+
+    assert_eq!(stateful_table.state.selected(), Some(1));
+
+    stateful_table.scroll_up();
+
+    assert_eq!(stateful_table.state.selected(), Some(0));
+
+    stateful_table.scroll_to_bottom();
+
+    assert_eq!(stateful_table.state.selected(), Some(1));
+
+    stateful_table.scroll_to_top();
+
+    assert_eq!(stateful_table.state.selected(), Some(0));
+  }
+
+  #[test]
+  fn test_stateful_table_set_items() {
+    let items_vec = vec!["Test 1", "Test 2", "Test 3"];
+    let mut stateful_table: StatefulTable<&str> = StatefulTable::default();
+
+    stateful_table.set_items(items_vec.clone());
+
+    assert_eq!(stateful_table.state.selected(), Some(0));
+
+    stateful_table.state.select(Some(1));
+    stateful_table.set_items(items_vec.clone());
+
+    assert_eq!(stateful_table.state.selected(), Some(1));
+
+    stateful_table.state.select(Some(3));
+    stateful_table.set_items(items_vec);
+
+    assert_eq!(stateful_table.state.selected(), Some(2));
+  }
+
+  #[test]
+  fn test_stateful_table_current_selection() {
+    let mut stateful_table = create_test_stateful_table();
+
+    assert_str_eq!(stateful_table.current_selection(), &stateful_table.items[0]);
+
+    stateful_table.state.select(Some(1));
+
+    assert_str_eq!(stateful_table.current_selection(), &stateful_table.items[1]);
+  }
+
+  #[test]
+  fn test_stateful_table_current_selection_clone() {
+    let mut stateful_table = create_test_stateful_table();
+
+    assert_str_eq!(
+      stateful_table.current_selection_clone(),
+      stateful_table.items[0]
+    );
+
+    stateful_table.state.select(Some(1));
+
+    assert_str_eq!(
+      stateful_table.current_selection_clone(),
+      stateful_table.items[1]
+    );
+  }
+
+  #[test]
+  fn test_stateful_table_select_index() {
+    let mut stateful_table = create_test_stateful_table();
+
+    assert_eq!(stateful_table.state.selected(), Some(0));
+
+    stateful_table.select_index(Some(1));
+
+    assert_eq!(stateful_table.state.selected(), Some(1));
+
+    stateful_table.select_index(None);
+
+    assert_eq!(stateful_table.state.selected(), None);
+  }
+
+  #[test]
+  fn test_stateful_table_scroll_up() {
+    let mut stateful_table = create_test_stateful_table();
+
+    assert_eq!(stateful_table.state.selected(), Some(0));
+
+    stateful_table.scroll_up();
+
+    assert_eq!(stateful_table.state.selected(), Some(1));
+
+    stateful_table.scroll_up();
+
+    assert_eq!(stateful_table.state.selected(), Some(0));
+  }
+
+  #[test]
+  fn test_scrollable_text_with_string() {
+    let scrollable_text = ScrollableText::with_string("Test \n String \n".to_owned());
+
+    assert_eq!(scrollable_text.items.len(), 3);
+    assert_eq!(scrollable_text.items, vec!["Test ", " String ", ""]);
+    assert_eq!(scrollable_text.offset, 0);
+  }
+
+  #[test]
+  fn test_scrollable_text_get_text() {
+    let test_text = "Test \nString";
+    let scrollable_text = ScrollableText::with_string(test_text.to_owned());
+
+    assert_str_eq!(scrollable_text.get_text(), test_text);
+  }
+
+  #[test]
+  fn test_scrollable_text_scroll() {
+    let mut scrollable_text = ScrollableText::with_string("Test \nString".to_owned());
+
+    scrollable_text.scroll_down();
+
+    assert_eq!(scrollable_text.offset, 1);
+
+    scrollable_text.scroll_down();
+
+    assert_eq!(scrollable_text.offset, 1);
+
+    scrollable_text.scroll_up();
+
+    assert_eq!(scrollable_text.offset, 0);
+
+    scrollable_text.scroll_up();
+
+    assert_eq!(scrollable_text.offset, 0);
+
+    scrollable_text.scroll_to_bottom();
+
+    assert_eq!(scrollable_text.offset, 1);
+
+    scrollable_text.scroll_to_top();
+
+    assert_eq!(scrollable_text.offset, 0);
+  }
+
+  #[test]
+  fn test_horizontally_scrollable_text_from() {
+    let test_text = "Test string";
+    let horizontally_scrollable_text = HorizontallyScrollableText::from(test_text.to_owned());
+
+    assert_eq!(*horizontally_scrollable_text.offset.borrow(), 0);
+    assert_str_eq!(
+      horizontally_scrollable_text.text,
+      format!("{}        ", test_text)
+    );
+  }
+
+  #[test]
+  fn test_horizontally_scrollable_text_to_string() {
+    let test_text = "Test string";
+    let horizontally_scrollable_text = HorizontallyScrollableText::from(test_text.to_owned());
+
+    assert_str_eq!(
+      horizontally_scrollable_text.to_string(),
+      format!("{}        ", test_text)
+    );
+
+    let horizontally_scrollable_text = HorizontallyScrollableText {
+      text: test_text.to_owned(),
+      offset: RefCell::new(test_text.len() - 1),
+    };
+
+    assert_str_eq!(horizontally_scrollable_text.to_string(), "g");
+
+    let horizontally_scrollable_text = HorizontallyScrollableText {
+      text: test_text.to_owned(),
+      offset: RefCell::new(test_text.len()),
+    };
+
+    assert!(horizontally_scrollable_text.to_string().is_empty());
+  }
+
+  #[test]
+  fn test_horizontally_scrollable_text_new() {
+    let test_text = "Test string";
+    let horizontally_scrollable_text = HorizontallyScrollableText::new(test_text.to_owned());
+
+    assert_eq!(*horizontally_scrollable_text.offset.borrow(), 0);
+    assert_str_eq!(
+      horizontally_scrollable_text.text,
+      format!("{}        ", test_text)
+    );
+  }
+
+  #[test]
+  fn test_horizontally_scrollable_text_scroll_text() {
+    let horizontally_scrollable_text = HorizontallyScrollableText::from("Test string".to_owned());
+
+    assert_eq!(*horizontally_scrollable_text.offset.borrow(), 0);
+
+    for i in 1..horizontally_scrollable_text.text.len() {
+      horizontally_scrollable_text.scroll_text();
+
+      assert_eq!(*horizontally_scrollable_text.offset.borrow(), i);
+    }
+
+    horizontally_scrollable_text.scroll_text();
+
+    assert_eq!(*horizontally_scrollable_text.offset.borrow(), 0);
+  }
+
+  #[test]
+  fn test_horizontally_scrollable_text_reset_offset() {
+    let horizontally_scrollable_text = HorizontallyScrollableText {
+      text: "Test string".to_owned(),
+      offset: RefCell::new(1),
+    };
+
+    horizontally_scrollable_text.reset_offset();
+
+    assert_eq!(*horizontally_scrollable_text.offset.borrow(), 0);
+  }
+
+  #[test]
+  fn test_horizontally_scrollable_text_scroll_or_reset() {
+    let width = 3;
+    let test_text = "Test string";
+    let horizontally_scrollable_text = HorizontallyScrollableText::from(test_text.to_owned());
+
+    horizontally_scrollable_text.scroll_or_reset(width, true);
+
+    assert_eq!(*horizontally_scrollable_text.offset.borrow(), 1);
+
+    horizontally_scrollable_text.scroll_or_reset(width, false);
+
+    assert_eq!(*horizontally_scrollable_text.offset.borrow(), 0);
+
+    horizontally_scrollable_text.scroll_or_reset(width, true);
+
+    assert_eq!(*horizontally_scrollable_text.offset.borrow(), 1);
+
+    horizontally_scrollable_text.scroll_or_reset(test_text.len(), false);
+
+    assert_eq!(*horizontally_scrollable_text.offset.borrow(), 0);
+  }
+
+  #[test]
+  fn test_horizontally_scrollable_text_stationary_style() {
+    let test_text = "Test string";
+    let horizontally_scrollable_text = HorizontallyScrollableText::from(test_text.to_owned());
+
+    assert_eq!(horizontally_scrollable_text.stationary_style(), test_text);
+  }
+
+  #[test]
+  fn test_tab_state_new() {
+    let tab_state = TabState::new(create_test_tab_routes());
+
+    assert_eq!(tab_state.index, 0);
+  }
+
+  #[test]
+  fn test_tab_state_set_index() {
+    let mut tab_state = TabState::new(create_test_tab_routes());
+
+    let result = tab_state.set_index(1);
+
+    assert_eq!(result, &create_test_tab_routes()[1]);
+    assert_eq!(tab_state.index, 1);
+  }
+
+  #[test]
+  fn test_tab_state_get_active_route() {
+    let second_tab = create_test_tab_routes()[1].clone().route;
+    let tab_state = TabState {
+      tabs: create_test_tab_routes(),
+      index: 1,
+    };
+
+    let active_route = tab_state.get_active_route();
+
+    assert_eq!(active_route, &second_tab);
+  }
+
+  #[test]
+  fn test_tab_state_get_active_tab_help() {
+    let second_tab_help = create_test_tab_routes()[1].clone().help;
+    let tab_state = TabState {
+      tabs: create_test_tab_routes(),
+      index: 1,
+    };
+
+    let tab_help = tab_state.get_active_tab_help();
+
+    assert_str_eq!(tab_help, second_tab_help);
+  }
+
+  #[test]
+  fn test_tab_state_get_active_tab_contextual_help() {
+    let second_tab_contextual_help = create_test_tab_routes()[1].clone().contextual_help.unwrap();
+    let tab_state = TabState {
+      tabs: create_test_tab_routes(),
+      index: 1,
+    };
+
+    let tab_contextual_help = tab_state.get_active_tab_contextual_help();
+
+    assert!(tab_contextual_help.is_some());
+    assert_str_eq!(tab_contextual_help.unwrap(), second_tab_contextual_help);
+  }
+
+  #[test]
+  fn test_tab_state_next() {
+    let tab_routes = create_test_tab_routes();
+    let mut tab_state = TabState::new(create_test_tab_routes());
+
+    assert_eq!(tab_state.get_active_route(), &tab_routes[0].route);
+
+    tab_state.next();
+
+    assert_eq!(tab_state.get_active_route(), &tab_routes[1].route);
+
+    tab_state.next();
+
+    assert_eq!(tab_state.get_active_route(), &tab_routes[0].route);
+  }
+
+  #[test]
+  fn test_tab_state_previous() {
+    let tab_routes = create_test_tab_routes();
+    let mut tab_state = TabState::new(create_test_tab_routes());
+
+    assert_eq!(tab_state.get_active_route(), &tab_routes[0].route);
+
+    tab_state.previous();
+
+    assert_eq!(tab_state.get_active_route(), &tab_routes[1].route);
+
+    tab_state.previous();
+
+    assert_eq!(tab_state.get_active_route(), &tab_routes[0].route);
+  }
+
+  fn create_test_tab_routes() -> Vec<TabRoute> {
+    vec![
+      TabRoute {
+        title: "Test 1".to_owned(),
+        route: ActiveRadarrBlock::Movies.into(),
+        help: "Help for Test 1".to_owned(),
+        contextual_help: Some("Contextual Help for Test 1".to_owned()),
+      },
+      TabRoute {
+        title: "Test 2".to_owned(),
+        route: ActiveRadarrBlock::Collections.into(),
+        help: "Help for Test 2".to_owned(),
+        contextual_help: Some("Contextual Help for Test 2".to_owned()),
+      },
+    ]
+  }
+
+  fn create_test_stateful_table() -> StatefulTable<&'static str> {
+    let mut stateful_table = StatefulTable::default();
+    stateful_table.set_items(vec!["Test 1", "Test 2"]);
+
+    stateful_table
+  }
+}

src/ui/radarr_ui/movie_details_ui.rs

@@ -399,7 +399,7 @@ fn draw_movie_releases<B: Backend>(f: &mut Frame<'_, B>, app: &mut App, content_
       );
       let size = convert_to_gb(size.as_u64().unwrap());
       let rejected_str = if *rejected { "⛔" } else { "" };
-      let mut peers = if seeders.is_none() || leechers.is_none() {
+      let peers = if seeders.is_none() || leechers.is_none() {
         Text::default()
       } else {
         let seeders = seeders.clone().unwrap().as_u64().unwrap();