feat(app): Dispatch support for all relevant Sonarr blocks

src/app/sonarr/mod.rs

@@ -0,0 +1,197 @@
+use crate::{
+  models::servarr_data::sonarr::sonarr_data::ActiveSonarrBlock,
+  network::sonarr_network::SonarrEvent,
+};
+
+use super::App;
+
+pub mod sonarr_context_clues;
+
+#[cfg(test)]
+#[path = "sonarr_tests.rs"]
+mod sonarr_tests;
+
+impl<'a> App<'a> {
+  pub(super) async fn dispatch_by_sonarr_block(&mut self, active_sonarr_block: &ActiveSonarrBlock) {
+    match active_sonarr_block {
+      ActiveSonarrBlock::Series => {
+        self
+          .dispatch_network_event(SonarrEvent::ListSeries.into())
+          .await;
+        self
+          .dispatch_network_event(SonarrEvent::GetDownloads.into())
+          .await;
+      }
+      ActiveSonarrBlock::SeriesDetails => {
+        self.is_loading = true;
+        self.populate_seasons_table().await;
+        self.is_loading = false;
+      }
+      ActiveSonarrBlock::SeriesHistory => {
+        self
+          .dispatch_network_event(SonarrEvent::GetSeriesHistory(None).into())
+          .await;
+      }
+      ActiveSonarrBlock::SeasonDetails => {
+        self
+          .dispatch_network_event(SonarrEvent::GetEpisodes(None).into())
+          .await;
+      }
+      ActiveSonarrBlock::ManualSeasonSearch => {
+        self
+          .dispatch_network_event(SonarrEvent::GetSeasonReleases(None).into())
+          .await;
+      }
+      ActiveSonarrBlock::EpisodeDetails | ActiveSonarrBlock::EpisodeFile => {
+        self
+          .dispatch_network_event(SonarrEvent::GetEpisodeDetails(None).into())
+          .await;
+      }
+      ActiveSonarrBlock::EpisodeHistory => {
+        self
+          .dispatch_network_event(SonarrEvent::GetEpisodeHistory(None).into())
+          .await;
+      }
+      ActiveSonarrBlock::ManualEpisodeSearch => {
+        self
+          .dispatch_network_event(SonarrEvent::GetEpisodeReleases(None).into())
+          .await;
+      }
+      ActiveSonarrBlock::Downloads => {
+        self
+          .dispatch_network_event(SonarrEvent::GetDownloads.into())
+          .await;
+      }
+      ActiveSonarrBlock::Blocklist => {
+        self
+          .dispatch_network_event(SonarrEvent::GetBlocklist.into())
+          .await;
+      }
+      ActiveSonarrBlock::History => {
+        self
+          .dispatch_network_event(SonarrEvent::GetHistory(None).into())
+          .await;
+      }
+      ActiveSonarrBlock::RootFolders => {
+        self
+          .dispatch_network_event(SonarrEvent::GetRootFolders.into())
+          .await;
+      }
+      ActiveSonarrBlock::Indexers => {
+        self
+          .dispatch_network_event(SonarrEvent::GetIndexers.into())
+          .await;
+      }
+      ActiveSonarrBlock::AllIndexerSettingsPrompt => {
+        self
+          .dispatch_network_event(SonarrEvent::GetAllIndexerSettings.into())
+          .await;
+      }
+      ActiveSonarrBlock::TestIndexer => {
+        self
+          .dispatch_network_event(SonarrEvent::TestIndexer(None).into())
+          .await;
+      }
+      ActiveSonarrBlock::TestAllIndexers => {
+        self
+          .dispatch_network_event(SonarrEvent::TestAllIndexers.into())
+          .await;
+      }
+      ActiveSonarrBlock::System => {
+        self
+          .dispatch_network_event(SonarrEvent::GetTasks.into())
+          .await;
+        self
+          .dispatch_network_event(SonarrEvent::GetQueuedEvents.into())
+          .await;
+        self
+          .dispatch_network_event(SonarrEvent::GetLogs(None).into())
+          .await;
+      }
+      ActiveSonarrBlock::SystemUpdates => {
+        self
+          .dispatch_network_event(SonarrEvent::GetUpdates.into())
+          .await;
+      }
+      _ => (),
+    }
+
+    self.check_for_sonarr_prompt_action().await;
+    self.reset_tick_count();
+  }
+
+  async fn check_for_sonarr_prompt_action(&mut self) {
+    if self.data.sonarr_data.prompt_confirm {
+      self.data.sonarr_data.prompt_confirm = false;
+      if let Some(sonarr_event) = &self.data.sonarr_data.prompt_confirm_action {
+        self
+          .dispatch_network_event(sonarr_event.clone().into())
+          .await;
+        self.should_refresh = true;
+        self.data.sonarr_data.prompt_confirm_action = None;
+      }
+    }
+  }
+
+  pub(super) async fn sonarr_on_tick(&mut self, active_sonarr_block: ActiveSonarrBlock) {
+    if self.is_first_render {
+      self.refresh_sonarr_metadata().await;
+      self.dispatch_by_sonarr_block(&active_sonarr_block).await;
+      self.is_first_render = false;
+    }
+
+    if self.should_refresh {
+      self.dispatch_by_sonarr_block(&active_sonarr_block).await;
+      self.refresh_sonarr_metadata().await;
+    }
+
+    if self.is_routing {
+      if !self.should_refresh {
+        self.cancellation_token.cancel();
+      } else {
+        self.dispatch_by_sonarr_block(&active_sonarr_block).await;
+        self.refresh_sonarr_metadata().await;
+      }
+    }
+
+    if self.tick_count % self.tick_until_poll == 0 {
+      self.refresh_sonarr_metadata().await;
+    }
+  }
+
+  async fn refresh_sonarr_metadata(&mut self) {
+    self
+      .dispatch_network_event(SonarrEvent::GetQualityProfiles.into())
+      .await;
+    self
+      .dispatch_network_event(SonarrEvent::GetLanguageProfiles.into())
+      .await;
+    self
+      .dispatch_network_event(SonarrEvent::GetTags.into())
+      .await;
+    self
+      .dispatch_network_event(SonarrEvent::GetRootFolders.into())
+      .await;
+    self
+      .dispatch_network_event(SonarrEvent::GetDownloads.into())
+      .await;
+    self
+      .dispatch_network_event(SonarrEvent::GetDiskSpace.into())
+      .await;
+    self
+      .dispatch_network_event(SonarrEvent::GetStatus.into())
+      .await;
+  }
+
+  async fn populate_seasons_table(&mut self) {
+    let seasons = self
+      .data
+      .sonarr_data
+      .series
+      .current_selection()
+      .clone()
+      .seasons
+      .unwrap_or_default();
+    self.data.sonarr_data.seasons.set_items(seasons);
+  }
+}

