test: Updated Rust edition to 2024 and refactored network module tests to be more idiomatic

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

@@ -7,43 +7,37 @@ mod tests {
     SonarrHistoryWrapper, SonarrSerdeable,
   };
   use crate::models::stateful_table::SortOption;
-  use crate::network::network_tests::test_utils::mock_servarr_api;
+  use crate::network::NetworkResource;
+  use crate::network::network_tests::test_utils::{MockServarrApi, test_network};
+  use crate::network::sonarr_network::SonarrEvent;
   use crate::network::sonarr_network::library::episodes::get_episode_status;
   use crate::network::sonarr_network::sonarr_network_test_utils::test_utils::{
-    episode, episode_file, history_item, release, EPISODE_JSON,
+    EPISODE_JSON, episode, episode_file, history_item, release,
   };
-  use crate::network::sonarr_network::SonarrEvent;
-  use crate::network::{Network, NetworkResource, RequestMethod};
   use indoc::formatdoc;
   use mockito::Matcher;
   use pretty_assertions::{assert_eq, assert_str_eq};
-  use reqwest::Client;
   use rstest::rstest;
-  use serde_json::{json, Number};
+  use serde_json::{Number, json};
   use std::slice;
-  use tokio_util::sync::CancellationToken;
 
   #[tokio::test]
   async fn test_handle_delete_sonarr_episode_file_event() {
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Delete,
-      None,
-      None,
-      None,
-      SonarrEvent::DeleteEpisodeFile(1),
-      Some("/1"),
-      None,
-    )
-    .await;
+    let (async_server, app_arc, _server) = MockServarrApi::delete()
+      .path("/1")
+      .build_for(SonarrEvent::DeleteEpisodeFile(1))
+      .await;
     app_arc.lock().await.data.sonarr_data.season_details_modal =
       Some(SeasonDetailsModal::default());
     app_arc.lock().await.server_tabs.next();
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let mut network = test_network(&app_arc);
 
-    assert!(network
-      .handle_sonarr_event(SonarrEvent::DeleteEpisodeFile(1))
-      .await
-      .is_ok());
+    assert!(
+      network
+        .handle_sonarr_event(SonarrEvent::DeleteEpisodeFile(1))
+        .await
+        .is_ok()
+    );
 
     async_server.assert_async().await;
   }
@@ -76,16 +70,11 @@ mod tests {
     };
     let expected_episodes = vec![episode_1.clone(), episode_2.clone(), episode_3.clone()];
     let mut expected_sorted_episodes = vec![episode_1.clone(), episode_3.clone()];
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(json!([episode_1, episode_2, episode_3])),
-      None,
-      SonarrEvent::GetEpisodes(1),
-      None,
-      Some("seriesId=1"),
-    )
-    .await;
+    let (mock, app, _server) = MockServarrApi::get()
+      .query("seriesId=1")
+      .returns(json!([episode_1, episode_2, episode_3]))
+      .build_for(SonarrEvent::GetEpisodes(1))
+      .await;
     let mut season_details_modal = SeasonDetailsModal::default();
     season_details_modal.episodes.sort_asc = true;
     if use_custom_sorting {
@@ -99,8 +88,8 @@ mod tests {
         .episodes
         .sorting(vec![title_sort_option]);
     }
-    app_arc.lock().await.data.sonarr_data.season_details_modal = Some(season_details_modal);
-    app_arc
+    app.lock().await.data.sonarr_data.season_details_modal = Some(season_details_modal);
+    app
       .lock()
       .await
       .data
@@ -110,7 +99,7 @@ mod tests {
         id: 1,
         ..Series::default()
       }]);
-    app_arc
+    app
       .lock()
       .await
       .data
@@ -120,42 +109,44 @@ mod tests {
         season_number: 1,
         ..Season::default()
       }]);
-    app_arc.lock().await.server_tabs.next();
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    app.lock().await.server_tabs.next();
+    let mut network = test_network(&app);
 
-    if let SonarrSerdeable::Episodes(episodes) = network
+    let result = network
       .handle_sonarr_event(SonarrEvent::GetEpisodes(1))
-      .await
-      .unwrap()
-    {
-      async_server.assert_async().await;
-      assert_eq!(
-        app_arc
-          .lock()
-          .await
-          .data
-          .sonarr_data
-          .season_details_modal
-          .as_ref()
-          .unwrap()
-          .episodes
-          .items,
-        expected_sorted_episodes
-      );
-      assert!(
-        app_arc
-          .lock()
-          .await
-          .data
-          .sonarr_data
-          .season_details_modal
-          .as_ref()
-          .unwrap()
-          .episodes
-          .sort_asc
-      );
-      assert_eq!(episodes, expected_episodes);
-    }
+      .await;
+
+    mock.assert_async().await;
+
+    let SonarrSerdeable::Episodes(episodes) = result.unwrap() else {
+      panic!("Expected Episodes variant")
+    };
+    assert_eq!(
+      app
+        .lock()
+        .await
+        .data
+        .sonarr_data
+        .season_details_modal
+        .as_ref()
+        .unwrap()
+        .episodes
+        .items,
+      expected_sorted_episodes
+    );
+    assert!(
+      app
+        .lock()
+        .await
+        .data
+        .sonarr_data
+        .season_details_modal
+        .as_ref()
+        .unwrap()
+        .episodes
+        .sort_asc
+    );
+    assert_eq!(episodes, expected_episodes);
   }
 
   #[tokio::test]
@@ -184,20 +175,15 @@ mod tests {
       ..episode()
     };
     let expected_episodes = vec![episode_1.clone(), episode_2.clone(), episode_3.clone()];
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(json!([episode_1, episode_2, episode_3])),
-      None,
-      SonarrEvent::GetEpisodes(1),
-      None,
-      Some("seriesId=1"),
-    )
-    .await;
+    let (mock, app, _server) = MockServarrApi::get()
+      .query("seriesId=1")
+      .returns(json!([episode_1, episode_2, episode_3]))
+      .build_for(SonarrEvent::GetEpisodes(1))
+      .await;
     let mut season_details_modal = SeasonDetailsModal::default();
     season_details_modal.episodes.sort_asc = true;
-    app_arc.lock().await.data.sonarr_data.season_details_modal = Some(season_details_modal);
-    app_arc
+    app.lock().await.data.sonarr_data.season_details_modal = Some(season_details_modal);
+    app
       .lock()
       .await
       .data
@@ -207,56 +193,53 @@ mod tests {
         id: 1,
         ..Series::default()
       }]);
-    app_arc.lock().await.server_tabs.next();
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    app.lock().await.server_tabs.next();
+    let mut network = test_network(&app);
 
-    if let SonarrSerdeable::Episodes(episodes) = network
+    let result = network
       .handle_sonarr_event(SonarrEvent::GetEpisodes(1))
-      .await
-      .unwrap()
-    {
-      async_server.assert_async().await;
-      assert_eq!(
-        app_arc
-          .lock()
-          .await
-          .data
-          .sonarr_data
-          .season_details_modal
-          .as_ref()
-          .unwrap()
-          .episodes
-          .items,
-        expected_episodes
-      );
-      assert!(
-        app_arc
-          .lock()
-          .await
-          .data
-          .sonarr_data
-          .season_details_modal
-          .as_ref()
-          .unwrap()
-          .episodes
-          .sort_asc
-      );
-      assert_eq!(episodes, expected_episodes);
-    }
+      .await;
+
+    mock.assert_async().await;
+
+    let SonarrSerdeable::Episodes(episodes) = result.unwrap() else {
+      panic!("Expected Episodes variant")
+    };
+    assert_eq!(
+      app
+        .lock()
+        .await
+        .data
+        .sonarr_data
+        .season_details_modal
+        .as_ref()
+        .unwrap()
+        .episodes
+        .items,
+      expected_episodes
+    );
+    assert!(
+      app
+        .lock()
+        .await
+        .data
+        .sonarr_data
+        .season_details_modal
+        .as_ref()
+        .unwrap()
+        .episodes
+        .sort_asc
+    );
+    assert_eq!(episodes, expected_episodes);
   }
 
   #[tokio::test]
   async fn test_handle_get_episodes_event_empty_season_details_modal() {
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(json!([episode()])),
-      None,
-      SonarrEvent::GetEpisodes(1),
-      None,
-      Some("seriesId=1"),
-    )
-    .await;
+    let (async_server, app_arc, _server) = MockServarrApi::get()
+      .returns(json!([episode()]))
+      .query("seriesId=1")
+      .build_for(SonarrEvent::GetEpisodes(1))
+      .await;
     app_arc
       .lock()
       .await
@@ -268,7 +251,7 @@ mod tests {
         ..Series::default()
       }]);
     app_arc.lock().await.server_tabs.next();
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let mut network = test_network(&app_arc);
 
     if let SonarrSerdeable::Episodes(episodes) = network
       .handle_sonarr_event(SonarrEvent::GetEpisodes(1))
