refactor: Refactored to use more idiomatic let-else statements where applicable

src/handlers/radarr_handlers/library/movie_details_handler.rs

@@ -158,7 +158,10 @@ impl<'a, 'b> KeyEventHandler<'a, 'b, ActiveRadarrBlock> for MovieDetailsHandler<
   }
 
   fn is_ready(&self) -> bool {
-    if let Some(movie_details_modal) = &self.app.data.radarr_data.movie_details_modal {
+    let Some(movie_details_modal) = &self.app.data.radarr_data.movie_details_modal else {
+      return false;
+    };
+
     match self.active_radarr_block {
       ActiveRadarrBlock::MovieDetails => {
         !self.app.is_loading && !movie_details_modal.movie_details.is_empty()
@@ -166,20 +169,13 @@ impl<'a, 'b> KeyEventHandler<'a, 'b, ActiveRadarrBlock> for MovieDetailsHandler<
       ActiveRadarrBlock::MovieHistory => {
         !self.app.is_loading && !movie_details_modal.movie_history.is_empty()
       }
-        ActiveRadarrBlock::Cast => {
+      ActiveRadarrBlock::Cast => !self.app.is_loading && !movie_details_modal.movie_cast.is_empty(),
-          !self.app.is_loading && !movie_details_modal.movie_cast.is_empty()
+      ActiveRadarrBlock::Crew => !self.app.is_loading && !movie_details_modal.movie_crew.is_empty(),
-        }
-        ActiveRadarrBlock::Crew => {
-          !self.app.is_loading && !movie_details_modal.movie_crew.is_empty()
-        }
       ActiveRadarrBlock::ManualSearch => {
         !self.app.is_loading && !movie_details_modal.movie_releases.is_empty()
       }
       _ => !self.app.is_loading,
     }
-    } else {
-      false
-    }
   }
 
   fn handle_scroll_up(&mut self) {

src/handlers/sonarr_handlers/library/episode_details_handler.rs

@@ -110,23 +110,23 @@ impl<'a, 'b> KeyEventHandler<'a, 'b, ActiveSonarrBlock> for EpisodeDetailsHandle
   }
 
   fn is_ready(&self) -> bool {
-    !self.app.is_loading
+    if self.app.is_loading {
-      && if let Some(season_details_modal) = self.app.data.sonarr_data.season_details_modal.as_ref()
+      return false;
-      {
+    }
-        if let Some(episode_details_modal) = &season_details_modal.episode_details_modal {
+
+    let Some(season_details_modal) = self.app.data.sonarr_data.season_details_modal.as_ref() else {
+      return false;
+    };
+
+    let Some(episode_details_modal) = &season_details_modal.episode_details_modal else {
+      return false;
+    };
+
     match self.active_sonarr_block {
       ActiveSonarrBlock::EpisodeHistory => !episode_details_modal.episode_history.is_empty(),
-            ActiveSonarrBlock::ManualEpisodeSearch => {
+      ActiveSonarrBlock::ManualEpisodeSearch => !episode_details_modal.episode_releases.is_empty(),
-              !episode_details_modal.episode_releases.is_empty()
-            }
       _ => true,
     }
-        } else {
-          false
-        }
-      } else {
-        false
-      }
   }
 
   fn handle_scroll_up(&mut self) {}

src/handlers/sonarr_handlers/library/season_details_handler.rs

@@ -162,17 +162,20 @@ impl<'a, 'b> KeyEventHandler<'a, 'b, ActiveSonarrBlock> for SeasonDetailsHandler
   }
 
   fn is_ready(&self) -> bool {
-    !self.app.is_loading
+    if self.app.is_loading {
-      && if let Some(season_details_modal) = &self.app.data.sonarr_data.season_details_modal {
+      return false;
+    }
+
+    let Some(season_details_modal) = &self.app.data.sonarr_data.season_details_modal else {
+      return false;
+    };
+
     match self.active_sonarr_block {
       ActiveSonarrBlock::SeasonDetails => !season_details_modal.episodes.is_empty(),
       ActiveSonarrBlock::SeasonHistory => !season_details_modal.season_history.is_empty(),
       ActiveSonarrBlock::ManualSeasonSearch => !season_details_modal.season_releases.is_empty(),
       _ => true,
     }
-      } else {
-        false
-      }
   }
 
   fn handle_scroll_up(&mut self) {}

src/network/radarr_network/blocklist/radarr_blocklist_network_tests.rs

@@ -195,11 +195,13 @@ mod tests {
     }
     let mut network = test_network(&app);
 
-    if let RadarrSerdeable::BlocklistResponse(blocklist) = network
+    let RadarrSerdeable::BlocklistResponse(blocklist) = network
       .handle_radarr_event(RadarrEvent::GetBlocklist)
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected BlocklistResponse")
+    };
     mock.assert_async().await;
     assert_eq!(
       app.lock().await.data.radarr_data.blocklist.items,
@@ -208,7 +210,6 @@ mod tests {
     assert!(app.lock().await.data.radarr_data.blocklist.sort_asc);
     assert_eq!(blocklist, response);
   }
-  }
 
   #[tokio::test]
   async fn test_handle_get_blocklist_event_no_op_when_user_is_selecting_sort_options() {

src/network/radarr_network/collections/radarr_collections_network_tests.rs

@@ -277,11 +277,13 @@ mod tests {
     }
     let mut network = test_network(&app);
 
-    if let RadarrSerdeable::Collections(collections) = network
+    let RadarrSerdeable::Collections(collections) = network
       .handle_radarr_event(RadarrEvent::GetCollections)
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected Collections")
+    };
     mock.assert_async().await;
     assert_eq!(
       app.lock().await.data.radarr_data.collections.items,
@@ -290,7 +292,6 @@ mod tests {
     assert!(app.lock().await.data.radarr_data.collections.sort_asc);
     assert_eq!(collections, response);
   }
-  }
 
   #[tokio::test]
   async fn test_handle_get_collections_event_no_op_when_user_is_selecting_sort_options() {

src/network/radarr_network/downloads/radarr_downloads_network_tests.rs

@@ -48,11 +48,13 @@ mod tests {
       .await;
     let mut network = test_network(&app);
 
-    if let RadarrSerdeable::DownloadsResponse(downloads) = network
+    let RadarrSerdeable::DownloadsResponse(downloads) = network
       .handle_radarr_event(RadarrEvent::GetDownloads(500))
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected DownloadsResponse")
+    };
     mock.assert_async().await;
     pretty_assertions::assert_eq!(
       app.lock().await.data.radarr_data.downloads.items,
@@ -60,7 +62,6 @@ mod tests {
     );
     pretty_assertions::assert_eq!(downloads, response);
   }
-  }
 
   #[tokio::test]
   async fn test_handle_update_radarr_downloads_event() {

src/network/radarr_network/indexers/radarr_indexers_network_tests.rs

@@ -623,11 +623,13 @@ mod tests {
       .await;
     let mut network = test_network(&app);
 
-    if let RadarrSerdeable::Indexers(indexers) = network
+    let RadarrSerdeable::Indexers(indexers) = network
       .handle_radarr_event(RadarrEvent::GetIndexers)
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected Indexers")
+    };
     async_server.assert_async().await;
     assert_eq!(
       app.lock().await.data.radarr_data.indexers.items,
@@ -635,7 +637,6 @@ mod tests {
     );
     assert_eq!(indexers, response);
   }
-  }
 
   #[tokio::test]
   async fn test_handle_get_all_indexer_settings_event() {
@@ -658,11 +659,13 @@ mod tests {
       .await;
     let mut network = test_network(&app);
 
-    if let RadarrSerdeable::IndexerSettings(settings) = network
+    let RadarrSerdeable::IndexerSettings(settings) = network
       .handle_radarr_event(RadarrEvent::GetAllIndexerSettings)
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected IndexerSettings")
+    };
     async_server.assert_async().await;
     assert_eq!(
       app.lock().await.data.radarr_data.indexer_settings,
@@ -670,7 +673,6 @@ mod tests {
     );
     assert_eq!(settings, response);
   }
-  }
 
   #[tokio::test]
   async fn test_handle_get_all_indexer_settings_event_no_op_if_already_present() {
@@ -755,19 +757,20 @@ mod tests {
       .await;
     let mut network = test_network(&app);
 
-    if let RadarrSerdeable::Value(value) = network
+    let RadarrSerdeable::Value(value) = network
       .handle_radarr_event(RadarrEvent::TestIndexer(1))
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected Value")
+    };
     async_details_server.assert_async().await;
     async_test_server.assert_async().await;
     assert_eq!(
       app.lock().await.data.radarr_data.indexer_test_errors,
       Some("\"test failure\"".to_owned())
     );
-      assert_eq!(value, response_json)
+    assert_eq!(value, response_json);
-    }
   }
 
   #[tokio::test]