src/app/sonarr/sonarr_context_clues.rs

@@ -0,0 +1,33 @@
+use crate::app::{context_clues::ContextClue, key_binding::DEFAULT_KEYBINDINGS};
+
+#[cfg(test)]
+#[path = "sonarr_context_clues_tests.rs"]
+mod sonarr_context_clues_tests;
+
+pub static SERIES_CONTEXT_CLUES: [ContextClue; 10] = [
+  (DEFAULT_KEYBINDINGS.add, DEFAULT_KEYBINDINGS.add.desc),
+  (DEFAULT_KEYBINDINGS.edit, DEFAULT_KEYBINDINGS.edit.desc),
+  (DEFAULT_KEYBINDINGS.sort, DEFAULT_KEYBINDINGS.sort.desc),
+  (DEFAULT_KEYBINDINGS.delete, DEFAULT_KEYBINDINGS.delete.desc),
+  (DEFAULT_KEYBINDINGS.search, DEFAULT_KEYBINDINGS.search.desc),
+  (DEFAULT_KEYBINDINGS.filter, DEFAULT_KEYBINDINGS.filter.desc),
+  (
+    DEFAULT_KEYBINDINGS.refresh,
+    DEFAULT_KEYBINDINGS.refresh.desc,
+  ),
+  (DEFAULT_KEYBINDINGS.update, "update all"),
+  (DEFAULT_KEYBINDINGS.submit, "details"),
+  (DEFAULT_KEYBINDINGS.esc, "cancel filter"),
+];
+
+pub static HISTORY_CONTEXT_CLUES: [ContextClue; 6] = [
+  (DEFAULT_KEYBINDINGS.sort, DEFAULT_KEYBINDINGS.sort.desc),
+  (DEFAULT_KEYBINDINGS.delete, "mark as failed"),
+  (DEFAULT_KEYBINDINGS.search, DEFAULT_KEYBINDINGS.search.desc),
+  (DEFAULT_KEYBINDINGS.filter, DEFAULT_KEYBINDINGS.filter.desc),
+  (
+    DEFAULT_KEYBINDINGS.refresh,
+    DEFAULT_KEYBINDINGS.refresh.desc,
+  ),
+  (DEFAULT_KEYBINDINGS.esc, "cancel filter"),
+];