@@ -336,16 +319,11 @@ mod tests {
       ..episode()
     };
     let mut expected_episodes = vec![episode_2.clone(), episode_1.clone()];
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(episodes_json),
-      None,
-      SonarrEvent::GetEpisodes(1),
-      None,
-      Some("seriesId=1"),
-    )
-    .await;
+    let (async_server, app_arc, _server) = MockServarrApi::get()
+      .returns(episodes_json)
+      .query("seriesId=1")
+      .build_for(SonarrEvent::GetEpisodes(1))
+      .await;
     app_arc
       .lock()
       .await
@@ -373,7 +351,7 @@ mod tests {
       }]);
     app_arc.lock().await.data.sonarr_data.season_details_modal = Some(season_details_modal);
     app_arc.lock().await.server_tabs.next();
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let mut network = test_network(&app_arc);
 
     if let SonarrSerdeable::Episodes(episodes) = network
       .handle_sonarr_event(SonarrEvent::GetEpisodes(1))
@@ -381,16 +359,18 @@ mod tests {
       .unwrap()
     {
       async_server.assert_async().await;
-      assert!(app_arc
-        .lock()
-        .await
-        .data
-        .sonarr_data
-        .season_details_modal
-        .as_ref()
-        .unwrap()
-        .episodes
-        .is_empty());
+      assert!(
+        app_arc
+          .lock()
+          .await
+          .data
+          .sonarr_data
+          .season_details_modal
+          .as_ref()
+          .unwrap()
+          .episodes
+          .is_empty()
+      );
       assert!(
         app_arc
           .lock()
@@ -409,16 +389,11 @@ mod tests {
 
   #[tokio::test]
   async fn test_handle_get_episode_files_event() {
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(json!([episode_file()])),
-      None,
-      SonarrEvent::GetEpisodeFiles(1),
-      None,
-      Some("seriesId=1"),
-    )
-    .await;
+    let (async_server, app_arc, _server) = MockServarrApi::get()
+      .returns(json!([episode_file()]))
+      .query("seriesId=1")
+      .build_for(SonarrEvent::GetEpisodeFiles(1))
+      .await;
     app_arc.lock().await.data.sonarr_data.season_details_modal =
       Some(SeasonDetailsModal::default());
     app_arc
@@ -432,7 +407,7 @@ mod tests {
         ..Series::default()
       }]);
     app_arc.lock().await.server_tabs.next();
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let mut network = test_network(&app_arc);
 
     if let SonarrSerdeable::EpisodeFiles(episode_files) = network
       .handle_sonarr_event(SonarrEvent::GetEpisodeFiles(1))
@@ -459,16 +434,11 @@ mod tests {
 
   #[tokio::test]
   async fn test_handle_get_episode_files_event_empty_season_details_modal() {
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(json!([episode_file()])),
-      None,
-      SonarrEvent::GetEpisodeFiles(1),
-      None,
-      Some("seriesId=1"),
-    )
-    .await;
+    let (async_server, app_arc, _server) = MockServarrApi::get()
+      .returns(json!([episode_file()]))
+      .query("seriesId=1")
+      .build_for(SonarrEvent::GetEpisodeFiles(1))
+      .await;
     app_arc
       .lock()
       .await
@@ -480,7 +450,7 @@ mod tests {
         ..Series::default()
       }]);
     app_arc.lock().await.server_tabs.next();
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let mut network = test_network(&app_arc);
 
     if let SonarrSerdeable::EpisodeFiles(episode_files) = network
       .handle_sonarr_event(SonarrEvent::GetEpisodeFiles(1))
@@ -488,13 +458,15 @@ mod tests {
       .unwrap()
     {
       async_server.assert_async().await;
-      assert!(app_arc
-        .lock()
-        .await
-        .data
-        .sonarr_data
-        .season_details_modal
-        .is_some());
+      assert!(
+        app_arc
+          .lock()
+          .await
+          .data
+          .sonarr_data
+          .season_details_modal
+          .is_some()
+      );
       assert_eq!(
         app_arc
           .lock()
@@ -555,16 +527,11 @@ mod tests {
         ..history_item()
       },
     ];
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(history_json),
-      None,
-      SonarrEvent::GetEpisodeHistory(1),
-      None,
-      Some("episodeId=1&pageSize=1000&sortDirection=descending&sortKey=date"),
-    )
-    .await;
+    let (async_server, app_arc, _server) = MockServarrApi::get()
+      .returns(history_json)
+      .query("episodeId=1&pageSize=1000&sortDirection=descending&sortKey=date")
+      .build_for(SonarrEvent::GetEpisodeHistory(1))
+      .await;
     app_arc.lock().await.data.sonarr_data.season_details_modal =
       Some(SeasonDetailsModal::default());
     app_arc
@@ -600,7 +567,7 @@ mod tests {
       .episode_history
       .sort_asc = true;
     app_arc.lock().await.server_tabs.next();
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let mut network = test_network(&app_arc);
 
     if let SonarrSerdeable::SonarrHistoryWrapper(history) = network
       .handle_sonarr_event(SonarrEvent::GetEpisodeHistory(1))
@@ -686,16 +653,11 @@ mod tests {
         ..history_item()
       },
     ];
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(history_json),
-      None,
-      SonarrEvent::GetEpisodeHistory(1),
-      None,
-      Some("episodeId=1&pageSize=1000&sortDirection=descending&sortKey=date"),
-    )
-    .await;
+    let (async_server, app_arc, _server) = MockServarrApi::get()
+      .returns(history_json)
+      .query("episodeId=1&pageSize=1000&sortDirection=descending&sortKey=date")
+      .build_for(SonarrEvent::GetEpisodeHistory(1))
+      .await;
     app_arc.lock().await.data.sonarr_data.season_details_modal =
       Some(SeasonDetailsModal::default());
     app_arc
@@ -709,7 +671,7 @@ mod tests {
       .episodes
       .set_items(vec![episode()]);
     app_arc.lock().await.server_tabs.next();
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let mut network = test_network(&app_arc);
 
     if let SonarrSerdeable::SonarrHistoryWrapper(history) = network
       .handle_sonarr_event(SonarrEvent::GetEpisodeHistory(1))
@@ -795,18 +757,13 @@ mod tests {
         ..history_item()
       },
     ];
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(history_json),
-      None,
-      SonarrEvent::GetEpisodeHistory(1),
-      None,
-      Some("episodeId=1&pageSize=1000&sortDirection=descending&sortKey=date"),
-    )
-    .await;
+    let (async_server, app_arc, _server) = MockServarrApi::get()
+      .returns(history_json)
+      .query("episodeId=1&pageSize=1000&sortDirection=descending&sortKey=date")
+      .build_for(SonarrEvent::GetEpisodeHistory(1))
+      .await;
     app_arc.lock().await.server_tabs.next();
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let mut network = test_network(&app_arc);
 
     if let SonarrSerdeable::SonarrHistoryWrapper(history) = network
       .handle_sonarr_event(SonarrEvent::GetEpisodeHistory(1))