@@ -812,11 +815,13 @@ mod tests {
       .await;
     let mut network = test_network(&app);
 
-    if let RadarrSerdeable::Value(value) = network
+    let RadarrSerdeable::Value(value) = network
       .handle_radarr_event(RadarrEvent::TestIndexer(1))
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected Value")
+    };
     async_details_server.assert_async().await;
     async_test_server.assert_async().await;
     assert_eq!(
@@ -825,7 +830,6 @@ mod tests {
     );
     assert_eq!(value, json!({}));
   }
-  }
 
   #[tokio::test]
   async fn test_handle_test_all_radarr_indexers_event() {
@@ -890,11 +894,13 @@ mod tests {
       .set_items(indexers);
     let mut network = test_network(&app);
 
-    if let RadarrSerdeable::IndexerTestResults(results) = network
+    let RadarrSerdeable::IndexerTestResults(results) = network
       .handle_radarr_event(RadarrEvent::TestAllIndexers)
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected IndexerTestResults")
+    };
     async_server.assert_async().await;
     assert!(
       app
@@ -919,5 +925,4 @@ mod tests {
     );
     assert_eq!(results, response);
   }
-  }
 }

src/network/radarr_network/library/radarr_library_network_tests.rs

@@ -382,11 +382,13 @@ mod tests {
     app_arc.lock().await.data.radarr_data.movie_details_modal = Some(MovieDetailsModal::default());
     let mut network = test_network(&app_arc);
 
-    if let RadarrSerdeable::Credits(credits) = network
+    let RadarrSerdeable::Credits(credits) = network
       .handle_radarr_event(RadarrEvent::GetMovieCredits(1))
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected Credits")
+    };
     let app = app_arc.lock().await;
     let movie_details_modal = app.data.radarr_data.movie_details_modal.as_ref().unwrap();
 
@@ -395,7 +397,6 @@ mod tests {
     assert_eq!(movie_details_modal.movie_crew.items, vec![crew_credit()]);
     assert_eq!(credits, response);
   }
-  }
 
   #[tokio::test]
   async fn test_handle_get_movie_credits_event_empty_movie_details_modal() {
@@ -570,11 +571,13 @@ mod tests {
       BiMap::from_iter([(2222, "HD - 1080p".to_owned())]);
     let mut network = test_network(&app_arc);
 
-    if let RadarrSerdeable::Movie(movie) = network
+    let RadarrSerdeable::Movie(movie) = network
       .handle_radarr_event(RadarrEvent::GetMovieDetails(1))
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected Movie")
+    };
     async_server.assert_async().await;
     assert!(
       app_arc
@@ -641,7 +644,6 @@ mod tests {
       )
     );
   }
-  }
 
   #[tokio::test]
   async fn test_handle_get_movie_details_event_empty_options_give_correct_defaults() {
@@ -741,11 +743,13 @@ mod tests {
     app_arc.lock().await.data.radarr_data.movie_details_modal = Some(MovieDetailsModal::default());
     let mut network = test_network(&app_arc);
 
-    if let RadarrSerdeable::MovieHistoryItems(history) = network
+    let RadarrSerdeable::MovieHistoryItems(history) = network
       .handle_radarr_event(RadarrEvent::GetMovieHistory(1))
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected MovieHistoryItems")
+    };
     async_server.assert_async().await;
     assert_eq!(
       app_arc
@@ -762,7 +766,6 @@ mod tests {
     );
     assert_eq!(history, response);
   }
-  }
 
   #[tokio::test]
   async fn test_handle_get_movie_history_event_empty_movie_details_modal() {
@@ -828,11 +831,13 @@ mod tests {
     app_arc.lock().await.data.radarr_data.movie_details_modal = Some(MovieDetailsModal::default());
     let mut network = test_network(&app_arc);
 
-    if let RadarrSerdeable::Releases(releases_vec) = network
+    let RadarrSerdeable::Releases(releases_vec) = network
       .handle_radarr_event(RadarrEvent::GetReleases(1))
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected Releases")
+    };
     async_server.assert_async().await;
     assert_eq!(
       app_arc
@@ -849,7 +854,6 @@ mod tests {
     );
     assert_eq!(releases_vec, vec![release()]);
   }
-  }
 
   #[tokio::test]
   async fn test_handle_get_movie_releases_event_empty_movie_details_modal() {
@@ -928,11 +932,13 @@ mod tests {
       .await;
     let mut network = test_network(&app_arc);
 
-    if let RadarrSerdeable::AddMovieSearchResults(add_movie_search_results) = network
+    let RadarrSerdeable::AddMovieSearchResults(add_movie_search_results) = network
       .handle_radarr_event(RadarrEvent::SearchNewMovie("test term".into()))
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected AddMovieSearchResults")
+    };
     async_server.assert_async().await;
     assert!(
       app_arc
@@ -957,7 +963,6 @@ mod tests {
     );
     assert_eq!(add_movie_search_results, vec![add_movie_search_result()]);
   }
-  }
 
   #[tokio::test]
   async fn test_handle_search_new_movie_event_no_results() {

src/network/radarr_network/radarr_network_tests.rs

@@ -194,8 +194,9 @@ mod test {
     mock.assert_async().await;
 
     let RadarrSerdeable::QualityProfiles(quality_profiles) = result.unwrap() else {
-      panic!("Expected QualityProfiles variant");
+      panic!("Expected QualityProfiles");
     };
+
     assert_eq!(quality_profiles, expected);
     assert_eq!(
       app.lock().await.data.radarr_data.quality_profile_map,
@@ -225,8 +226,9 @@ mod test {
     mock.assert_async().await;
 
     let RadarrSerdeable::Tags(tags) = result.unwrap() else {
-      panic!("Expected Tags variant");
+      panic!("Expected Tags");
     };
+
     assert_eq!(tags, expected);
     assert_eq!(
       app.lock().await.data.radarr_data.tags_map,
@@ -259,8 +261,9 @@ mod test {
     mock.assert_async().await;
 
     let RadarrSerdeable::Tag(tag) = result.unwrap() else {
-      panic!("Expected Tag variant");
+      panic!("Expected Tag");
     };
+
     assert_eq!(tag, expected);
     assert_eq!(
       app.lock().await.data.radarr_data.tags_map,

src/network/radarr_network/root_folders/radarr_root_folders_network_tests.rs

@@ -65,11 +65,13 @@ mod tests {
       .await;
     let mut network = test_network(&app);
 
-    if let RadarrSerdeable::RootFolders(root_folders) = network
+    let RadarrSerdeable::RootFolders(root_folders) = network
       .handle_radarr_event(RadarrEvent::GetRootFolders)
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected RootFolders")
+    };
     mock.assert_async().await;
     assert_eq!(
       app.lock().await.data.radarr_data.root_folders.items,
@@ -77,5 +79,4 @@ mod tests {
     );
     assert_eq!(root_folders, response);
   }
-  }
 }

src/network/radarr_network/system/radarr_system_network_tests.rs

@@ -39,11 +39,13 @@ mod tests {
       },
     ];
 
-    if let RadarrSerdeable::DiskSpaces(disk_space) = network
+    let RadarrSerdeable::DiskSpaces(disk_space) = network
       .handle_radarr_event(RadarrEvent::GetDiskSpace)
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected DiskSpaces")
+    };
     mock.assert_async().await;
     assert_eq!(
       app.lock().await.data.radarr_data.disk_space_vec,
@@ -51,7 +53,6 @@ mod tests {
     );
     assert_eq!(disk_space, disk_space_vec);
   }
-  }
 
   #[tokio::test]
   async fn test_handle_get_radarr_host_config_event() {
@@ -73,15 +74,16 @@ mod tests {
       .await;
     let mut network = test_network(&app);
 
-    if let RadarrSerdeable::HostConfig(host_config) = network
+    let RadarrSerdeable::HostConfig(host_config) = network
       .handle_radarr_event(RadarrEvent::GetHostConfig)
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected HostConfig")
+    };
     mock.assert_async().await;
     assert_eq!(host_config, response);
   }
-  }
 
   #[tokio::test]
   async fn test_handle_get_radarr_logs_event() {
@@ -123,11 +125,13 @@ mod tests {
       .await;
     let mut network = test_network(&app);
 
-    if let RadarrSerdeable::LogResponse(logs) = network
+    let RadarrSerdeable::LogResponse(logs) = network
       .handle_radarr_event(RadarrEvent::GetLogs(500))
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected LogResponse")
+    };
     mock.assert_async().await;
     assert_eq!(app.lock().await.data.radarr_data.logs.items, expected_logs);
     assert!(
@@ -143,7 +147,6 @@ mod tests {
     );
     assert_eq!(logs, response);
   }
-  }
 
   #[tokio::test]
   async fn test_handle_get_queued_radarr_events_event() {
@@ -176,11 +179,13 @@ mod tests {
       .await;
     let mut network = test_network(&app);
 
-    if let RadarrSerdeable::QueueEvents(events) = network
+    let RadarrSerdeable::QueueEvents(events) = network
       .handle_radarr_event(RadarrEvent::GetQueuedEvents)
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected QueueEvents")
+    };
     mock.assert_async().await;
     assert_eq!(
       app.lock().await.data.radarr_data.queued_events.items,
@@ -188,7 +193,6 @@ mod tests {
     );
     assert_eq!(events, response);
   }
-  }
 
   #[tokio::test]
   async fn test_handle_get_radarr_security_config_event() {
@@ -208,15 +212,16 @@ mod tests {
       .await;
     let mut network = test_network(&app);
 
-    if let RadarrSerdeable::SecurityConfig(security_config) = network
+    let RadarrSerdeable::SecurityConfig(security_config) = network
       .handle_radarr_event(RadarrEvent::GetSecurityConfig)
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected SecurityConfig")
+    };
     mock.assert_async().await;
     assert_eq!(security_config, response);
   }
-  }
 
   #[tokio::test]
   async fn test_handle_get_radarr_status_event() {
@@ -230,11 +235,13 @@ mod tests {
     let mut network = test_network(&app);
     let date_time = DateTime::from(DateTime::parse_from_rfc3339("2023-02-25T20:16:43Z").unwrap());
 
-    if let RadarrSerdeable::SystemStatus(status) = network
+    let RadarrSerdeable::SystemStatus(status) = network
       .handle_radarr_event(RadarrEvent::GetStatus)
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected SystemStatus")
+    };
     async_server.assert_async().await;
     assert_str_eq!(app.lock().await.data.radarr_data.version, "v1");
     assert_eq!(app.lock().await.data.radarr_data.start_time, date_time);
@@ -246,7 +253,6 @@ mod tests {
       }
     );
   }