src/app/sonarr/sonarr_context_clues_tests.rs

@@ -0,0 +1,101 @@
+#[cfg(test)]
+mod tests {
+  use pretty_assertions::{assert_eq, assert_str_eq};
+
+  use crate::app::{
+    key_binding::DEFAULT_KEYBINDINGS,
+    sonarr::sonarr_context_clues::{HISTORY_CONTEXT_CLUES, SERIES_CONTEXT_CLUES},
+  };
+
+  #[test]
+  fn test_series_context_clues() {
+    let mut series_context_clues_iter = SERIES_CONTEXT_CLUES.iter();
+
+    let (key_binding, description) = series_context_clues_iter.next().unwrap();
+
+    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.add);
+    assert_str_eq!(*description, DEFAULT_KEYBINDINGS.add.desc);
+
+    let (key_binding, description) = series_context_clues_iter.next().unwrap();
+
+    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.edit);
+    assert_str_eq!(*description, DEFAULT_KEYBINDINGS.edit.desc);
+
+    let (key_binding, description) = series_context_clues_iter.next().unwrap();
+
+    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.sort);
+    assert_str_eq!(*description, DEFAULT_KEYBINDINGS.sort.desc);
+
+    let (key_binding, description) = series_context_clues_iter.next().unwrap();
+
+    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.delete);
+    assert_str_eq!(*description, DEFAULT_KEYBINDINGS.delete.desc);
+
+    let (key_binding, description) = series_context_clues_iter.next().unwrap();
+
+    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.search);
+    assert_str_eq!(*description, DEFAULT_KEYBINDINGS.search.desc);
+
+    let (key_binding, description) = series_context_clues_iter.next().unwrap();
+
+    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.filter);
+    assert_str_eq!(*description, DEFAULT_KEYBINDINGS.filter.desc);
+
+    let (key_binding, description) = series_context_clues_iter.next().unwrap();
+
+    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.refresh);
+    assert_str_eq!(*description, DEFAULT_KEYBINDINGS.refresh.desc);
+
+    let (key_binding, description) = series_context_clues_iter.next().unwrap();
+
+    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.update);
+    assert_str_eq!(*description, "update all");
+
+    let (key_binding, description) = series_context_clues_iter.next().unwrap();
+
+    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.submit);
+    assert_str_eq!(*description, "details");
+
+    let (key_binding, description) = series_context_clues_iter.next().unwrap();
+
+    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.esc);
+    assert_str_eq!(*description, "cancel filter");
+    assert_eq!(series_context_clues_iter.next(), None);
+  }
+
+  #[test]
+  fn test_history_context_clues() {
+    let mut history_context_clues_iter = HISTORY_CONTEXT_CLUES.iter();
+
+    let (key_binding, description) = history_context_clues_iter.next().unwrap();
+
+    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.sort);
+    assert_str_eq!(*description, DEFAULT_KEYBINDINGS.sort.desc);
+
+    let (key_binding, description) = history_context_clues_iter.next().unwrap();
+
+    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.delete);
+    assert_str_eq!(*description, "mark as failed");
+
+    let (key_binding, description) = history_context_clues_iter.next().unwrap();
+
+    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.search);
+    assert_str_eq!(*description, DEFAULT_KEYBINDINGS.search.desc);
+
+    let (key_binding, description) = history_context_clues_iter.next().unwrap();
+
+    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.filter);
+    assert_str_eq!(*description, DEFAULT_KEYBINDINGS.filter.desc);
+
+    let (key_binding, description) = history_context_clues_iter.next().unwrap();
+
+    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.refresh);
+    assert_str_eq!(*description, DEFAULT_KEYBINDINGS.refresh.desc);
+
+    let (key_binding, description) = history_context_clues_iter.next().unwrap();
+
+    assert_eq!(*key_binding, DEFAULT_KEYBINDINGS.esc);
+    assert_str_eq!(*description, "cancel filter");
+    assert_eq!(history_context_clues_iter.next(), None);
+  }
+}