@@ -852,16 +809,11 @@ mod tests {
   #[tokio::test]
   async fn test_handle_get_episode_details_event() {
     let response: Episode = serde_json::from_str(EPISODE_JSON).unwrap();
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(serde_json::from_str(EPISODE_JSON).unwrap()),
-      None,
-      SonarrEvent::GetEpisodeDetails(1),
-      Some("/1"),
-      None,
-    )
-    .await;
+    let (async_server, app_arc, _server) = MockServarrApi::get()
+      .returns(serde_json::from_str(EPISODE_JSON).unwrap())
+      .path("/1")
+      .build_for(SonarrEvent::GetEpisodeDetails(1))
+      .await;
     let mut episode_details_modal = EpisodeDetailsModal::default();
     episode_details_modal.episode_details_tabs.next();
     let mut season_details_modal = SeasonDetailsModal::default();
@@ -873,7 +825,7 @@ mod tests {
       .await
       .push_navigation_stack(ActiveSonarrBlock::EpisodeDetails.into());
     app_arc.lock().await.server_tabs.next();
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let mut network = test_network(&app_arc);
 
     if let SonarrSerdeable::Episode(episode) = network
       .handle_sonarr_event(SonarrEvent::GetEpisodeDetails(1))
@@ -881,16 +833,18 @@ mod tests {
       .unwrap()
     {
       async_server.assert_async().await;
-      assert!(app_arc
-        .lock()
-        .await
-        .data
-        .sonarr_data
-        .season_details_modal
-        .as_ref()
-        .unwrap()
-        .episode_details_modal
-        .is_some());
+      assert!(
+        app_arc
+          .lock()
+          .await
+          .data
+          .sonarr_data
+          .season_details_modal
+          .as_ref()
+          .unwrap()
+          .episode_details_modal
+          .is_some()
+      );
       assert_eq!(
         app_arc
           .lock()
@@ -969,16 +923,11 @@ mod tests {
   #[tokio::test]
   async fn test_handle_get_episode_details_event_empty_episode_details_modal() {
     let response: Episode = serde_json::from_str(EPISODE_JSON).unwrap();
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(serde_json::from_str(EPISODE_JSON).unwrap()),
-      None,
-      SonarrEvent::GetEpisodeDetails(1),
-      Some("/1"),
-      None,
-    )
-    .await;
+    let (async_server, app_arc, _server) = MockServarrApi::get()
+      .returns(serde_json::from_str(EPISODE_JSON).unwrap())
+      .path("/1")
+      .build_for(SonarrEvent::GetEpisodeDetails(1))
+      .await;
     let mut season_details_modal = SeasonDetailsModal::default();
     season_details_modal.episodes.set_items(vec![episode()]);
     app_arc.lock().await.data.sonarr_data.season_details_modal = Some(season_details_modal);
@@ -987,7 +936,7 @@ mod tests {
       .await
       .push_navigation_stack(ActiveSonarrBlock::EpisodeDetails.into());
     app_arc.lock().await.server_tabs.next();
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let mut network = test_network(&app_arc);
 
     if let SonarrSerdeable::Episode(episode) = network
       .handle_sonarr_event(SonarrEvent::GetEpisodeDetails(1))
@@ -995,16 +944,18 @@ mod tests {
       .unwrap()
     {
       async_server.assert_async().await;
-      assert!(app_arc
-        .lock()
-        .await
-        .data
-        .sonarr_data
-        .season_details_modal
-        .as_ref()
-        .unwrap()
-        .episode_details_modal
-        .is_some());
+      assert!(
+        app_arc
+          .lock()
+          .await
+          .data
+          .sonarr_data
+          .season_details_modal
+          .as_ref()
+          .unwrap()
+          .episode_details_modal
+          .is_some()
+      );
       assert_eq!(episode, response);
 
       let app = app_arc.lock().await;
@@ -1067,19 +1018,14 @@ mod tests {
   #[tokio::test]
   async fn test_handle_get_episode_details_event_season_details_modal_not_required_in_cli_mode() {
     let response: Episode = serde_json::from_str(EPISODE_JSON).unwrap();
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(serde_json::from_str(EPISODE_JSON).unwrap()),
-      None,
-      SonarrEvent::GetEpisodeDetails(1),
-      Some("/1"),
-      None,
-    )
-    .await;
+    let (async_server, app_arc, _server) = MockServarrApi::get()
+      .returns(serde_json::from_str(EPISODE_JSON).unwrap())
+      .path("/1")
+      .build_for(SonarrEvent::GetEpisodeDetails(1))
+      .await;
     app_arc.lock().await.cli_mode = true;
     app_arc.lock().await.server_tabs.next();
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let mut network = test_network(&app_arc);
 
     if let SonarrSerdeable::Episode(episode) = network
       .handle_sonarr_event(SonarrEvent::GetEpisodeDetails(1))
@@ -1093,20 +1039,15 @@ mod tests {
 
   #[tokio::test]
   #[should_panic(expected = "Season details modal is empty")]
-  async fn test_handle_get_episode_details_event_requires_season_details_modal_to_be_some_when_in_tui_mode(
-  ) {
-    let (_async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(serde_json::from_str(EPISODE_JSON).unwrap()),
-      None,
-      SonarrEvent::GetEpisodeDetails(1),
-      Some("/1"),
-      None,
-    )
-    .await;
+  async fn test_handle_get_episode_details_event_requires_season_details_modal_to_be_some_when_in_tui_mode()
+   {
+    let (_async_server, app_arc, _server) = MockServarrApi::get()
+      .returns(serde_json::from_str(EPISODE_JSON).unwrap())
+      .path("/1")
+      .build_for(SonarrEvent::GetEpisodeDetails(1))
+      .await;
     app_arc.lock().await.server_tabs.next();
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let mut network = test_network(&app_arc);
 
     network
       .handle_sonarr_event(SonarrEvent::GetEpisodeDetails(1))
@@ -1131,16 +1072,11 @@ mod tests {
       "languages": [ { "id": 1, "name": "English" } ],
       "quality": { "quality": { "name": "Bluray-1080p" }}
     }]);
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(release_json),
-      None,
-      SonarrEvent::GetEpisodeReleases(1),
-      None,
-      Some("episodeId=1"),
-    )
-    .await;
+    let (async_server, app_arc, _server) = MockServarrApi::get()
+      .returns(release_json)
+      .query("episodeId=1")
+      .build_for(SonarrEvent::GetEpisodeReleases(1))
+      .await;
     let mut season_details_modal = SeasonDetailsModal::default();
     season_details_modal.episodes.set_items(vec![episode()]);
     app_arc.lock().await.data.sonarr_data.season_details_modal = Some(season_details_modal);
@@ -1154,7 +1090,7 @@ mod tests {
       .unwrap()
       .episode_details_modal = Some(EpisodeDetailsModal::default());
     app_arc.lock().await.server_tabs.next();
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let mut network = test_network(&app_arc);
 
     if let SonarrSerdeable::Releases(releases_vec) = network
       .handle_sonarr_event(SonarrEvent::GetEpisodeReleases(1))
@@ -1199,21 +1135,16 @@ mod tests {
       "languages": [ { "id": 1, "name": "English" } ],
       "quality": { "quality": { "name": "Bluray-1080p" }}
     }]);
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(release_json),
-      None,
-      SonarrEvent::GetEpisodeReleases(1),
-      None,
-      Some("episodeId=1"),
-    )
-    .await;
+    let (async_server, app_arc, _server) = MockServarrApi::get()
+      .returns(release_json)
+      .query("episodeId=1")
+      .build_for(SonarrEvent::GetEpisodeReleases(1))
+      .await;
     let mut season_details_modal = SeasonDetailsModal::default();
     season_details_modal.episodes.set_items(vec![episode()]);
     app_arc.lock().await.data.sonarr_data.season_details_modal = Some(season_details_modal);
     app_arc.lock().await.server_tabs.next();
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let mut network = test_network(&app_arc);
 
     if let SonarrSerdeable::Releases(releases_vec) = network
       .handle_sonarr_event(SonarrEvent::GetEpisodeReleases(1))
@@ -1249,16 +1180,11 @@ mod tests {
     };
     let body = Episode { id: 2, ..episode() };
 
-    let (async_details_server, app_arc, mut server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(json!(body)),
-      None,
-      SonarrEvent::GetEpisodeDetails(2),
-      Some("/2"),
-      None,
-    )
-    .await;
+    let (async_details_server, app_arc, mut server) = MockServarrApi::get()
+      .returns(json!(body))
+      .path("/2")
+      .build_for(SonarrEvent::GetEpisodeDetails(2))
+      .await;
     let async_toggle_server = server
       .mock(
         "PUT",
@@ -1274,12 +1200,14 @@ mod tests {
       .create_async()
       .await;
     app_arc.lock().await.server_tabs.next();
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let mut network = test_network(&app_arc);
 
-    assert!(network
-      .handle_sonarr_event(SonarrEvent::ToggleEpisodeMonitoring(2))
-      .await
-      .is_ok());
+    assert!(
+      network
+        .handle_sonarr_event(SonarrEvent::ToggleEpisodeMonitoring(2))
+        .await
+        .is_ok()
+    );
 
     async_details_server.assert_async().await;
     async_toggle_server.assert_async().await;
@@ -1287,28 +1215,26 @@ mod tests {
 
   #[tokio::test]
   async fn test_handle_trigger_automatic_episode_search_event() {
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Post,
-      Some(json!({
-        "name": "EpisodeSearch",
-        "episodeIds": [ 1 ]
-      })),
-      Some(json!({})),
-      None,
-      SonarrEvent::TriggerAutomaticEpisodeSearch(1),
-      None,
-      None,
-    )
-    .await;
-    app_arc.lock().await.server_tabs.next();
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let body = json!({
+      "name": "EpisodeSearch",
+      "episodeIds": [ 1 ]
+    });
+    let (mock, app, _server) = MockServarrApi::post()
+      .with_request_body(body)
+      .returns(json!({}))
+      .build_for(SonarrEvent::TriggerAutomaticEpisodeSearch(1))
+      .await;
+    app.lock().await.server_tabs.next();
+    let mut network = test_network(&app);
 
-    assert!(network
-      .handle_sonarr_event(SonarrEvent::TriggerAutomaticEpisodeSearch(1))
-      .await
-      .is_ok());
+    assert!(
+      network
+        .handle_sonarr_event(SonarrEvent::TriggerAutomaticEpisodeSearch(1))
+        .await
+        .is_ok()
+    );
 
-    async_server.assert_async().await;
+    mock.assert_async().await;
   }
 
   #[test]

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

@@ -4,7 +4,7 @@ use crate::network::sonarr_network::SonarrEvent;
 use crate::network::{Network, RequestMethod};
 use anyhow::Result;
 use log::{debug, info, warn};
-use serde_json::{json, Value};
+use serde_json::{Value, json};
 
 #[cfg(test)]
 #[path = "sonarr_seasons_network_tests.rs"]

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

@@ -2,17 +2,15 @@
 mod tests {
   use crate::models::servarr_data::sonarr::modals::SeasonDetailsModal;
   use crate::models::sonarr_models::{SonarrHistoryItem, SonarrRelease, SonarrSerdeable};
-  use crate::network::network_tests::test_utils::mock_servarr_api;
-  use crate::network::sonarr_network::sonarr_network_test_utils::test_utils::{
-    history_item, release, season, series, SERIES_JSON,
-  };
+  use crate::network::NetworkResource;
+  use crate::network::network_tests::test_utils::{MockServarrApi, test_network};
   use crate::network::sonarr_network::SonarrEvent;
-  use crate::network::{Network, NetworkResource, RequestMethod};
+  use crate::network::sonarr_network::sonarr_network_test_utils::test_utils::{
+    SERIES_JSON, history_item, release, season, series,
+  };
   use mockito::Matcher;
   use pretty_assertions::assert_eq;
-  use reqwest::Client;
-  use serde_json::{json, Value};
-  use tokio_util::sync::CancellationToken;
+  use serde_json::{Value, json};
 
   #[tokio::test]
   async fn test_handle_toggle_season_monitoring_event() {
@@ -28,16 +26,11 @@ mod tests {
       .get_mut("monitored")
       .unwrap() = json!(false);
 
-    let (async_details_server, app_arc, mut server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(serde_json::from_str(SERIES_JSON).unwrap()),
-      None,
-      SonarrEvent::GetSeriesDetails(1),
-      Some("/1"),
-      None,
-    )
-    .await;
+    let (async_details_server, app, mut server) = MockServarrApi::get()
+      .returns(serde_json::from_str(SERIES_JSON).unwrap())
+      .path("/1")
+      .build_for(SonarrEvent::GetSeriesDetails(1))
+      .await;
     let async_toggle_server = server
       .mock(
         "PUT",
@@ -53,17 +46,19 @@ mod tests {
       .create_async()
       .await;
     {
-      let mut app = app_arc.lock().await;
-      app.data.sonarr_data.series.set_items(vec![series()]);
-      app.data.sonarr_data.seasons.set_items(vec![season()]);
+      let mut app_lock = app.lock().await;
+      app_lock.data.sonarr_data.series.set_items(vec![series()]);
+      app_lock.data.sonarr_data.seasons.set_items(vec![season()]);
     }
-    app_arc.lock().await.server_tabs.next();
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    app.lock().await.server_tabs.next();
+    let mut network = test_network(&app);
 
-    assert!(network
-      .handle_sonarr_event(SonarrEvent::ToggleSeasonMonitoring((1, 1)))
-      .await
-      .is_ok());
+    assert!(
+      network
+        .handle_sonarr_event(SonarrEvent::ToggleSeasonMonitoring((1, 1)))
+        .await
+        .is_ok()
+    );
 
     async_details_server.assert_async().await;
     async_toggle_server.assert_async().await;
@@ -118,43 +113,37 @@ mod tests {
         ..release()
       },
     ];
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(release_json),
-      None,
-      SonarrEvent::GetSeasonReleases((1, 1)),
-      None,
-      Some("seriesId=1&seasonNumber=1"),
-    )
-    .await;
-    app_arc
+    let (mock, app, _server) = MockServarrApi::get()
+      .returns(release_json)
+      .query("seriesId=1&seasonNumber=1")
+      .build_for(SonarrEvent::GetSeasonReleases((1, 1)))
+      .await;
+    app
       .lock()
       .await
       .data
       .sonarr_data
       .series
       .set_items(vec![series()]);
-    app_arc
+    app
       .lock()
       .await
       .data
       .sonarr_data
       .seasons
       .set_items(vec![season()]);
-    app_arc.lock().await.data.sonarr_data.season_details_modal =
-      Some(SeasonDetailsModal::default());
-    app_arc.lock().await.server_tabs.next();
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    app.lock().await.data.sonarr_data.season_details_modal = Some(SeasonDetailsModal::default());
+    app.lock().await.server_tabs.next();
+    let mut network = test_network(&app);
 
     if let SonarrSerdeable::Releases(releases_vec) = network
       .handle_sonarr_event(SonarrEvent::GetSeasonReleases((1, 1)))
       .await
       .unwrap()
     {
-      async_server.assert_async().await;
+      mock.assert_async().await;
       assert_eq!(
-        app_arc
+        app
           .lock()
           .await
           .data
@@ -209,41 +198,38 @@ mod tests {
       full_season: true,
       ..release()
     };
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(release_json),
-      None,
-      SonarrEvent::GetSeasonReleases((1, 1)),
-      None,
-      Some("seriesId=1&seasonNumber=1"),
-    )
-    .await;
-    app_arc
+    let (mock, app, _server) = MockServarrApi::get()
+      .returns(release_json)
+      .query("seriesId=1&seasonNumber=1")
+      .build_for(SonarrEvent::GetSeasonReleases((1, 1)))
+      .await;
+    app
       .lock()
       .await
       .data
       .sonarr_data
       .series
       .set_items(vec![series()]);
-    app_arc
+    app
       .lock()
       .await
       .data
       .sonarr_data
       .seasons
       .set_items(vec![season()]);
-    app_arc.lock().await.server_tabs.next();
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    app.lock().await.server_tabs.next();
+    let mut network = test_network(&app);
 
-    assert!(network
-      .handle_sonarr_event(SonarrEvent::GetSeasonReleases((1, 1)))
-      .await
-      .is_ok());
+    assert!(
+      network
+        .handle_sonarr_event(SonarrEvent::GetSeasonReleases((1, 1)))
+        .await
+        .is_ok()
+    );
 
-    async_server.assert_async().await;
+    mock.assert_async().await;
     assert_eq!(
-      app_arc
+      app
         .lock()
         .await
         .data
@@ -300,33 +286,27 @@ mod tests {
         ..history_item()
       },
     ];
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(history_json),
-      None,
-      SonarrEvent::GetSeasonHistory((1, 1)),
-      None,
-      Some("seriesId=1&seasonNumber=1"),
-    )
-    .await;
-    app_arc.lock().await.data.sonarr_data.season_details_modal =
-      Some(SeasonDetailsModal::default());
-    app_arc
+    let (mock, app, _server) = MockServarrApi::get()
+      .returns(history_json)
+      .query("seriesId=1&seasonNumber=1")
+      .build_for(SonarrEvent::GetSeasonHistory((1, 1)))
+      .await;
+    app.lock().await.data.sonarr_data.season_details_modal = Some(SeasonDetailsModal::default());
+    app
       .lock()
       .await
       .data
       .sonarr_data
       .series
       .set_items(vec![series()]);
-    app_arc
+    app
       .lock()
       .await
       .data
       .sonarr_data
       .seasons
       .set_items(vec![season()]);
-    app_arc
+    app
       .lock()
       .await
       .data
@@ -336,17 +316,17 @@ mod tests {
       .unwrap()
       .season_history
       .sort_asc = true;
-    app_arc.lock().await.server_tabs.next();
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    app.lock().await.server_tabs.next();
+    let mut network = test_network(&app);
 
     if let SonarrSerdeable::SonarrHistoryItems(history) = network
       .handle_sonarr_event(SonarrEvent::GetSeasonHistory((1, 1)))
       .await
       .unwrap()
     {
-      async_server.assert_async().await;
+      mock.assert_async().await;
       assert_eq!(
-        app_arc
+        app
           .lock()
           .await
           .data
@@ -359,7 +339,7 @@ mod tests {
         expected_history_items
       );
       assert!(
-        app_arc
+        app
           .lock()
           .await
           .data
@@ -417,48 +397,45 @@ mod tests {
         ..history_item()
       },
     ];
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(history_json),
-      None,
-      SonarrEvent::GetSeasonHistory((1, 1)),
-      None,
-      Some("seriesId=1&seasonNumber=1"),
-    )
-    .await;
-    app_arc
+    let (mock, app, _server) = MockServarrApi::get()
+      .returns(history_json)
+      .query("seriesId=1&seasonNumber=1")
+      .build_for(SonarrEvent::GetSeasonHistory((1, 1)))
+      .await;
+    app
       .lock()
       .await
       .data
       .sonarr_data
       .series
       .set_items(vec![series()]);
-    app_arc
+    app
       .lock()
       .await
       .data
       .sonarr_data
       .seasons
       .set_items(vec![season()]);
-    app_arc.lock().await.server_tabs.next();
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    app.lock().await.server_tabs.next();
+    let mut network = test_network(&app);
 
     if let SonarrSerdeable::SonarrHistoryItems(history) = network
       .handle_sonarr_event(SonarrEvent::GetSeasonHistory((1, 1)))
       .await
       .unwrap()
     {
-      async_server.assert_async().await;
-      assert!(app_arc
-        .lock()
-        .await
-        .data
-        .sonarr_data
-        .season_details_modal
-        .is_some());
+      mock.assert_async().await;
+      assert!(
+        app
+          .lock()
+          .await
+          .data
+          .sonarr_data
+          .season_details_modal
+          .is_some()
+      );
       assert_eq!(
-        app_arc
+        app
           .lock()
           .await
           .data
@@ -471,7 +448,7 @@ mod tests {
         expected_history_items
       );
       assert!(
-        !app_arc
+        !app
           .lock()
           .await
           .data
@@ -488,28 +465,25 @@ mod tests {
 
   #[tokio::test]
   async fn test_handle_trigger_automatic_season_search_event() {
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Post,
-      Some(json!({
+    let (mock, app, _server) = MockServarrApi::post()
+      .with_request_body(json!({
         "name": "SeasonSearch",
         "seriesId": 1,
         "seasonNumber": 1
-      })),
-      Some(json!({})),
-      None,
-      SonarrEvent::TriggerAutomaticSeasonSearch((1, 1)),
-      None,
-      None,
-    )
-    .await;
-    app_arc.lock().await.server_tabs.next();
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+      }))
+      .returns(json!({}))
+      .build_for(SonarrEvent::TriggerAutomaticSeasonSearch((1, 1)))
+      .await;
+    app.lock().await.server_tabs.next();
+    let mut network = test_network(&app);
 
-    assert!(network
-      .handle_sonarr_event(SonarrEvent::TriggerAutomaticSeasonSearch((1, 1)))
-      .await
-      .is_ok());
+    assert!(
+      network
+        .handle_sonarr_event(SonarrEvent::TriggerAutomaticSeasonSearch((1, 1)))
+        .await
+        .is_ok()
+    );
 
-    async_server.assert_async().await;
+    mock.assert_async().await;
   }
 }

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

@@ -1,15 +1,15 @@
+use crate::models::Route;
 use crate::models::servarr_data::sonarr::sonarr_data::ActiveSonarrBlock;
 use crate::models::sonarr_models::{
   AddSeriesBody, AddSeriesSearchResult, DeleteSeriesParams, EditSeriesParams, Series,
   SonarrCommandBody, SonarrHistoryItem,
 };
 use crate::models::stateful_table::StatefulTable;
-use crate::models::Route;
 use crate::network::sonarr_network::SonarrEvent;
 use crate::network::{Network, RequestMethod};
 use anyhow::Result;
 use log::{debug, info, warn};
-use serde_json::{json, Value};
+use serde_json::{Value, json};
 use urlencoding::encode;
 
 #[cfg(test)]
@@ -56,7 +56,9 @@ impl Network<'_, '_> {
       add_list_exclusion,
     } = delete_series_params;
 
-    info!("Deleting Sonarr series with ID: {id} with deleteFiles={delete_series_files} and addImportExclusion={add_list_exclusion}");
+    info!(
+      "Deleting Sonarr series with ID: {id} with deleteFiles={delete_series_files} and addImportExclusion={add_list_exclusion}"
+    );
 
     let request_props = self
       .request_props_from(

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

@@ -6,19 +6,17 @@ mod tests {
     SonarrHistoryItem, SonarrSerdeable,
   };
   use crate::models::stateful_table::{SortOption, StatefulTable};
-  use crate::network::network_tests::test_utils::mock_servarr_api;
-  use crate::network::sonarr_network::sonarr_network_test_utils::test_utils::{
-    add_series_search_result, history_item, season, series, SERIES_JSON,
-  };
+  use crate::network::NetworkResource;
+  use crate::network::network_tests::test_utils::{MockServarrApi, test_network};
   use crate::network::sonarr_network::SonarrEvent;
-  use crate::network::{Network, NetworkResource, RequestMethod};
+  use crate::network::sonarr_network::sonarr_network_test_utils::test_utils::{
+    SERIES_JSON, add_series_search_result, history_item, season, series,
+  };
   use bimap::BiMap;
   use mockito::Matcher;
   use pretty_assertions::assert_eq;
-  use reqwest::Client;
   use rstest::rstest;
-  use serde_json::{json, Value};
-  use tokio_util::sync::CancellationToken;
+  use serde_json::{Value, json};
 
   #[tokio::test]
   async fn test_handle_add_sonarr_series_event() {
@@ -39,9 +37,8 @@ mod tests {
         search_for_missing_episodes: true,
       },
     };
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Post,
-      Some(json!({
+    let (async_server, app, _server) = MockServarrApi::post()
+      .with_request_body(json!({
         "tvdbId": 1234,
         "title": "Test",
         "monitored": true,
@@ -56,30 +53,28 @@ mod tests {
           "searchForCutoffUnmetEpisodes": true,
           "searchForMissingEpisodes": true
         }
-      })),
-      Some(json!({})),
-      None,
-      SonarrEvent::AddSeries(expected_add_series_body.clone()),
-      None,
-      None,
-    )
-    .await;
-    app_arc.lock().await.data.sonarr_data.tags_map =
+      }))
+      .returns(json!({}))
+      .build_for(SonarrEvent::AddSeries(expected_add_series_body.clone()))
+      .await;
+    app.lock().await.data.sonarr_data.tags_map =
       BiMap::from_iter([(1, "usenet".to_owned()), (2, "testing".to_owned())]);
-    app_arc.lock().await.server_tabs.next();
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    app.lock().await.server_tabs.next();
+    let mut network = test_network(&app);
 
-    assert!(network
-      .handle_sonarr_event(SonarrEvent::AddSeries(expected_add_series_body))
-      .await
-      .is_ok());
+    assert!(
+      network
+        .handle_sonarr_event(SonarrEvent::AddSeries(expected_add_series_body))
+        .await
+        .is_ok()
+    );
 
     async_server.assert_async().await;
   }
 
   #[tokio::test]
-  async fn test_handle_add_sonarr_series_event_does_not_overwrite_tags_vec_when_tag_input_string_is_none(
-  ) {
+  async fn test_handle_add_sonarr_series_event_does_not_overwrite_tags_vec_when_tag_input_string_is_none()
+   {
     let expected_add_series_body = AddSeriesBody {
       tvdb_id: 1234,
       title: "Test".to_owned(),
@@ -97,9 +92,8 @@ mod tests {
         search_for_missing_episodes: true,
       },
     };
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Post,
-      Some(json!({
+    let (async_server, app, _server) = MockServarrApi::post()
+      .with_request_body(json!({
         "tvdbId": 1234,
         "title": "Test",
         "monitored": true,
@@ -114,21 +108,19 @@ mod tests {
           "searchForCutoffUnmetEpisodes": true,
           "searchForMissingEpisodes": true
         }
-      })),
-      Some(json!({})),
-      None,
-      SonarrEvent::AddSeries(expected_add_series_body.clone()),
-      None,
-      None,
-    )
-    .await;
-    app_arc.lock().await.server_tabs.next();
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+      }))
+      .returns(json!({}))
+      .build_for(SonarrEvent::AddSeries(expected_add_series_body.clone()))
+      .await;
+    app.lock().await.server_tabs.next();
+    let mut network = test_network(&app);
 
-    assert!(network
-      .handle_sonarr_event(SonarrEvent::AddSeries(expected_add_series_body))
-      .await
-      .is_ok());
+    assert!(
+      network
+        .handle_sonarr_event(SonarrEvent::AddSeries(expected_add_series_body))
+        .await
+        .is_ok()
+    );
 
     async_server.assert_async().await;
   }
@@ -140,23 +132,20 @@ mod tests {
       delete_series_files: true,
       add_list_exclusion: true,
     };
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Delete,
-      None,
-      None,
-      None,
-      SonarrEvent::DeleteSeries(delete_series_params.clone()),
-      Some("/1"),
-      Some("deleteFiles=true&addImportExclusion=true"),
-    )
-    .await;
-    app_arc.lock().await.server_tabs.next();
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let (async_server, app, _server) = MockServarrApi::delete()
+      .path("/1")
+      .query("deleteFiles=true&addImportExclusion=true")
+      .build_for(SonarrEvent::DeleteSeries(delete_series_params.clone()))
+      .await;
+    app.lock().await.server_tabs.next();
+    let mut network = test_network(&app);
 
-    assert!(network
-      .handle_sonarr_event(SonarrEvent::DeleteSeries(delete_series_params))
-      .await
-      .is_ok());
+    assert!(
+      network
+        .handle_sonarr_event(SonarrEvent::DeleteSeries(delete_series_params))
+        .await
+        .is_ok()
+    );
 
     async_server.assert_async().await;
   }
@@ -183,16 +172,11 @@ mod tests {
       ..EditSeriesParams::default()
     };
 
-    let (async_details_server, app_arc, mut server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(serde_json::from_str(SERIES_JSON).unwrap()),
-      None,
-      SonarrEvent::GetSeriesDetails(1),
-      Some("/1"),
-      None,
-    )
-    .await;
+    let (async_details_server, app, mut server) = MockServarrApi::get()
+      .returns(serde_json::from_str(SERIES_JSON).unwrap())
+      .path("/1")
+      .build_for(SonarrEvent::GetSeriesDetails(1))
+      .await;
     let async_edit_server = server
       .mock(
         "PUT",
@@ -207,23 +191,25 @@ mod tests {
       .match_body(Matcher::Json(expected_body))
       .create_async()
       .await;
-    app_arc.lock().await.data.sonarr_data.tags_map =
+    app.lock().await.data.sonarr_data.tags_map =
       BiMap::from_iter([(1, "usenet".to_owned()), (2, "testing".to_owned())]);
-    app_arc.lock().await.server_tabs.next();
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    app.lock().await.server_tabs.next();
+    let mut network = test_network(&app);
 
-    assert!(network
-      .handle_sonarr_event(SonarrEvent::EditSeries(edit_series_params))
-      .await
-      .is_ok());
+    assert!(
+      network
+        .handle_sonarr_event(SonarrEvent::EditSeries(edit_series_params))
+        .await
+        .is_ok()
+    );
 
     async_details_server.assert_async().await;
     async_edit_server.assert_async().await;
   }
 
   #[tokio::test]
-  async fn test_handle_edit_series_event_does_not_overwrite_tag_ids_vec_when_tag_input_string_is_none(
-  ) {
+  async fn test_handle_edit_series_event_does_not_overwrite_tag_ids_vec_when_tag_input_string_is_none()
+   {
     let mut expected_body: Value = serde_json::from_str(SERIES_JSON).unwrap();
     *expected_body.get_mut("monitored").unwrap() = json!(false);
     *expected_body.get_mut("seasonFolder").unwrap() = json!(false);
@@ -244,16 +230,11 @@ mod tests {
       ..EditSeriesParams::default()
     };
 
-    let (async_details_server, app_arc, mut server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(serde_json::from_str(SERIES_JSON).unwrap()),
-      None,
-      SonarrEvent::GetSeriesDetails(1),
-      Some("/1"),
-      None,
-    )
-    .await;
+    let (async_details_server, app, mut server) = MockServarrApi::get()
+      .returns(serde_json::from_str(SERIES_JSON).unwrap())
+      .path("/1")
+      .build_for(SonarrEvent::GetSeriesDetails(1))
+      .await;
     let async_edit_server = server
       .mock(
         "PUT",
@@ -268,15 +249,17 @@ mod tests {
       .match_body(Matcher::Json(expected_body))
       .create_async()
       .await;
-    app_arc.lock().await.data.sonarr_data.tags_map =
+    app.lock().await.data.sonarr_data.tags_map =
       BiMap::from_iter([(1, "usenet".to_owned()), (2, "testing".to_owned())]);
-    app_arc.lock().await.server_tabs.next();
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    app.lock().await.server_tabs.next();
+    let mut network = test_network(&app);
 
-    assert!(network
-      .handle_sonarr_event(SonarrEvent::EditSeries(edit_series_params))
-      .await
-      .is_ok());
+    assert!(
+      network
+        .handle_sonarr_event(SonarrEvent::EditSeries(edit_series_params))
+        .await
+        .is_ok()
+    );
 
     async_details_server.assert_async().await;
     async_edit_server.assert_async().await;
@@ -289,16 +272,11 @@ mod tests {
       ..EditSeriesParams::default()
     };
     let expected_body: Value = serde_json::from_str(SERIES_JSON).unwrap();
-    let (async_details_server, app_arc, mut server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(serde_json::from_str(SERIES_JSON).unwrap()),
-      None,
-      SonarrEvent::GetSeriesDetails(1),
-      Some("/1"),
-      None,
-    )
-    .await;
+    let (async_details_server, app, mut server) = MockServarrApi::get()
+      .returns(serde_json::from_str(SERIES_JSON).unwrap())
+      .path("/1")
+      .build_for(SonarrEvent::GetSeriesDetails(1))
+      .await;
     let async_edit_server = server
       .mock(
         "PUT",
@@ -313,13 +291,15 @@ mod tests {
       .match_body(Matcher::Json(expected_body))
       .create_async()
       .await;
-    app_arc.lock().await.server_tabs.next();
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    app.lock().await.server_tabs.next();
+    let mut network = test_network(&app);
 
-    assert!(network
-      .handle_sonarr_event(SonarrEvent::EditSeries(edit_series_params))
-      .await
-      .is_ok());
+    assert!(
+      network
+        .handle_sonarr_event(SonarrEvent::EditSeries(edit_series_params))
+        .await
+        .is_ok()
+    );
 
     async_details_server.assert_async().await;
     async_edit_server.assert_async().await;
@@ -330,16 +310,11 @@ mod tests {
     let mut expected_body: Value = serde_json::from_str(SERIES_JSON).unwrap();
     *expected_body.get_mut("tags").unwrap() = json!([]);
 
-    let (async_details_server, app_arc, mut server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(serde_json::from_str(SERIES_JSON).unwrap()),
-      None,
-      SonarrEvent::GetSeriesDetails(1),
-      Some("/1"),
-      None,
-    )
-    .await;
+    let (async_details_server, app, mut server) = MockServarrApi::get()
+      .returns(serde_json::from_str(SERIES_JSON).unwrap())
+      .path("/1")
+      .build_for(SonarrEvent::GetSeriesDetails(1))
+      .await;
     let edit_series_params = EditSeriesParams {
       series_id: 1,
       clear_tags: true,
@@ -359,13 +334,15 @@ mod tests {
       .match_body(Matcher::Json(expected_body))
       .create_async()
       .await;
-    app_arc.lock().await.server_tabs.next();
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    app.lock().await.server_tabs.next();
+    let mut network = test_network(&app);
 
-    assert!(network
-      .handle_sonarr_event(SonarrEvent::EditSeries(edit_series_params))
-      .await
-      .is_ok());
+    assert!(
+      network
+        .handle_sonarr_event(SonarrEvent::EditSeries(edit_series_params))
+        .await
+        .is_ok()
+    );
 
     async_details_server.assert_async().await;
     async_edit_server.assert_async().await;
@@ -376,16 +353,11 @@ mod tests {
     let mut expected_body: Value = serde_json::from_str(SERIES_JSON).unwrap();
     *expected_body.get_mut("monitored").unwrap() = json!(false);
 
-    let (async_details_server, app_arc, mut server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(serde_json::from_str(SERIES_JSON).unwrap()),
-      None,
-      SonarrEvent::GetSeriesDetails(1),
-      Some("/1"),
-      None,
-    )
-    .await;
+    let (async_details_server, app, mut server) = MockServarrApi::get()
+      .returns(serde_json::from_str(SERIES_JSON).unwrap())
+      .path("/1")
+      .build_for(SonarrEvent::GetSeriesDetails(1))
+      .await;
     let async_toggle_server = server
       .mock(
         "PUT",
@@ -401,17 +373,19 @@ mod tests {
       .create_async()
       .await;
     {
-      let mut app = app_arc.lock().await;
+      let mut app = app.lock().await;
       app.data.sonarr_data.series.set_items(vec![series()]);
       app.data.sonarr_data.seasons.set_items(vec![season()]);
     }
-    app_arc.lock().await.server_tabs.next();
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    app.lock().await.server_tabs.next();
+    let mut network = test_network(&app);
 
-    assert!(network
-      .handle_sonarr_event(SonarrEvent::ToggleSeriesMonitoring(1))
-      .await
-      .is_ok());
+    assert!(
+      network
+        .handle_sonarr_event(SonarrEvent::ToggleSeriesMonitoring(1))
+        .await
+        .is_ok()
+    );
 
     async_details_server.assert_async().await;
     async_toggle_server.assert_async().await;
@@ -420,25 +394,20 @@ mod tests {
   #[tokio::test]
   async fn test_handle_get_series_details_event() {
     let expected_series: Series = serde_json::from_str(SERIES_JSON).unwrap();
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(serde_json::from_str(SERIES_JSON).unwrap()),
-      None,
-      SonarrEvent::GetSeriesDetails(1),
-      Some("/1"),
-      None,
-    )
-    .await;
-    app_arc
+    let (async_server, app, _server) = MockServarrApi::get()
+      .returns(serde_json::from_str(SERIES_JSON).unwrap())
+      .path("/1")
+      .build_for(SonarrEvent::GetSeriesDetails(1))
+      .await;
+    app
       .lock()
       .await
       .data
       .sonarr_data
       .series
       .set_items(vec![series()]);
-    app_arc.lock().await.server_tabs.next();
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    app.lock().await.server_tabs.next();
+    let mut network = test_network(&app);
 
     if let SonarrSerdeable::Series(series) = network
       .handle_sonarr_event(SonarrEvent::GetSeriesDetails(1))
@@ -496,16 +465,11 @@ mod tests {
         ..history_item()
       },
     ];
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(history_json),
-      None,
-      SonarrEvent::GetSeriesHistory(1),
-      None,
-      Some("seriesId=1"),
-    )
-    .await;
+    let (async_server, app, _server) = MockServarrApi::get()
+      .returns(history_json)
+      .query("seriesId=1")
+      .build_for(SonarrEvent::GetSeriesHistory(1))
+      .await;
     let mut series_history_table = StatefulTable {
       sort_asc: true,
       ..StatefulTable::default()
@@ -525,16 +489,16 @@ mod tests {
       };
       series_history_table.sorting(vec![history_sort_option]);
     }
-    app_arc
+    app
       .lock()
       .await
       .data
       .sonarr_data
       .series
       .set_items(vec![series()]);
-    app_arc.lock().await.data.sonarr_data.series_history = Some(series_history_table);
-    app_arc.lock().await.server_tabs.next();
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    app.lock().await.data.sonarr_data.series_history = Some(series_history_table);
+    app.lock().await.server_tabs.next();
+    let mut network = test_network(&app);
 
     if let SonarrSerdeable::SonarrHistoryItems(history_items) = network
       .handle_sonarr_event(SonarrEvent::GetSeriesHistory(1))
@@ -542,15 +506,9 @@ mod tests {
       .unwrap()
     {
       async_server.assert_async().await;
-      assert!(app_arc
-        .lock()
-        .await
-        .data
-        .sonarr_data
-        .series_history
-        .is_some());
+      assert!(app.lock().await.data.sonarr_data.series_history.is_some());
       assert_eq!(
-        app_arc
+        app
           .lock()
           .await
           .data
@@ -562,7 +520,7 @@ mod tests {
         expected_history_items
       );
       assert!(
-        app_arc
+        app
           .lock()
           .await
           .data
@@ -619,25 +577,20 @@ mod tests {
         ..history_item()
       },
     ];
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(history_json),
-      None,
-      SonarrEvent::GetSeriesHistory(1),
-      None,
-      Some("seriesId=1"),
-    )
-    .await;
-    app_arc
+    let (async_server, app, _server) = MockServarrApi::get()
+      .returns(history_json)
+      .query("seriesId=1")
+      .build_for(SonarrEvent::GetSeriesHistory(1))
+      .await;
+    app
       .lock()
       .await
       .data
       .sonarr_data
       .series
       .set_items(vec![series()]);
-    app_arc.lock().await.server_tabs.next();
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    app.lock().await.server_tabs.next();
+    let mut network = test_network(&app);
 
     if let SonarrSerdeable::SonarrHistoryItems(history_items) = network
       .handle_sonarr_event(SonarrEvent::GetSeriesHistory(1))
@@ -645,15 +598,9 @@ mod tests {
       .unwrap()
     {
       async_server.assert_async().await;
-      assert!(app_arc
-        .lock()
-        .await
-        .data
-        .sonarr_data
-        .series_history
-        .is_some());
+      assert!(app.lock().await.data.sonarr_data.series_history.is_some());
       assert_eq!(
-        app_arc
+        app
           .lock()
           .await
           .data
@@ -665,7 +612,7 @@ mod tests {
         expected_history_items
       );
       assert!(
-        !app_arc
+        !app
           .lock()
           .await
           .data
@@ -708,16 +655,11 @@ mod tests {
       }
     }]);
     let response: Vec<SonarrHistoryItem> = serde_json::from_value(history_json.clone()).unwrap();
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(history_json),
-      None,
-      SonarrEvent::GetSeriesHistory(1),
-      None,
-      Some("seriesId=1"),
-    )
-    .await;
+    let (async_server, app, _server) = MockServarrApi::get()
+      .returns(history_json)
+      .query("seriesId=1")
+      .build_for(SonarrEvent::GetSeriesHistory(1))
+      .await;
     let cmp_fn = |a: &SonarrHistoryItem, b: &SonarrHistoryItem| {
       a.source_title
         .text
@@ -733,20 +675,20 @@ mod tests {
       ..StatefulTable::default()
     };
     series_history_table.sorting(vec![history_sort_option]);
-    app_arc.lock().await.data.sonarr_data.series_history = Some(series_history_table);
-    app_arc
+    app.lock().await.data.sonarr_data.series_history = Some(series_history_table);
+    app
       .lock()
       .await
       .data
       .sonarr_data
       .series
       .set_items(vec![series()]);
-    app_arc
+    app
       .lock()
       .await
       .push_navigation_stack(ActiveSonarrBlock::SeriesHistorySortPrompt.into());
-    app_arc.lock().await.server_tabs.next();
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    app.lock().await.server_tabs.next();
+    let mut network = test_network(&app);
 
     if let SonarrSerdeable::SonarrHistoryItems(history_items) = network
       .handle_sonarr_event(SonarrEvent::GetSeriesHistory(1))
@@ -754,24 +696,20 @@ mod tests {
       .unwrap()
     {
       async_server.assert_async().await;
-      assert!(app_arc
-        .lock()
-        .await
-        .data
-        .sonarr_data
-        .series_history
-        .is_some());
-      assert!(app_arc
-        .lock()
-        .await
-        .data
-        .sonarr_data
-        .series_history
-        .as_ref()
-        .unwrap()
-        .is_empty());
+      assert!(app.lock().await.data.sonarr_data.series_history.is_some());
       assert!(
-        app_arc
+        app
+          .lock()
+          .await
+          .data
+          .sonarr_data
+          .series_history
+          .as_ref()
+          .unwrap()
+          .is_empty()
+      );
+      assert!(
+        app
           .lock()
           .await
           .data
@@ -818,17 +756,11 @@ mod tests {
         ..series()
       },
     ];
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(json!([series_1, series_2])),
-      None,
-      SonarrEvent::ListSeries,
-      None,
-      None,
-    )
-    .await;
-    app_arc.lock().await.data.sonarr_data.series.sort_asc = true;
+    let (async_server, app, _server) = MockServarrApi::get()
+      .returns(json!([series_1, series_2]))
+      .build_for(SonarrEvent::ListSeries)
+      .await;
+    app.lock().await.data.sonarr_data.series.sort_asc = true;
     if use_custom_sorting {
       let cmp_fn = |a: &Series, b: &Series| {
         a.title
@@ -841,7 +773,7 @@ mod tests {
         name: "Title",
         cmp_fn: Some(cmp_fn),
       };
-      app_arc
+      app
         .lock()
         .await
         .data
@@ -849,8 +781,8 @@ mod tests {
         .series
         .sorting(vec![title_sort_option]);
     }
-    app_arc.lock().await.server_tabs.next();
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    app.lock().await.server_tabs.next();
+    let mut network = test_network(&app);
 
     if let SonarrSerdeable::SeriesVec(series) = network
       .handle_sonarr_event(SonarrEvent::ListSeries)
@@ -859,10 +791,10 @@ mod tests {
     {
       async_server.assert_async().await;
       assert_eq!(
-        app_arc.lock().await.data.sonarr_data.series.items,
+        app.lock().await.data.sonarr_data.series.items,
         expected_sorted_series
       );
-      assert!(app_arc.lock().await.data.sonarr_data.series.sort_asc);
+      assert!(app.lock().await.data.sonarr_data.series.sort_asc);
       assert_eq!(series, expected_series);
     }
   }
@@ -875,21 +807,15 @@ mod tests {
     *series_1.get_mut("title").unwrap() = json!("z test");
     *series_2.get_mut("id").unwrap() = json!(2);
     *series_2.get_mut("title").unwrap() = json!("A test");
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(json!([series_1, series_2])),
-      None,
-      SonarrEvent::ListSeries,
-      None,
-      None,
-    )
-    .await;
-    app_arc
+    let (async_server, app, _server) = MockServarrApi::get()
+      .returns(json!([series_1, series_2]))
+      .build_for(SonarrEvent::ListSeries)
+      .await;
+    app
       .lock()
       .await
       .push_navigation_stack(ActiveSonarrBlock::SeriesSortPrompt.into());
-    app_arc.lock().await.data.sonarr_data.series.sort_asc = true;
+    app.lock().await.data.sonarr_data.series.sort_asc = true;
     let cmp_fn = |a: &Series, b: &Series| {
       a.title
         .text
@@ -900,31 +826,26 @@ mod tests {
       name: "Title",
       cmp_fn: Some(cmp_fn),
     };
-    app_arc
+    app
       .lock()
       .await
       .data
       .sonarr_data
       .series
       .sorting(vec![title_sort_option]);
-    app_arc.lock().await.server_tabs.next();
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    app.lock().await.server_tabs.next();
+    let mut network = test_network(&app);
 
-    assert!(network
-      .handle_sonarr_event(SonarrEvent::ListSeries)
-      .await
-      .is_ok());
+    assert!(
+      network
+        .handle_sonarr_event(SonarrEvent::ListSeries)
+        .await
+        .is_ok()
+    );
 
     async_server.assert_async().await;
-    assert!(app_arc
-      .lock()
-      .await
-      .data
-      .sonarr_data
-      .series
-      .items
-      .is_empty());
-    assert!(app_arc.lock().await.data.sonarr_data.series.sort_asc);
+    assert!(app.lock().await.data.sonarr_data.series.items.is_empty());
+    assert!(app.lock().await.data.sonarr_data.series.sort_asc);
   }
 
   #[tokio::test]
@@ -942,19 +863,14 @@ mod tests {
       "ratings": { "votes": 406744, "value": 8.4 },
       "statistics": { "seasonCount": 3 }
     }]);
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(add_series_search_result_json),
-      None,
-      SonarrEvent::SearchNewSeries("test term".into()),
-      None,
-      Some("term=test%20term"),
-    )
-    .await;
-    app_arc.lock().await.data.sonarr_data.add_series_search = Some("test term".into());
-    app_arc.lock().await.server_tabs.next();
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let (async_server, app, _server) = MockServarrApi::get()
+      .returns(add_series_search_result_json)
+      .query("term=test%20term")
+      .build_for(SonarrEvent::SearchNewSeries("test term".into()))
+      .await;
+    app.lock().await.data.sonarr_data.add_series_search = Some("test term".into());
+    app.lock().await.server_tabs.next();
+    let mut network = test_network(&app);
 
     if let SonarrSerdeable::AddSeriesSearchResults(add_series_search_results) = network
       .handle_sonarr_event(SonarrEvent::SearchNewSeries("test term".into()))
@@ -962,15 +878,17 @@ mod tests {
       .unwrap()
     {
       async_server.assert_async().await;
-      assert!(app_arc
-        .lock()
-        .await
-        .data
-        .sonarr_data
-        .add_searched_series
-        .is_some());
+      assert!(
+        app
+          .lock()
+          .await
+          .data
+          .sonarr_data
+          .add_searched_series
+          .is_some()
+      );
       assert_eq!(
-        app_arc
+        app
           .lock()
           .await
           .data
@@ -987,119 +905,109 @@ mod tests {
 
   #[tokio::test]
   async fn test_handle_search_new_series_event_no_results() {
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(json!([])),
-      None,
-      SonarrEvent::SearchNewSeries("test term".into()),
-      None,
-      Some("term=test%20term"),
-    )
-    .await;
-    app_arc.lock().await.data.sonarr_data.add_series_search = Some("test term".into());
-    app_arc.lock().await.server_tabs.next();
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let (async_server, app, _server) = MockServarrApi::get()
+      .returns(json!([]))
+      .query("term=test%20term")
+      .build_for(SonarrEvent::SearchNewSeries("test term".into()))
+      .await;
+    app.lock().await.data.sonarr_data.add_series_search = Some("test term".into());
+    app.lock().await.server_tabs.next();
+    let mut network = test_network(&app);
 
-    assert!(network
-      .handle_sonarr_event(SonarrEvent::SearchNewSeries("test term".into()))
-      .await
-      .is_ok());
+    assert!(
+      network
+        .handle_sonarr_event(SonarrEvent::SearchNewSeries("test term".into()))
+        .await
+        .is_ok()
+    );
 
     async_server.assert_async().await;
-    assert!(app_arc
-      .lock()
-      .await
-      .data
-      .sonarr_data
-      .add_searched_series
-      .is_none());
+    assert!(
+      app
+        .lock()
+        .await
+        .data
+        .sonarr_data
+        .add_searched_series
+        .is_none()
+    );
     assert_eq!(
-      app_arc.lock().await.get_current_route(),
+      app.lock().await.get_current_route(),
       ActiveSonarrBlock::AddSeriesEmptySearchResults.into()
     );
   }
 
   #[tokio::test]
   async fn test_handle_trigger_automatic_series_search_event() {
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Post,
-      Some(json!({
+    let (async_server, app, _server) = MockServarrApi::post()
+      .with_request_body(json!({
         "name": "SeriesSearch",
         "seriesId": 1
-      })),
-      Some(json!({})),
-      None,
-      SonarrEvent::TriggerAutomaticSeriesSearch(1),
-      None,
-      None,
-    )
-    .await;
-    app_arc.lock().await.server_tabs.next();
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+      }))
+      .returns(json!({}))
+      .build_for(SonarrEvent::TriggerAutomaticSeriesSearch(1))
+      .await;
+    app.lock().await.server_tabs.next();
+    let mut network = test_network(&app);
 
-    assert!(network
-      .handle_sonarr_event(SonarrEvent::TriggerAutomaticSeriesSearch(1))
-      .await
-      .is_ok());
+    assert!(
+      network
+        .handle_sonarr_event(SonarrEvent::TriggerAutomaticSeriesSearch(1))
+        .await
+        .is_ok()
+    );
 
     async_server.assert_async().await;
   }
 
   #[tokio::test]
   async fn test_handle_update_all_series_event() {
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Post,
-      Some(json!({
+    let (async_server, app, _server) = MockServarrApi::post()
+      .with_request_body(json!({
         "name": "RefreshSeries",
-      })),
-      Some(json!({})),
-      None,
-      SonarrEvent::UpdateAllSeries,
-      None,
-      None,
-    )
-    .await;
-    app_arc.lock().await.server_tabs.next();
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+      }))
+      .returns(json!({}))
+      .build_for(SonarrEvent::UpdateAllSeries)
+      .await;
+    app.lock().await.server_tabs.next();
+    let mut network = test_network(&app);
 
-    assert!(network
-      .handle_sonarr_event(SonarrEvent::UpdateAllSeries)
-      .await
-      .is_ok());
+    assert!(
+      network
+        .handle_sonarr_event(SonarrEvent::UpdateAllSeries)
+        .await
+        .is_ok()
+    );
 
     async_server.assert_async().await;
   }
 
   #[tokio::test]
   async fn test_handle_update_and_scan_series_event() {
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Post,
-      Some(json!({
+    let (async_server, app, _server) = MockServarrApi::post()
+      .with_request_body(json!({
         "name": "RefreshSeries",
         "seriesId": 1,
-      })),
-      Some(json!({})),
-      None,
-      SonarrEvent::UpdateAndScanSeries(1),
-      None,
-      None,
-    )
-    .await;
-    app_arc
+      }))
+      .returns(json!({}))
+      .build_for(SonarrEvent::UpdateAndScanSeries(1))
+      .await;
+    app
       .lock()
       .await
       .data
       .sonarr_data
       .series
       .set_items(vec![series()]);
-    app_arc.lock().await.server_tabs.next();
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    app.lock().await.server_tabs.next();
+    let mut network = test_network(&app);
 
-    assert!(network
-      .handle_sonarr_event(SonarrEvent::UpdateAndScanSeries(1))
-      .await
-      .is_ok());
+    assert!(
+      network
+        .handle_sonarr_event(SonarrEvent::UpdateAndScanSeries(1))
+        .await
+        .is_ok()
+    );
 
     async_server.assert_async().await;
   }

src/network/sonarr_network/library/sonarr_library_network_tests.rs

@@ -1,12 +1,9 @@
 #[cfg(test)]
 mod tests {
   use crate::models::sonarr_models::SonarrReleaseDownloadBody;
-  use crate::network::network_tests::test_utils::mock_servarr_api;
+  use crate::network::network_tests::test_utils::{MockServarrApi, test_network};
   use crate::network::sonarr_network::SonarrEvent;
-  use crate::network::{Network, RequestMethod};
-  use reqwest::Client;
   use serde_json::json;
-  use tokio_util::sync::CancellationToken;
 
   #[tokio::test]
   async fn test_handle_download_sonarr_release_event_uses_provided_params() {
@@ -16,28 +13,25 @@ mod tests {
       series_id: Some(1),
       ..SonarrReleaseDownloadBody::default()
     };
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Post,
-      Some(json!({
+
+    let (mock, app, _server) = MockServarrApi::post()
+      .with_request_body(json!({
         "guid": "1234",
         "indexerId": 2,
         "seriesId": 1,
-      })),
-      Some(json!({})),
-      None,
-      SonarrEvent::DownloadRelease(params.clone()),
-      None,
-      None,
-    )
-    .await;
-    app_arc.lock().await.server_tabs.next();
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+      }))
+      .returns(json!({}))
+      .build_for(SonarrEvent::DownloadRelease(params.clone()))
+      .await;
 
-    assert!(network
+    app.lock().await.server_tabs.next();
+    let mut network = test_network(&app);
+
+    let result = network
       .handle_sonarr_event(SonarrEvent::DownloadRelease(params))
-      .await
-      .is_ok());
+      .await;
 
-    async_server.assert_async().await;
+    mock.assert_async().await;
+    assert!(result.is_ok());
   }
 }