-  }
 
   #[tokio::test]
   async fn test_handle_get_radarr_updates_event() {
@@ -323,11 +329,13 @@ mod tests {
       .await;
     let mut network = test_network(&app);
 
-    if let RadarrSerdeable::Updates(updates) = network
+    let RadarrSerdeable::Updates(updates) = network
       .handle_radarr_event(RadarrEvent::GetUpdates)
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected Updates")
+    };
     async_server.assert_async().await;
     assert_str_eq!(
       app.lock().await.data.radarr_data.updates.get_text(),
@@ -335,7 +343,6 @@ mod tests {
     );
     assert_eq!(updates, response);
   }
-  }
 
   #[tokio::test]
   async fn test_handle_get_radarr_tasks_event() {
@@ -381,11 +388,13 @@ mod tests {
       .await;
     let mut network = test_network(&app);
 
-    if let RadarrSerdeable::Tasks(tasks) = network
+    let RadarrSerdeable::Tasks(tasks) = network
       .handle_radarr_event(RadarrEvent::GetTasks)
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected Tasks")
+    };
     async_server.assert_async().await;
     assert_eq!(
       app.lock().await.data.radarr_data.tasks.items,
@@ -393,7 +402,6 @@ mod tests {
     );
     assert_eq!(tasks, response);
   }
-  }
 
   #[tokio::test]
   async fn test_handle_start_radarr_task_event() {
@@ -409,15 +417,16 @@ mod tests {
       .await;
     let mut network = test_network(&app);
 
-    if let RadarrSerdeable::Value(value) = network
+    let RadarrSerdeable::Value(value) = network
       .handle_radarr_event(RadarrEvent::StartTask(
         RadarrTaskName::ApplicationCheckUpdate,
       ))
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected Value")
+    };
     async_server.assert_async().await;
     assert_eq!(value, response);
   }
-  }
 }

src/network/sonarr_network/blocklist/sonarr_blocklist_network_tests.rs

@@ -163,11 +163,13 @@ mod tests {
     app.lock().await.server_tabs.next();
     let mut network = test_network(&app);
 
-    if let SonarrSerdeable::BlocklistResponse(blocklist) = network
+    let SonarrSerdeable::BlocklistResponse(blocklist) = network
       .handle_sonarr_event(SonarrEvent::GetBlocklist)
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected BlocklistResponse")
+    };
     mock.assert_async().await;
     assert_eq!(
       app.lock().await.data.sonarr_data.blocklist.items,
@@ -176,7 +178,6 @@ mod tests {
     assert!(app.lock().await.data.sonarr_data.blocklist.sort_asc);
     assert_eq!(blocklist, response);
   }
-  }
 
   #[tokio::test]
   async fn test_handle_get_sonarr_blocklist_event_no_op_when_user_is_selecting_sort_options() {
@@ -233,15 +234,16 @@ mod tests {
     app.lock().await.server_tabs.next();
     let mut network = test_network(&app);
 
-    if let SonarrSerdeable::BlocklistResponse(blocklist) = network
+    let SonarrSerdeable::BlocklistResponse(blocklist) = network
       .handle_sonarr_event(SonarrEvent::GetBlocklist)
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected BlocklistResponse")
+    };
     mock.assert_async().await;
     assert!(app.lock().await.data.sonarr_data.blocklist.is_empty());
     assert!(app.lock().await.data.sonarr_data.blocklist.sort_asc);
     assert_eq!(blocklist, response);
   }
-  }
 }

src/network/sonarr_network/downloads/sonarr_downloads_network_tests.rs

@@ -60,11 +60,13 @@ mod tests {
     app.lock().await.server_tabs.next();
     let mut network = test_network(&app);
 
-    if let SonarrSerdeable::DownloadsResponse(downloads) = network
+    let SonarrSerdeable::DownloadsResponse(downloads) = network
       .handle_sonarr_event(SonarrEvent::GetDownloads(500))
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected DownloadsResponse")
+    };
     mock.assert_async().await;
     assert_eq!(
       app.lock().await.data.sonarr_data.downloads.items,
@@ -72,7 +74,6 @@ mod tests {
     );
     assert_eq!(downloads, response);
   }