src/app/sonarr/sonarr_tests.rs

@@ -0,0 +1,606 @@
+#[cfg(test)]
+mod tests {
+  mod sonarr_tests {
+    use pretty_assertions::assert_eq;
+    use tokio::sync::mpsc;
+
+    use crate::{
+      app::App,
+      models::{
+        servarr_data::sonarr::sonarr_data::ActiveSonarrBlock,
+        sonarr_models::{Season, Series},
+      },
+      network::{sonarr_network::SonarrEvent, NetworkEvent},
+    };
+
+    #[tokio::test]
+    async fn test_dispatch_by_blocklist_block() {
+      let (mut app, mut sync_network_rx) = construct_app_unit();
+
+      app
+        .dispatch_by_sonarr_block(&ActiveSonarrBlock::Blocklist)
+        .await;
+
+      assert!(app.is_loading);
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetBlocklist.into()
+      );
+      assert!(!app.data.sonarr_data.prompt_confirm);
+      assert_eq!(app.tick_count, 0);
+    }
+
+    #[tokio::test]
+    async fn test_dispatch_by_series_history_block() {
+      let (mut app, mut sync_network_rx) = construct_app_unit();
+
+      app
+        .dispatch_by_sonarr_block(&ActiveSonarrBlock::SeriesHistory)
+        .await;
+
+      assert!(app.is_loading);
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetSeriesHistory(None).into()
+      );
+      assert!(!app.data.sonarr_data.prompt_confirm);
+      assert_eq!(app.tick_count, 0);
+    }
+
+    #[tokio::test]
+    async fn test_dispatch_by_series_details_block() {
+      let (mut app, _) = construct_app_unit();
+
+      app.data.sonarr_data.series.set_items(vec![Series {
+        seasons: Some(vec![Season::default()]),
+        ..Series::default()
+      }]);
+
+      app
+        .dispatch_by_sonarr_block(&ActiveSonarrBlock::SeriesDetails)
+        .await;
+
+      assert!(!app.is_loading);
+      assert!(!app.data.sonarr_data.seasons.items.is_empty());
+      assert_eq!(app.tick_count, 0);
+      assert!(!app.data.sonarr_data.prompt_confirm);
+    }
+
+    #[tokio::test]
+    async fn test_dispatch_by_season_details_block() {
+      let (mut app, mut sync_network_rx) = construct_app_unit();
+
+      app
+        .dispatch_by_sonarr_block(&ActiveSonarrBlock::SeasonDetails)
+        .await;
+
+      assert!(app.is_loading);
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetEpisodes(None).into()
+      );
+      assert!(!app.data.sonarr_data.prompt_confirm);
+      assert_eq!(app.tick_count, 0);
+    }
+
+    #[tokio::test]
+    async fn test_dispatch_by_manual_season_search_block() {
+      let (mut app, mut sync_network_rx) = construct_app_unit();
+
+      app
+        .dispatch_by_sonarr_block(&ActiveSonarrBlock::ManualSeasonSearch)
+        .await;
+
+      assert!(app.is_loading);
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetSeasonReleases(None).into()
+      );
+      assert!(!app.data.sonarr_data.prompt_confirm);
+      assert_eq!(app.tick_count, 0);
+    }
+
+    #[tokio::test]
+    async fn test_dispatch_by_episode_details_block() {
+      let (mut app, mut sync_network_rx) = construct_app_unit();
+
+      app
+        .dispatch_by_sonarr_block(&ActiveSonarrBlock::EpisodeDetails)
+        .await;
+
+      assert!(app.is_loading);
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetEpisodeDetails(None).into()
+      );
+      assert!(!app.data.sonarr_data.prompt_confirm);
+      assert_eq!(app.tick_count, 0);
+    }
+
+    #[tokio::test]
+    async fn test_dispatch_by_episode_file_block() {
+      let (mut app, mut sync_network_rx) = construct_app_unit();
+
+      app
+        .dispatch_by_sonarr_block(&ActiveSonarrBlock::EpisodeFile)
+        .await;
+
+      assert!(app.is_loading);
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetEpisodeDetails(None).into()
+      );
+      assert!(!app.data.sonarr_data.prompt_confirm);
+      assert_eq!(app.tick_count, 0);
+    }
+
+    #[tokio::test]
+    async fn test_dispatch_by_episode_history_block() {
+      let (mut app, mut sync_network_rx) = construct_app_unit();
+
+      app
+        .dispatch_by_sonarr_block(&ActiveSonarrBlock::EpisodeHistory)
+        .await;
+
+      assert!(app.is_loading);
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetEpisodeHistory(None).into()
+      );
+      assert!(!app.data.sonarr_data.prompt_confirm);
+      assert_eq!(app.tick_count, 0);
+    }
+
+    #[tokio::test]
+    async fn test_dispatch_by_manual_episode_search_block() {
+      let (mut app, mut sync_network_rx) = construct_app_unit();
+
+      app
+        .dispatch_by_sonarr_block(&ActiveSonarrBlock::ManualEpisodeSearch)
+        .await;
+
+      assert!(app.is_loading);
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetEpisodeReleases(None).into()
+      );
+      assert!(!app.data.sonarr_data.prompt_confirm);
+      assert_eq!(app.tick_count, 0);
+    }
+
+    #[tokio::test]
+    async fn test_dispatch_by_history_block() {
+      let (mut app, mut sync_network_rx) = construct_app_unit();
+
+      app
+        .dispatch_by_sonarr_block(&ActiveSonarrBlock::History)
+        .await;
+
+      assert!(app.is_loading);
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetHistory(None).into()
+      );
+      assert!(!app.data.sonarr_data.prompt_confirm);
+      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_sonarr_block(&ActiveSonarrBlock::Downloads)
+        .await;
+
+      assert!(app.is_loading);
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetDownloads.into()
+      );
+      assert!(!app.data.sonarr_data.prompt_confirm);
+      assert_eq!(app.tick_count, 0);
+    }
+
+    #[tokio::test]
+    async fn test_dispatch_by_root_folders_block() {
+      let (mut app, mut sync_network_rx) = construct_app_unit();
+
+      app
+        .dispatch_by_sonarr_block(&ActiveSonarrBlock::RootFolders)
+        .await;
+
+      assert!(app.is_loading);
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetRootFolders.into()
+      );
+      assert!(!app.data.sonarr_data.prompt_confirm);
+      assert_eq!(app.tick_count, 0);
+    }
+
+    #[tokio::test]
+    async fn test_dispatch_by_series_block() {
+      let (mut app, mut sync_network_rx) = construct_app_unit();
+
+      app
+        .dispatch_by_sonarr_block(&ActiveSonarrBlock::Series)
+        .await;
+
+      assert!(app.is_loading);
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::ListSeries.into()
+      );
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetDownloads.into()
+      );
+      assert!(!app.data.sonarr_data.prompt_confirm);
+      assert_eq!(app.tick_count, 0);
+    }
+
+    #[tokio::test]
+    async fn test_dispatch_by_indexers_block() {
+      let (mut app, mut sync_network_rx) = construct_app_unit();
+
+      app
+        .dispatch_by_sonarr_block(&ActiveSonarrBlock::Indexers)
+        .await;
+
+      assert!(app.is_loading);
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetIndexers.into()
+      );
+      assert!(!app.data.sonarr_data.prompt_confirm);
+      assert_eq!(app.tick_count, 0);
+    }
+
+    #[tokio::test]
+    async fn test_dispatch_by_all_indexer_settings_block() {
+      let (mut app, mut sync_network_rx) = construct_app_unit();
+
+      app
+        .dispatch_by_sonarr_block(&ActiveSonarrBlock::AllIndexerSettingsPrompt)
+        .await;
+
+      assert!(app.is_loading);
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetAllIndexerSettings.into()
+      );
+      assert!(!app.data.sonarr_data.prompt_confirm);
+      assert_eq!(app.tick_count, 0);
+    }
+
+    #[tokio::test]
+    async fn test_dispatch_by_test_indexer_block() {
+      let (mut app, mut sync_network_rx) = construct_app_unit();
+
+      app
+        .dispatch_by_sonarr_block(&ActiveSonarrBlock::TestIndexer)
+        .await;
+
+      assert!(app.is_loading);
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::TestIndexer(None).into()
+      );
+      assert_eq!(app.tick_count, 0);
+    }
+
+    #[tokio::test]
+    async fn test_dispatch_by_test_all_indexers_block() {
+      let (mut app, mut sync_network_rx) = construct_app_unit();
+
+      app
+        .dispatch_by_sonarr_block(&ActiveSonarrBlock::TestAllIndexers)
+        .await;
+
+      assert!(app.is_loading);
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::TestAllIndexers.into()
+      );
+      assert_eq!(app.tick_count, 0);
+    }
+
+    #[tokio::test]
+    async fn test_dispatch_by_system_block() {
+      let (mut app, mut sync_network_rx) = construct_app_unit();
+
+      app
+        .dispatch_by_sonarr_block(&ActiveSonarrBlock::System)
+        .await;
+
+      assert!(app.is_loading);
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetTasks.into()
+      );
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetQueuedEvents.into()
+      );
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetLogs(None).into()
+      );
+      assert!(!app.data.sonarr_data.prompt_confirm);
+      assert_eq!(app.tick_count, 0);
+    }
+
+    #[tokio::test]
+    async fn test_dispatch_by_system_updates_block() {
+      let (mut app, mut sync_network_rx) = construct_app_unit();
+
+      app
+        .dispatch_by_sonarr_block(&ActiveSonarrBlock::SystemUpdates)
+        .await;
+
+      assert!(app.is_loading);
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetUpdates.into()
+      );
+      assert!(!app.data.sonarr_data.prompt_confirm);
+      assert_eq!(app.tick_count, 0);
+    }
+
+    #[tokio::test]
+    async fn test_check_for_sonarr_prompt_action_no_prompt_confirm() {
+      let mut app = App::default();
+      app.data.sonarr_data.prompt_confirm = false;
+
+      app.check_for_sonarr_prompt_action().await;
+
+      assert!(!app.data.sonarr_data.prompt_confirm);
+      assert!(!app.should_refresh);
+    }
+
+    #[tokio::test]
+    async fn test_check_for_sonarr_prompt_action() {
+      let (mut app, mut sync_network_rx) = construct_app_unit();
+      app.data.sonarr_data.prompt_confirm_action = Some(SonarrEvent::GetStatus);
+
+      app.check_for_sonarr_prompt_action().await;
+
+      assert!(!app.data.sonarr_data.prompt_confirm);
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetStatus.into()
+      );
+      assert!(app.should_refresh);
+      assert_eq!(app.data.sonarr_data.prompt_confirm_action, None);
+    }
+
+    #[tokio::test]
+    async fn test_sonarr_refresh_metadata() {
+      let (mut app, mut sync_network_rx) = construct_app_unit();
+      app.is_routing = true;
+
+      app.refresh_sonarr_metadata().await;
+
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetQualityProfiles.into()
+      );
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetLanguageProfiles.into()
+      );
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetTags.into()
+      );
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetRootFolders.into()
+      );
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetDownloads.into()
+      );
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetDiskSpace.into()
+      );
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetStatus.into()
+      );
+      assert!(app.is_loading);
+    }
+
+    #[tokio::test]
+    async fn test_sonarr_on_tick_first_render() {
+      let (mut app, mut sync_network_rx) = construct_app_unit();
+      app.is_first_render = true;
+
+      app.sonarr_on_tick(ActiveSonarrBlock::Downloads).await;
+
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetQualityProfiles.into()
+      );
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetLanguageProfiles.into()
+      );
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetTags.into()
+      );
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetRootFolders.into()
+      );
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetDownloads.into()
+      );
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetDiskSpace.into()
+      );
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetStatus.into()
+      );
+      assert!(app.is_loading);
+      assert!(!app.data.sonarr_data.prompt_confirm);
+      assert!(!app.is_first_render);
+    }
+
+    #[tokio::test]
+    async fn test_sonarr_on_tick_routing() {
+      let (mut app, mut sync_network_rx) = construct_app_unit();
+      app.is_routing = true;
+      app.should_refresh = true;
+
+      app.sonarr_on_tick(ActiveSonarrBlock::Downloads).await;
+
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetDownloads.into()
+      );
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetQualityProfiles.into()
+      );
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetLanguageProfiles.into()
+      );
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetTags.into()
+      );
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetRootFolders.into()
+      );
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetDownloads.into()
+      );
+      assert!(!app.data.sonarr_data.prompt_confirm);
+    }
+
+    #[tokio::test]
+    async fn test_sonarr_on_tick_routing_while_long_request_is_running_should_cancel_request() {
+      let (mut app, _) = construct_app_unit();
+      app.is_routing = true;
+      app.should_refresh = false;
+
+      app.sonarr_on_tick(ActiveSonarrBlock::Downloads).await;
+
+      assert!(app.cancellation_token.is_cancelled());
+    }
+
+    #[tokio::test]
+    async fn test_sonarr_on_tick_should_refresh() {
+      let (mut app, mut sync_network_rx) = construct_app_unit();
+      app.should_refresh = true;
+
+      app.sonarr_on_tick(ActiveSonarrBlock::Downloads).await;
+
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetDownloads.into()
+      );
+      assert!(app.should_refresh);
+      assert!(!app.data.sonarr_data.prompt_confirm);
+    }
+
+    #[tokio::test]
+    async fn test_sonarr_on_tick_should_refresh_does_not_cancel_prompt_requests() {
+      let (mut app, mut sync_network_rx) = construct_app_unit();
+      app.is_loading = true;
+      app.is_routing = true;
+      app.should_refresh = true;
+
+      app.sonarr_on_tick(ActiveSonarrBlock::Downloads).await;
+
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetDownloads.into()
+      );
+      assert!(app.is_loading);
+      assert!(app.should_refresh);
+      assert!(!app.data.sonarr_data.prompt_confirm);
+      assert!(!app.cancellation_token.is_cancelled());
+    }
+
+    #[tokio::test]
+    async fn test_sonarr_on_tick_network_tick_frequency() {
+      let (mut app, mut sync_network_rx) = construct_app_unit();
+      app.tick_count = 2;
+      app.tick_until_poll = 2;
+
+      app.sonarr_on_tick(ActiveSonarrBlock::Downloads).await;
+
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetQualityProfiles.into()
+      );
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetLanguageProfiles.into()
+      );
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetTags.into()
+      );
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetRootFolders.into()
+      );
+      assert_eq!(
+        sync_network_rx.recv().await.unwrap(),
+        SonarrEvent::GetDownloads.into()
+      );
+      assert!(app.is_loading);
+    }
+
+    #[tokio::test]
+    async fn test_populate_seasons_table_unfiltered() {
+      let mut app = App::default();
+      app.data.sonarr_data.series.set_items(vec![Series {
+        seasons: Some(vec![Season::default()]),
+        ..Series::default()
+      }]);
+
+      app.populate_seasons_table().await;
+
+      assert!(!app.data.sonarr_data.seasons.items.is_empty());
+    }
+
+    #[tokio::test]
+    async fn test_populate_seasons_table_filtered() {
+      let mut app = App::default();
+      app.data.sonarr_data.series.set_filtered_items(vec![Series {
+        seasons: Some(vec![Season::default()]),
+        ..Series::default()
+      }]);
+
+      app.populate_seasons_table().await;
+
+      assert!(!app.data.sonarr_data.seasons.items.is_empty());
+    }
+
+    fn construct_app_unit<'a>() -> (App<'a>, 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,
+        is_first_render: false,
+        ..App::default()
+      };
+      app.data.sonarr_data.prompt_confirm = true;
+
+      (app, sync_network_rx)
+    }
+  }
+}