-  }
 
   #[tokio::test]
   async fn test_handle_update_sonarr_downloads_event() {

src/network/sonarr_network/history/sonarr_history_network_tests.rs

@@ -84,11 +84,13 @@ mod tests {
     app.lock().await.server_tabs.next();
     let mut network = test_network(&app);
 
-    if let SonarrSerdeable::SonarrHistoryWrapper(history) = network
+    let SonarrSerdeable::SonarrHistoryWrapper(history) = network
       .handle_sonarr_event(SonarrEvent::GetHistory(500))
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected SonarrHistoryWrapper")
+    };
     mock.assert_async().await;
     assert_eq!(
       app.lock().await.data.sonarr_data.history.items,
@@ -97,7 +99,6 @@ mod tests {
     assert!(app.lock().await.data.sonarr_data.history.sort_asc);
     assert_eq!(history, response);
   }
-  }
 
   #[tokio::test]
   async fn test_handle_get_sonarr_history_event_no_op_when_user_is_selecting_sort_options() {
@@ -158,17 +159,18 @@ mod tests {
     app.lock().await.server_tabs.next();
     let mut network = test_network(&app);
 
-    if let SonarrSerdeable::SonarrHistoryWrapper(history) = network
+    let SonarrSerdeable::SonarrHistoryWrapper(history) = network
       .handle_sonarr_event(SonarrEvent::GetHistory(500))
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected SonarrHistoryWrapper")
+    };
     mock.assert_async().await;
     assert!(app.lock().await.data.sonarr_data.history.is_empty());
     assert!(app.lock().await.data.sonarr_data.history.sort_asc);
     assert_eq!(history, response);
   }
-  }
 
   #[tokio::test]
   async fn test_handle_mark_sonarr_history_item_as_failed_event() {

src/network/sonarr_network/indexers/sonarr_indexers_network_tests.rs

@@ -635,11 +635,13 @@ mod tests {
     app.lock().await.server_tabs.next();
     let mut network = test_network(&app);
 
-    if let SonarrSerdeable::Indexers(indexers) = network
+    let SonarrSerdeable::Indexers(indexers) = network
       .handle_sonarr_event(SonarrEvent::GetIndexers)
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected Indexers")
+    };
     async_server.assert_async().await;
     assert_eq!(
       app.lock().await.data.sonarr_data.indexers.items,
@@ -647,7 +649,6 @@ mod tests {
     );
     assert_eq!(indexers, response);
   }
-  }
 
   #[tokio::test]
   async fn test_handle_test_sonarr_indexer_event_error() {
@@ -706,19 +707,20 @@ mod tests {
     app.lock().await.server_tabs.next();
     let mut network = test_network(&app);
 
-    if let SonarrSerdeable::Value(value) = network
+    let SonarrSerdeable::Value(value) = network
       .handle_sonarr_event(SonarrEvent::TestIndexer(1))
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected Value")
+    };
     async_details_server.assert_async().await;
     async_test_server.assert_async().await;
     assert_eq!(
       app.lock().await.data.sonarr_data.indexer_test_errors,
       Some("\"test failure\"".to_owned())
     );
-      assert_eq!(value, response_json)
+    assert_eq!(value, response_json);
-    }
   }
 
   #[tokio::test]
@@ -771,11 +773,13 @@ mod tests {
     app.lock().await.server_tabs.next();
     let mut network = test_network(&app);
 
-    if let SonarrSerdeable::Value(value) = network
+    let SonarrSerdeable::Value(value) = network
       .handle_sonarr_event(SonarrEvent::TestIndexer(1))
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected Value")
+    };
     async_details_server.assert_async().await;
     async_test_server.assert_async().await;
     assert_eq!(
@@ -784,7 +788,6 @@ mod tests {
     );
     assert_eq!(value, json!({}));
   }
-  }
 
   #[tokio::test]
   async fn test_handle_test_all_sonarr_indexers_event() {
@@ -850,11 +853,13 @@ mod tests {
     app.lock().await.server_tabs.next();
     let mut network = test_network(&app);
 
-    if let SonarrSerdeable::IndexerTestResults(results) = network
+    let SonarrSerdeable::IndexerTestResults(results) = network
       .handle_sonarr_event(SonarrEvent::TestAllIndexers)
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected IndexerTestResults")
+    };
     async_server.assert_async().await;
     assert!(
       app
@@ -879,5 +884,4 @@ mod tests {
     );
     assert_eq!(results, response);
   }
-  }
 }

src/network/sonarr_network/library/episodes/sonarr_episodes_network_tests.rs

@@ -253,11 +253,13 @@ mod tests {
     app_arc.lock().await.server_tabs.next();
     let mut network = test_network(&app_arc);
 
-    if let SonarrSerdeable::Episodes(episodes) = network
+    let SonarrSerdeable::Episodes(episodes) = network
       .handle_sonarr_event(SonarrEvent::GetEpisodes(1))
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected Episodes")
+    };
     async_server.assert_async().await;
     assert_eq!(
       app_arc
@@ -274,7 +276,6 @@ mod tests {
     );
     assert_eq!(episodes, vec![episode()]);
   }
-  }
 
   #[tokio::test]
   async fn test_handle_get_episodes_event_no_op_while_user_is_selecting_sort_options_on_table() {
@@ -353,11 +354,13 @@ mod tests {
     app_arc.lock().await.server_tabs.next();
     let mut network = test_network(&app_arc);
 
-    if let SonarrSerdeable::Episodes(episodes) = network
+    let SonarrSerdeable::Episodes(episodes) = network
       .handle_sonarr_event(SonarrEvent::GetEpisodes(1))
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected Episodes")
+    };
     async_server.assert_async().await;
     assert!(
       app_arc
@@ -385,7 +388,6 @@ mod tests {
     );
     assert_eq!(episodes, expected_episodes);
   }
-  }
 
   #[tokio::test]
   async fn test_handle_get_episode_files_event() {
@@ -409,11 +411,13 @@ mod tests {
     app_arc.lock().await.server_tabs.next();
     let mut network = test_network(&app_arc);
 
-    if let SonarrSerdeable::EpisodeFiles(episode_files) = network
+    let SonarrSerdeable::EpisodeFiles(episode_files) = network
       .handle_sonarr_event(SonarrEvent::GetEpisodeFiles(1))
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected EpisodeFiles")
+    };
     async_server.assert_async().await;
     assert_eq!(
       app_arc
@@ -430,7 +434,6 @@ mod tests {
     );
     assert_eq!(episode_files, vec![episode_file()]);
   }
-  }
 
   #[tokio::test]
   async fn test_handle_get_episode_files_event_empty_season_details_modal() {
@@ -452,11 +455,13 @@ mod tests {
     app_arc.lock().await.server_tabs.next();
     let mut network = test_network(&app_arc);
 
-    if let SonarrSerdeable::EpisodeFiles(episode_files) = network
+    let SonarrSerdeable::EpisodeFiles(episode_files) = network
       .handle_sonarr_event(SonarrEvent::GetEpisodeFiles(1))
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected EpisodeFiles")
+    };
     async_server.assert_async().await;
     assert!(
       app_arc
@@ -482,7 +487,6 @@ mod tests {
     );
     assert_eq!(episode_files, vec![episode_file()]);
   }
-  }
 
   #[tokio::test]
   async fn test_handle_get_sonarr_episode_history_event() {
@@ -569,11 +573,13 @@ mod tests {
     app_arc.lock().await.server_tabs.next();
     let mut network = test_network(&app_arc);
 
-    if let SonarrSerdeable::SonarrHistoryWrapper(history) = network
+    let SonarrSerdeable::SonarrHistoryWrapper(history) = network
       .handle_sonarr_event(SonarrEvent::GetEpisodeHistory(1))
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected SonarrHistoryWrapper")
+    };
     async_server.assert_async().await;
     assert_eq!(
       app_arc
@@ -608,7 +614,6 @@ mod tests {
     );
     assert_eq!(history, response);
   }
-  }
 
   #[tokio::test]
   async fn test_handle_get_sonarr_episode_history_event_empty_episode_details_modal() {
@@ -673,11 +678,13 @@ mod tests {
     app_arc.lock().await.server_tabs.next();
     let mut network = test_network(&app_arc);
 
-    if let SonarrSerdeable::SonarrHistoryWrapper(history) = network
+    let SonarrSerdeable::SonarrHistoryWrapper(history) = network
       .handle_sonarr_event(SonarrEvent::GetEpisodeHistory(1))
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected SonarrHistoryWrapper")
+    };
     async_server.assert_async().await;
     assert_eq!(
       app_arc
@@ -712,7 +719,6 @@ mod tests {
     );
     assert_eq!(history, response);
   }
-  }
 
   #[tokio::test]
   async fn test_handle_get_sonarr_episode_history_event_empty_season_details_modal() {
@@ -765,11 +771,13 @@ mod tests {
     app_arc.lock().await.server_tabs.next();
     let mut network = test_network(&app_arc);
 
-    if let SonarrSerdeable::SonarrHistoryWrapper(history) = network
+    let SonarrSerdeable::SonarrHistoryWrapper(history) = network
       .handle_sonarr_event(SonarrEvent::GetEpisodeHistory(1))
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected SonarrHistoryWrapper")
+    };
     async_server.assert_async().await;
     assert_eq!(
       app_arc
@@ -804,7 +812,6 @@ mod tests {
     );
     assert_eq!(history, response);
   }
-  }
 
   #[tokio::test]
   async fn test_handle_get_episode_details_event() {
@@ -827,11 +834,13 @@ mod tests {
     app_arc.lock().await.server_tabs.next();
     let mut network = test_network(&app_arc);
 
-    if let SonarrSerdeable::Episode(episode) = network
+    let SonarrSerdeable::Episode(episode) = network
       .handle_sonarr_event(SonarrEvent::GetEpisodeDetails(1))
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected Episode")
+    };
     async_server.assert_async().await;
     assert!(
       app_arc
@@ -918,7 +927,6 @@ mod tests {
       )
     );
   }
-  }
 
   #[tokio::test]
   async fn test_handle_get_episode_details_event_empty_episode_details_modal() {
@@ -938,11 +946,13 @@ mod tests {
     app_arc.lock().await.server_tabs.next();
     let mut network = test_network(&app_arc);
 
-    if let SonarrSerdeable::Episode(episode) = network
+    let SonarrSerdeable::Episode(episode) = network
       .handle_sonarr_event(SonarrEvent::GetEpisodeDetails(1))
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected Episode")
+    };
     async_server.assert_async().await;
     assert!(
       app_arc
@@ -1013,7 +1023,6 @@ mod tests {
       )
     );
   }
-  }
 
   #[tokio::test]
   async fn test_handle_get_episode_details_event_season_details_modal_not_required_in_cli_mode() {
@@ -1027,15 +1036,16 @@ mod tests {
     app_arc.lock().await.server_tabs.next();
     let mut network = test_network(&app_arc);
 
-    if let SonarrSerdeable::Episode(episode) = network
+    let SonarrSerdeable::Episode(episode) = network
       .handle_sonarr_event(SonarrEvent::GetEpisodeDetails(1))
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected Episode")
+    };
     async_server.assert_async().await;
     assert_eq!(episode, response);
   }
-  }
 
   #[tokio::test]
   #[should_panic(expected = "Season details modal is empty")]
@@ -1092,11 +1102,13 @@ mod tests {
     app_arc.lock().await.server_tabs.next();
     let mut network = test_network(&app_arc);
 
-    if let SonarrSerdeable::Releases(releases_vec) = network
+    let SonarrSerdeable::Releases(releases_vec) = network
       .handle_sonarr_event(SonarrEvent::GetEpisodeReleases(1))
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected Releases")
+    };
     async_server.assert_async().await;
     assert_eq!(
       app_arc
@@ -1116,7 +1128,6 @@ mod tests {
     );
     assert_eq!(releases_vec, vec![release()]);
   }
-  }
 
   #[tokio::test]
   async fn test_handle_get_episode_releases_event_empty_episode_details_modal() {
@@ -1146,11 +1157,13 @@ mod tests {
     app_arc.lock().await.server_tabs.next();
     let mut network = test_network(&app_arc);
 
-    if let SonarrSerdeable::Releases(releases_vec) = network
+    let SonarrSerdeable::Releases(releases_vec) = network
       .handle_sonarr_event(SonarrEvent::GetEpisodeReleases(1))
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected Releases")
+    };
     async_server.assert_async().await;
     assert_eq!(
       app_arc
@@ -1170,7 +1183,6 @@ mod tests {
     );
     assert_eq!(releases_vec, vec![release()]);
   }
-  }
 
   #[tokio::test]
   async fn test_handle_toggle_episode_monitoring_event() {

src/network/sonarr_network/library/seasons/sonarr_seasons_network_tests.rs

@@ -136,11 +136,13 @@ mod tests {
     app.lock().await.server_tabs.next();
     let mut network = test_network(&app);
 
-    if let SonarrSerdeable::Releases(releases_vec) = network
+    let SonarrSerdeable::Releases(releases_vec) = network
       .handle_sonarr_event(SonarrEvent::GetSeasonReleases((1, 1)))
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected Releases")
+    };
     mock.assert_async().await;
     assert_eq!(
       app
@@ -157,7 +159,6 @@ mod tests {
     );
     assert_eq!(releases_vec, expected_raw_sonarr_releases);
   }
-  }
 
   #[tokio::test]
   async fn test_handle_get_season_releases_event_empty_season_details_modal() {
@@ -319,11 +320,13 @@ mod tests {
     app.lock().await.server_tabs.next();
     let mut network = test_network(&app);
 
-    if let SonarrSerdeable::SonarrHistoryItems(history) = network
+    let SonarrSerdeable::SonarrHistoryItems(history) = network
       .handle_sonarr_event(SonarrEvent::GetSeasonHistory((1, 1)))
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected SonarrHistoryItems")
+    };
     mock.assert_async().await;
     assert_eq!(
       app
@@ -352,7 +355,6 @@ mod tests {
     );
     assert_eq!(history, response);
   }
-  }
 
   #[tokio::test]
   async fn test_handle_get_sonarr_season_history_event_empty_season_details_modal() {
@@ -419,11 +421,13 @@ mod tests {
     app.lock().await.server_tabs.next();
     let mut network = test_network(&app);
 
-    if let SonarrSerdeable::SonarrHistoryItems(history) = network
+    let SonarrSerdeable::SonarrHistoryItems(history) = network
       .handle_sonarr_event(SonarrEvent::GetSeasonHistory((1, 1)))
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected SonarrHistoryItems")
+    };
     mock.assert_async().await;
     assert!(
       app
@@ -461,7 +465,6 @@ mod tests {
     );
     assert_eq!(history, response);
   }
-  }
 
   #[tokio::test]
   async fn test_handle_trigger_automatic_season_search_event() {

src/network/sonarr_network/library/series/sonarr_series_network_tests.rs

@@ -409,15 +409,16 @@ mod tests {
     app.lock().await.server_tabs.next();
     let mut network = test_network(&app);
 
-    if let SonarrSerdeable::Series(series) = network
+    let SonarrSerdeable::Series(series) = network
       .handle_sonarr_event(SonarrEvent::GetSeriesDetails(1))
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected Series")
+    };
     async_server.assert_async().await;
     assert_eq!(series, expected_series);
   }
-  }
 
   #[rstest]
   #[tokio::test]
@@ -500,11 +501,13 @@ mod tests {
     app.lock().await.server_tabs.next();
     let mut network = test_network(&app);
 
-    if let SonarrSerdeable::SonarrHistoryItems(history_items) = network
+    let SonarrSerdeable::SonarrHistoryItems(history_items) = network
       .handle_sonarr_event(SonarrEvent::GetSeriesHistory(1))
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected SonarrHistoryItems")
+    };
     async_server.assert_async().await;
     assert!(app.lock().await.data.sonarr_data.series_history.is_some());
     assert_eq!(
@@ -532,7 +535,6 @@ mod tests {
     );
     assert_eq!(history_items, response);
   }
-  }
 
   #[tokio::test]
   async fn test_handle_get_sonarr_series_history_event_empty_series_history_table() {
@@ -592,11 +594,13 @@ mod tests {
     app.lock().await.server_tabs.next();
     let mut network = test_network(&app);
 
-    if let SonarrSerdeable::SonarrHistoryItems(history_items) = network
+    let SonarrSerdeable::SonarrHistoryItems(history_items) = network
       .handle_sonarr_event(SonarrEvent::GetSeriesHistory(1))
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected SonarrHistoryItems")
+    };
     async_server.assert_async().await;
     assert!(app.lock().await.data.sonarr_data.series_history.is_some());
     assert_eq!(
@@ -624,7 +628,6 @@ mod tests {
     );
     assert_eq!(history_items, response);
   }
-  }
 
   #[tokio::test]
   async fn test_handle_get_sonarr_series_history_event_no_op_when_user_is_selecting_sort_options() {
@@ -690,11 +693,13 @@ mod tests {
     app.lock().await.server_tabs.next();
     let mut network = test_network(&app);
 
-    if let SonarrSerdeable::SonarrHistoryItems(history_items) = network
+    let SonarrSerdeable::SonarrHistoryItems(history_items) = network
       .handle_sonarr_event(SonarrEvent::GetSeriesHistory(1))
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected SonarrHistoryItems")
+    };
     async_server.assert_async().await;
     assert!(app.lock().await.data.sonarr_data.series_history.is_some());
     assert!(
@@ -721,7 +726,6 @@ mod tests {
     );
     assert_eq!(history_items, response);
   }
-  }
 
   #[rstest]
   #[tokio::test]
@@ -784,11 +788,13 @@ mod tests {
     app.lock().await.server_tabs.next();
     let mut network = test_network(&app);
 
-    if let SonarrSerdeable::SeriesVec(series) = network
+    let SonarrSerdeable::SeriesVec(series) = network
       .handle_sonarr_event(SonarrEvent::ListSeries)
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected SeriesVec")
+    };
     async_server.assert_async().await;
     assert_eq!(
       app.lock().await.data.sonarr_data.series.items,
@@ -797,7 +803,6 @@ mod tests {
     assert!(app.lock().await.data.sonarr_data.series.sort_asc);
     assert_eq!(series, expected_series);
   }
-  }
 
   #[tokio::test]
   async fn test_handle_list_series_event_no_op_while_user_is_selecting_sort_options() {
@@ -872,11 +877,13 @@ mod tests {
     app.lock().await.server_tabs.next();
     let mut network = test_network(&app);
 
-    if let SonarrSerdeable::AddSeriesSearchResults(add_series_search_results) = network
+    let SonarrSerdeable::AddSeriesSearchResults(add_series_search_results) = network
       .handle_sonarr_event(SonarrEvent::SearchNewSeries("test term".into()))
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected AddSeriesSearchResults")
+    };
     async_server.assert_async().await;
     assert!(
       app
@@ -901,7 +908,6 @@ mod tests {
     );
     assert_eq!(add_series_search_results, vec![add_series_search_result()]);
   }
-  }
 
   #[tokio::test]
   async fn test_handle_search_new_series_event_no_results() {

src/network/sonarr_network/root_folders/sonarr_root_folders_network_tests.rs

@@ -71,11 +71,13 @@ mod tests {
     app.lock().await.server_tabs.next();
     let mut network = test_network(&app);
 
-    if let SonarrSerdeable::RootFolders(root_folders) = network
+    let SonarrSerdeable::RootFolders(root_folders) = network
       .handle_sonarr_event(SonarrEvent::GetRootFolders)
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected RootFolders")
+    };
     mock.assert_async().await;
     assert_eq!(
       app.lock().await.data.sonarr_data.root_folders.items,
@@ -83,5 +85,4 @@ mod tests {
     );
     assert_eq!(root_folders, response);
   }
-  }
 }

src/network/sonarr_network/sonarr_network_tests.rs

@@ -212,8 +212,9 @@ mod test {
     mock.assert_async().await;
 
     let SonarrSerdeable::Tag(tag) = result.unwrap() else {
-      panic!("Expected Tag variant");
+      panic!("Expected Tag");
     };
+
     assert_eq!(tag, expected);
     assert_eq!(
       app.lock().await.data.sonarr_data.tags_map,
@@ -278,8 +279,9 @@ mod test {
     mock.assert_async().await;
 
     let SonarrSerdeable::LanguageProfiles(language_profiles) = result.unwrap() else {
-      panic!("Expected the LanguageProfiles variant")
+      panic!("Expected LanguageProfiles")
     };
+
     assert_eq!(
       app.lock().await.data.sonarr_data.language_profiles_map,
       BiMap::from_iter([(2222i64, "English".to_owned())])
@@ -309,8 +311,9 @@ mod test {
     mock.assert_async().await;
 
     let SonarrSerdeable::QualityProfiles(quality_profiles) = result.unwrap() else {
-      panic!("Expected the QualityProfiles variant")
+      panic!("Expected QualityProfiles")
     };
+
     assert_eq!(
       app.lock().await.data.sonarr_data.quality_profile_map,
       BiMap::from_iter([(2222i64, "HD - 1080p".to_owned())])
@@ -337,8 +340,9 @@ mod test {
     mock.assert_async().await;
 
     let SonarrSerdeable::Tags(tags) = result.unwrap() else {
-      panic!("Expected the Tag variant")
+      panic!("Expected Tags")
     };
+
     mock.assert_async().await;
     assert_eq!(
       app.lock().await.data.sonarr_data.tags_map,

src/network/sonarr_network/system/sonarr_system_network_tests.rs

@@ -33,15 +33,16 @@ mod tests {
     app.lock().await.server_tabs.next();
     let mut network = test_network(&app);
 
-    if let SonarrSerdeable::HostConfig(host_config) = network
+    let SonarrSerdeable::HostConfig(host_config) = network
       .handle_sonarr_event(SonarrEvent::GetHostConfig)
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected HostConfig")
+    };
     mock.assert_async().await;
     assert_eq!(host_config, response);
   }
-  }
 
   #[tokio::test]
   async fn test_handle_get_sonarr_logs_event() {
@@ -84,11 +85,13 @@ mod tests {
     app.lock().await.server_tabs.next();
     let mut network = test_network(&app);
 
-    if let SonarrSerdeable::LogResponse(logs) = network
+    let SonarrSerdeable::LogResponse(logs) = network
       .handle_sonarr_event(SonarrEvent::GetLogs(500))
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected LogResponse")
+    };
     mock.assert_async().await;
     assert_eq!(app.lock().await.data.sonarr_data.logs.items, expected_logs);
     assert!(
@@ -104,7 +107,6 @@ mod tests {
     );
     assert_eq!(logs, response);
   }
-  }
 
   #[tokio::test]
   async fn test_handle_get_sonarr_diskspace_event() {
@@ -134,11 +136,13 @@ mod tests {
       },
     ];
 
-    if let SonarrSerdeable::DiskSpaces(disk_space) = network
+    let SonarrSerdeable::DiskSpaces(disk_space) = network
       .handle_sonarr_event(SonarrEvent::GetDiskSpace)
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected DiskSpaces")
+    };
     mock.assert_async().await;
     assert_eq!(
       app.lock().await.data.sonarr_data.disk_space_vec,
@@ -146,7 +150,6 @@ mod tests {
     );
     assert_eq!(disk_space, disk_space_vec);
   }
-  }
 
   #[tokio::test]
   async fn test_handle_get_queued_sonarr_events_event() {
@@ -180,11 +183,13 @@ mod tests {
     app.lock().await.server_tabs.next();
     let mut network = test_network(&app);
 
-    if let SonarrSerdeable::QueueEvents(events) = network
+    let SonarrSerdeable::QueueEvents(events) = network
       .handle_sonarr_event(SonarrEvent::GetQueuedEvents)
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected QueueEvents")
+    };
     mock.assert_async().await;
     assert_eq!(
       app.lock().await.data.sonarr_data.queued_events.items,
@@ -192,7 +197,6 @@ mod tests {
     );
     assert_eq!(events, response);
   }
-  }
 
   #[tokio::test]
   async fn test_handle_get_sonarr_security_config_event() {
@@ -213,15 +217,16 @@ mod tests {
     app.lock().await.server_tabs.next();
     let mut network = test_network(&app);
 
-    if let SonarrSerdeable::SecurityConfig(security_config) = network
+    let SonarrSerdeable::SecurityConfig(security_config) = network
       .handle_sonarr_event(SonarrEvent::GetSecurityConfig)
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected SecurityConfig")
+    };
     mock.assert_async().await;
     assert_eq!(security_config, response);
   }
-  }
 
   #[tokio::test]
   async fn test_handle_get_status_event() {
@@ -236,11 +241,13 @@ mod tests {
     let mut network = test_network(&app);
     let date_time = DateTime::from(DateTime::parse_from_rfc3339("2023-02-25T20:16:43Z").unwrap());
 
-    if let SonarrSerdeable::SystemStatus(status) = network
+    let SonarrSerdeable::SystemStatus(status) = network
       .handle_sonarr_event(SonarrEvent::GetStatus)
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected SystemStatus")
+    };
     mock.assert_async().await;
     assert_str_eq!(app.lock().await.data.sonarr_data.version, "v1");
     assert_eq!(app.lock().await.data.sonarr_data.start_time, date_time);
@@ -252,7 +259,6 @@ mod tests {
       }
     );
   }
-  }
 
   #[tokio::test]
   async fn test_handle_get_sonarr_tasks_event() {
@@ -295,11 +301,13 @@ mod tests {
     app.lock().await.server_tabs.next();
     let mut network = test_network(&app);
 
-    if let SonarrSerdeable::Tasks(tasks) = network
+    let SonarrSerdeable::Tasks(tasks) = network
       .handle_sonarr_event(SonarrEvent::GetTasks)
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected Tasks")
+    };
     mock.assert_async().await;
     assert_eq!(
       app.lock().await.data.sonarr_data.tasks.items,
@@ -307,7 +315,6 @@ mod tests {
     );
     assert_eq!(tasks, response);
   }
-  }
 
   #[tokio::test]
   async fn test_handle_get_sonarr_updates_event() {
@@ -385,11 +392,13 @@ mod tests {
     app.lock().await.server_tabs.next();
     let mut network = test_network(&app);
 
-    if let SonarrSerdeable::Updates(updates) = network
+    let SonarrSerdeable::Updates(updates) = network
       .handle_sonarr_event(SonarrEvent::GetUpdates)
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected Updates")
+    };
     mock.assert_async().await;
     let actual_text = app.lock().await.data.sonarr_data.updates.get_text();
     let expected = expected_text.get_text();
@@ -404,7 +413,6 @@ mod tests {
     );
     assert_eq!(updates, response);
   }
-  }
 
   #[tokio::test]
   async fn test_handle_start_sonarr_task_event() {
@@ -431,15 +439,16 @@ mod tests {
     app.lock().await.server_tabs.next();
     let mut network = test_network(&app);
 
-    if let SonarrSerdeable::Value(value) = network
+    let SonarrSerdeable::Value(value) = network
       .handle_sonarr_event(SonarrEvent::StartTask(
         SonarrTaskName::ApplicationUpdateCheck,
       ))
       .await
       .unwrap()
-    {
+    else {
+      panic!("Expected Value")
+    };
     mock.assert_async().await;
     assert_eq!(value, response);
   }
-  }
 }

src/ui/radarr_ui/blocklist/mod.rs

@@ -23,11 +23,10 @@ pub(super) struct BlocklistUi;
 
 impl DrawUi for BlocklistUi {
   fn accepts(route: Route) -> bool {
-    if let Route::Radarr(active_radarr_block, _) = route {
+    let Route::Radarr(active_radarr_block, _) = route else {
-      return BLOCKLIST_BLOCKS.contains(&active_radarr_block);
+      return false;
-    }
+    };
-
+    BLOCKLIST_BLOCKS.contains(&active_radarr_block)
-    false
   }
 
   fn draw(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) {

src/ui/radarr_ui/collections/mod.rs

@@ -25,13 +25,12 @@ pub(super) struct CollectionsUi;
 
 impl DrawUi for CollectionsUi {
   fn accepts(route: Route) -> bool {
-    if let Route::Radarr(active_radarr_block, _) = route {
+    let Route::Radarr(active_radarr_block, _) = route else {
-      return CollectionDetailsUi::accepts(route)
+      return false;
+    };
+    CollectionDetailsUi::accepts(route)
       || EditCollectionUi::accepts(route)
-        || COLLECTIONS_BLOCKS.contains(&active_radarr_block);
+      || COLLECTIONS_BLOCKS.contains(&active_radarr_block)
-    }
-
-    false
   }
 
   fn draw(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) {

src/ui/radarr_ui/downloads/mod.rs

@@ -22,11 +22,10 @@ pub(super) struct DownloadsUi;
 
 impl DrawUi for DownloadsUi {
   fn accepts(route: Route) -> bool {
-    if let Route::Radarr(active_radarr_block, _) = route {
+    let Route::Radarr(active_radarr_block, _) = route else {
-      return DOWNLOADS_BLOCKS.contains(&active_radarr_block);
+      return false;
-    }
+    };
-
+    DOWNLOADS_BLOCKS.contains(&active_radarr_block)
-    false
   }
 
   fn draw(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) {

src/ui/radarr_ui/indexers/indexer_settings_ui.rs

@@ -26,11 +26,10 @@ pub(super) struct IndexerSettingsUi;
 
 impl DrawUi for IndexerSettingsUi {
   fn accepts(route: Route) -> bool {
-    if let Route::Radarr(active_radarr_block, _) = route {
+    let Route::Radarr(active_radarr_block, _) = route else {
-      return INDEXER_SETTINGS_BLOCKS.contains(&active_radarr_block);
+      return false;
-    }
+    };
-
+    INDEXER_SETTINGS_BLOCKS.contains(&active_radarr_block)
-    false
   }
 
   fn draw(f: &mut Frame<'_>, app: &mut App<'_>, _area: Rect) {

src/ui/radarr_ui/indexers/test_all_indexers_ui.rs

@@ -19,11 +19,10 @@ pub(super) struct TestAllIndexersUi;
 
 impl DrawUi for TestAllIndexersUi {
   fn accepts(route: Route) -> bool {
-    if let Route::Radarr(active_radarr_block, _) = route {
+    let Route::Radarr(active_radarr_block, _) = route else {
-      return active_radarr_block == ActiveRadarrBlock::TestAllIndexers;
+      return false;
-    }
+    };
-
+    active_radarr_block == ActiveRadarrBlock::TestAllIndexers
-    false
   }
 
   fn draw(f: &mut Frame<'_>, app: &mut App<'_>, _area: Rect) {

src/ui/radarr_ui/library/add_movie_ui.rs

@@ -31,11 +31,10 @@ pub(super) struct AddMovieUi;
 
 impl DrawUi for AddMovieUi {
   fn accepts(route: Route) -> bool {
-    if let Route::Radarr(active_radarr_block, _) = route {
+    let Route::Radarr(active_radarr_block, _) = route else {
-      return ADD_MOVIE_BLOCKS.contains(&active_radarr_block);
+      return false;
-    }
+    };
-
+    ADD_MOVIE_BLOCKS.contains(&active_radarr_block)
-    false
   }
 
   fn draw(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) {

src/ui/radarr_ui/library/delete_movie_ui.rs

@@ -17,11 +17,10 @@ pub(super) struct DeleteMovieUi;
 
 impl DrawUi for DeleteMovieUi {
   fn accepts(route: Route) -> bool {
-    if let Route::Radarr(active_radarr_block, _) = route {
+    let Route::Radarr(active_radarr_block, _) = route else {
-      return DELETE_MOVIE_BLOCKS.contains(&active_radarr_block);
+      return false;
-    }
+    };
-
+    DELETE_MOVIE_BLOCKS.contains(&active_radarr_block)
-    false
   }
 
   fn draw(f: &mut Frame<'_>, app: &mut App<'_>, _area: Rect) {

src/ui/radarr_ui/library/edit_movie_ui.rs

@@ -31,11 +31,10 @@ pub(super) struct EditMovieUi;
 
 impl DrawUi for EditMovieUi {
   fn accepts(route: Route) -> bool {
-    if let Route::Radarr(active_radarr_block, _) = route {
+    let Route::Radarr(active_radarr_block, _) = route else {
-      return EDIT_MOVIE_BLOCKS.contains(&active_radarr_block);
+      return false;
-    }
+    };
-
+    EDIT_MOVIE_BLOCKS.contains(&active_radarr_block)
-    false
   }
 
   fn draw(f: &mut Frame<'_>, app: &mut App<'_>, _area: Rect) {

src/ui/radarr_ui/library/movie_details_ui.rs

@@ -32,11 +32,10 @@ pub(super) struct MovieDetailsUi;
 
 impl DrawUi for MovieDetailsUi {
   fn accepts(route: Route) -> bool {
-    if let Route::Radarr(active_radarr_block, _) = route {
+    let Route::Radarr(active_radarr_block, _) = route else {
-      return MOVIE_DETAILS_BLOCKS.contains(&active_radarr_block);
+      return false;
-    }
+    };
-
+    MOVIE_DETAILS_BLOCKS.contains(&active_radarr_block)
-    false
   }
 
   fn draw(f: &mut Frame<'_>, app: &mut App<'_>, _area: Rect) {

src/ui/radarr_ui/root_folders/mod.rs

@@ -22,11 +22,10 @@ pub(super) struct RootFoldersUi;
 
 impl DrawUi for RootFoldersUi {
   fn accepts(route: Route) -> bool {
-    if let Route::Radarr(active_radarr_block, _) = route {
+    let Route::Radarr(active_radarr_block, _) = route else {
-      return ROOT_FOLDERS_BLOCKS.contains(&active_radarr_block);
+      return false;
-    }
+    };
-
+    ROOT_FOLDERS_BLOCKS.contains(&active_radarr_block)
-    false
   }
 
   fn draw(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) {

src/ui/radarr_ui/system/mod.rs

@@ -52,11 +52,10 @@ pub(super) struct SystemUi;
 
 impl DrawUi for SystemUi {
   fn accepts(route: Route) -> bool {
-    if let Route::Radarr(active_radarr_block, _) = route {
+    let Route::Radarr(active_radarr_block, _) = route else {
-      return SystemDetailsUi::accepts(route) || active_radarr_block == ActiveRadarrBlock::System;
+      return false;
-    }
+    };
-
+    SystemDetailsUi::accepts(route) || active_radarr_block == ActiveRadarrBlock::System
-    false
   }
 
   fn draw(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) {

src/ui/radarr_ui/system/system_details_ui.rs

@@ -27,11 +27,10 @@ pub(super) struct SystemDetailsUi;
 
 impl DrawUi for SystemDetailsUi {
   fn accepts(route: Route) -> bool {
-    if let Route::Radarr(active_radarr_block, _) = route {
+    let Route::Radarr(active_radarr_block, _) = route else {
-      return SYSTEM_DETAILS_BLOCKS.contains(&active_radarr_block);
+      return false;
-    }
+    };
-
+    SYSTEM_DETAILS_BLOCKS.contains(&active_radarr_block)
-    false
   }
 
   fn draw(f: &mut Frame<'_>, app: &mut App<'_>, _area: Rect) {

src/ui/sonarr_ui/indexers/edit_indexer_ui.rs

@@ -23,11 +23,10 @@ pub(super) struct EditIndexerUi;
 
 impl DrawUi for EditIndexerUi {
   fn accepts(route: Route) -> bool {
-    if let Route::Sonarr(active_sonarr_block, _) = route {
+    let Route::Sonarr(active_sonarr_block, _) = route else {
-      return EDIT_INDEXER_BLOCKS.contains(&active_sonarr_block);
+      return false;
-    }
+    };
-
+    EDIT_INDEXER_BLOCKS.contains(&active_sonarr_block)
-    false
   }
 
   fn draw(f: &mut Frame<'_>, app: &mut App<'_>, _area: Rect) {

src/ui/sonarr_ui/indexers/indexer_settings_ui.rs

@@ -23,11 +23,10 @@ pub(super) struct IndexerSettingsUi;
 
 impl DrawUi for IndexerSettingsUi {
   fn accepts(route: Route) -> bool {
-    if let Route::Sonarr(active_sonarr_block, _) = route {
+    let Route::Sonarr(active_sonarr_block, _) = route else {
-      return INDEXER_SETTINGS_BLOCKS.contains(&active_sonarr_block);
+      return false;
-    }
+    };
-
+    INDEXER_SETTINGS_BLOCKS.contains(&active_sonarr_block)
-    false
   }
 
   fn draw(f: &mut Frame<'_>, app: &mut App<'_>, _area: Rect) {

src/ui/sonarr_ui/library/add_series_ui.rs

@@ -30,11 +30,10 @@ pub(super) struct AddSeriesUi;
 
 impl DrawUi for AddSeriesUi {
   fn accepts(route: Route) -> bool {
-    if let Route::Sonarr(active_sonarr_block, _) = route {
+    let Route::Sonarr(active_sonarr_block, _) = route else {
-      return ADD_SERIES_BLOCKS.contains(&active_sonarr_block);
+      return false;
-    }
+    };
-
+    ADD_SERIES_BLOCKS.contains(&active_sonarr_block)
-    false
   }
 
   fn draw(f: &mut Frame<'_>, app: &mut App<'_>, _area: Rect) {

src/ui/sonarr_ui/library/delete_series_ui.rs

@@ -17,11 +17,10 @@ pub(super) struct DeleteSeriesUi;
 
 impl DrawUi for DeleteSeriesUi {
   fn accepts(route: Route) -> bool {
-    if let Route::Sonarr(active_sonarr_block, _) = route {
+    let Route::Sonarr(active_sonarr_block, _) = route else {
-      return DELETE_SERIES_BLOCKS.contains(&active_sonarr_block);
+      return false;
-    }
+    };
-
+    DELETE_SERIES_BLOCKS.contains(&active_sonarr_block)
-    false
   }
 
   fn draw(f: &mut Frame<'_>, app: &mut App<'_>, _area: Rect) {

src/ui/sonarr_ui/library/edit_series_ui.rs

@@ -32,11 +32,10 @@ pub(super) struct EditSeriesUi;
 
 impl DrawUi for EditSeriesUi {
   fn accepts(route: Route) -> bool {
-    if let Route::Sonarr(active_sonarr_block, _) = route {
+    let Route::Sonarr(active_sonarr_block, _) = route else {
-      return EDIT_SERIES_BLOCKS.contains(&active_sonarr_block);
+      return false;
-    }
+    };
-
+    EDIT_SERIES_BLOCKS.contains(&active_sonarr_block)
-    false
   }
 
   fn draw(f: &mut Frame<'_>, app: &mut App<'_>, _area: Rect) {

src/ui/sonarr_ui/library/episode_details_ui.rs

@@ -39,11 +39,10 @@ pub(super) struct EpisodeDetailsUi;
 
 impl DrawUi for EpisodeDetailsUi {
   fn accepts(route: Route) -> bool {
-    if let Route::Sonarr(active_sonarr_block, _) = route {
+    let Route::Sonarr(active_sonarr_block, _) = route else {
-      return EPISODE_DETAILS_BLOCKS.contains(&active_sonarr_block);
+      return false;
-    }
+    };
-
+    EPISODE_DETAILS_BLOCKS.contains(&active_sonarr_block)
-    false
   }
 
   fn draw(f: &mut Frame<'_>, app: &mut App<'_>, _area: Rect) {

src/ui/sonarr_ui/library/season_details_ui.rs

@@ -38,12 +38,10 @@ pub(super) struct SeasonDetailsUi;
 
 impl DrawUi for SeasonDetailsUi {
   fn accepts(route: Route) -> bool {
-    if let Route::Sonarr(active_sonarr_block, _) = route {
+    let Route::Sonarr(active_sonarr_block, _) = route else {
-      return EpisodeDetailsUi::accepts(route)
+      return false;
-        || SEASON_DETAILS_BLOCKS.contains(&active_sonarr_block);
+    };
-    }
+    EpisodeDetailsUi::accepts(route) || SEASON_DETAILS_BLOCKS.contains(&active_sonarr_block)
-
-    false
   }
 
   fn draw(f: &mut Frame<'_>, app: &mut App<'_>, _area: Rect) {

src/ui/sonarr_ui/library/series_details_ui.rs

@@ -42,13 +42,12 @@ pub(super) struct SeriesDetailsUi;
 
 impl DrawUi for SeriesDetailsUi {
   fn accepts(route: Route) -> bool {
-    if let Route::Sonarr(active_sonarr_block, _) = route {
+    let Route::Sonarr(active_sonarr_block, _) = route else {
-      return SeasonDetailsUi::accepts(route)
+      return false;
+    };
+    SeasonDetailsUi::accepts(route)
       || EpisodeDetailsUi::accepts(route)
-        || SERIES_DETAILS_BLOCKS.contains(&active_sonarr_block);
+      || SERIES_DETAILS_BLOCKS.contains(&active_sonarr_block)
-    }
-
-    false
   }
 
   fn draw(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) {

src/ui/sonarr_ui/system/mod.rs

@@ -46,11 +46,10 @@ pub(super) struct SystemUi;
 
 impl DrawUi for SystemUi {
   fn accepts(route: Route) -> bool {
-    if let Route::Sonarr(active_sonarr_block, _) = route {
+    let Route::Sonarr(active_sonarr_block, _) = route else {
-      return SystemDetailsUi::accepts(route) || active_sonarr_block == ActiveSonarrBlock::System;
+      return false;
-    }
+    };
-
+    SystemDetailsUi::accepts(route) || active_sonarr_block == ActiveSonarrBlock::System
-    false
   }
 
   fn draw(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) {

src/ui/sonarr_ui/system/system_details_ui.rs

@@ -27,11 +27,10 @@ pub(super) struct SystemDetailsUi;
 
 impl DrawUi for SystemDetailsUi {
   fn accepts(route: Route) -> bool {
-    if let Route::Sonarr(active_sonarr_block, _) = route {
+    let Route::Sonarr(active_sonarr_block, _) = route else {
-      return SYSTEM_DETAILS_BLOCKS.contains(&active_sonarr_block);
+      return false;
-    }
+    };
-
+    SYSTEM_DETAILS_BLOCKS.contains(&active_sonarr_block)
-    false
   }
 
   fn draw(f: &mut Frame<'_>, app: &mut App<'_>, _area: Rect) {