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

src/network/mod.rs

@@ -1,13 +1,13 @@
 use std::fmt::Debug;
 use std::sync::Arc;
 
-use anyhow::{anyhow, Result};
+use anyhow::{Result, anyhow};
 use async_trait::async_trait;
 use log::{debug, error, warn};
 use regex::Regex;
 use reqwest::{Client, RequestBuilder};
-use serde::de::DeserializeOwned;
 use serde::Serialize;
+use serde::de::DeserializeOwned;
 use sonarr_network::SonarrEvent;
 use strum_macros::Display;
 use tokio::select;

src/network/network_tests.rs

@@ -6,54 +6,41 @@ mod tests {
 
   use mockito::{Mock, Server, ServerGuard};
   use pretty_assertions::assert_str_eq;
-  use reqwest::header::HeaderMap;
   use reqwest::Client;
+  use reqwest::header::HeaderMap;
   use rstest::rstest;
   use serde::{Deserialize, Serialize};
-  use tokio::sync::{mpsc, Mutex};
+  use serde_json::json;
+  use tokio::sync::{Mutex, mpsc};
   use tokio_util::sync::CancellationToken;
 
+  use super::test_utils;
   use crate::app::{App, AppConfig, ServarrConfig};
   use crate::models::HorizontallyScrollableText;
+  use crate::network::NetworkResource;
+  use crate::network::network_tests::test_utils::test_network;
   use crate::network::radarr_network::RadarrEvent;
   use crate::network::sonarr_network::SonarrEvent;
-  use crate::network::NetworkResource;
   use crate::network::{Network, NetworkEvent, NetworkTrait, RequestMethod, RequestProps};
 
   #[tokio::test]
   async fn test_handle_network_event_radarr_event() {
-    let mut server = Server::new_async().await;
-    let radarr_server = server
-      .mock("GET", "/api/v3/health")
-      .with_status(200)
-      .with_body("{}")
-      .create_async()
+    use test_utils::{MockServarrApi, test_network};
+
+    let (mock, app, _server) = MockServarrApi::get()
+      .returns(json!({}))
+      .build_for(RadarrEvent::HealthCheck)
       .await;
-    let host = Some(server.host_with_port().split(':').collect::<Vec<&str>>()[0].to_owned());
-    let port = Some(
-      server.host_with_port().split(':').collect::<Vec<&str>>()[1]
-        .parse()
-        .unwrap(),
-    );
-    let mut app = App::test_default();
-    app.is_loading = true;
-    let radarr_config = ServarrConfig {
-      host,
-      api_token: Some(String::new()),
-      port,
-      ssl_cert_path: None,
-      ..ServarrConfig::default()
-    };
-    app.server_tabs.tabs[0].config = Some(radarr_config);
-    let app_arc = Arc::new(Mutex::new(app));
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+
+    app.lock().await.is_loading = true;
+    let mut network = test_network(&app);
 
     let _ = network
       .handle_network_event(RadarrEvent::HealthCheck.into())
       .await;
 
-    radarr_server.assert_async().await;
-    assert!(!app_arc.lock().await.is_loading);
+    mock.assert_async().await;
+    assert!(!app.lock().await.is_loading);
   }
 
   #[rstest]
@@ -70,7 +57,7 @@ mod tests {
       .create_async()
       .await;
     let app_arc = Arc::new(Mutex::new(App::test_default()));
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let mut network = test_network(&app_arc);
 
     let _ = network
       .handle_request::<Test, ()>(
@@ -97,7 +84,7 @@ mod tests {
     #[values(RequestMethod::Get, RequestMethod::Post)] request_method: RequestMethod,
   ) {
     let (async_server, app_arc, server) = mock_api(request_method, 200, true).await;
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let mut network = test_network(&app_arc);
 
     let resp = network
       .handle_request::<(), Test>(
@@ -130,7 +117,7 @@ mod tests {
     #[values(RequestMethod::Get, RequestMethod::Post)] request_method: RequestMethod,
   ) {
     let (async_server, app_arc, server) = mock_api(request_method, 400, true).await;
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let mut network = test_network(&app_arc);
     let mut test_result = String::new();
 
     let resp = network
@@ -224,7 +211,7 @@ mod tests {
       .create_async()
       .await;
     let app_arc = Arc::new(Mutex::new(App::test_default()));
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let mut network = test_network(&app_arc);
 
     let resp = network
       .handle_request::<(), Test>(
@@ -241,23 +228,27 @@ mod tests {
       .await;
 
     async_server.assert_async().await;
-    assert!(app_arc
-      .lock()
-      .await
-      .error
-      .text
-      .starts_with("Failed to parse response!"));
+    assert!(
+      app_arc
+        .lock()
+        .await
+        .error
+        .text
+        .starts_with("Failed to parse response!")
+    );
     assert!(resp.is_err());
-    assert!(resp
-      .unwrap_err()
-      .to_string()
-      .starts_with("Failed to parse response!"));
+    assert!(
+      resp
+        .unwrap_err()
+        .to_string()
+        .starts_with("Failed to parse response!")
+    );
   }
 
   #[tokio::test]
   async fn test_handle_request_failure_to_send_request() {
     let app_arc = Arc::new(Mutex::new(App::test_default()));
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let mut network = test_network(&app_arc);
 
     let resp = network
       .handle_request::<(), Test>(
@@ -273,17 +264,21 @@ mod tests {
       )
       .await;
 
-    assert!(app_arc
-      .lock()
-      .await
-      .error
-      .text
-      .starts_with("Failed to send request."));
+    assert!(
+      app_arc
+        .lock()
+        .await
+        .error
+        .text
+        .starts_with("Failed to send request.")
+    );
     assert!(resp.is_err());
-    assert!(resp
-      .unwrap_err()
-      .to_string()
-      .starts_with("Failed to send request."));
+    assert!(
+      resp
+        .unwrap_err()
+        .to_string()
+        .starts_with("Failed to send request.")
+    );
   }
 
   #[rstest]
@@ -298,7 +293,7 @@ mod tests {
     request_method: RequestMethod,
   ) {
     let (async_server, app_arc, server) = mock_api(request_method, 404, true).await;
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let mut network = test_network(&app_arc);
 
     let resp = network
       .handle_request::<(), Test>(
@@ -329,7 +324,7 @@ mod tests {
   #[tokio::test]
   async fn test_handle_request_non_success_code_empty_response_body() {
     let (async_server, app_arc, server) = mock_api(RequestMethod::Post, 404, false).await;
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let mut network = test_network(&app_arc);
 
     let resp = network
       .handle_request::<(), Test>(
@@ -391,7 +386,7 @@ mod tests {
 
     async_server = async_server.create_async().await;
     let app_arc = Arc::new(Mutex::new(App::test_default()));
-    let network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let network = test_network(&app_arc);
 
     network
       .call_api(RequestProps {
@@ -415,10 +410,10 @@ mod tests {
   #[rstest]
   async fn test_request_props_from_requires_radarr_config_to_be_present_for_all_network_events(
     #[values(RadarrEvent::HealthCheck, SonarrEvent::HealthCheck)] network_event: impl Into<NetworkEvent>
-      + NetworkResource,
+    + NetworkResource,
   ) {
     let app_arc = Arc::new(Mutex::new(App::default()));
-    let network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let network = test_network(&app_arc);
 
     network
       .request_props_from(network_event, RequestMethod::Get, None::<()>, None, None)
@@ -434,7 +429,7 @@ mod tests {
     #[case] default_port: u16,
   ) {
     let app_arc = Arc::new(Mutex::new(App::test_default()));
-    let network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let network = test_network(&app_arc);
     let resource = network_event.resource();
     {
       let mut app = app_arc.lock().await;
@@ -460,7 +455,7 @@ mod tests {
   #[tokio::test]
   async fn test_request_props_from_custom_config(
     #[values(RadarrEvent::GetMovies, SonarrEvent::ListSeries)] network_event: impl Into<NetworkEvent>
-      + NetworkResource,
+    + NetworkResource,
   ) {
     let api_token = "testToken1234".to_owned();
     let app_arc = Arc::new(Mutex::new(App::test_default()));
@@ -477,7 +472,7 @@ mod tests {
       app.server_tabs.tabs[0].config = Some(servarr_config.clone());
       app.server_tabs.tabs[1].config = Some(servarr_config);
     }
-    let network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let network = test_network(&app_arc);
 
     let request_props = network
       .request_props_from(network_event, RequestMethod::Get, None::<()>, None, None)
@@ -497,7 +492,7 @@ mod tests {
   #[tokio::test]
   async fn test_request_props_from_custom_config_custom_headers(
     #[values(RadarrEvent::GetMovies, SonarrEvent::ListSeries)] network_event: impl Into<NetworkEvent>
-      + NetworkResource,
+    + NetworkResource,
   ) {
     let api_token = "testToken1234".to_owned();
     let app_arc = Arc::new(Mutex::new(App::test_default()));
@@ -517,7 +512,7 @@ mod tests {
       app.server_tabs.tabs[0].config = Some(servarr_config.clone());
       app.server_tabs.tabs[1].config = Some(servarr_config);
     }
-    let network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let network = test_network(&app_arc);
 
     let request_props = network
       .request_props_from(network_event, RequestMethod::Get, None::<()>, None, None)
@@ -537,7 +532,7 @@ mod tests {
   #[tokio::test]
   async fn test_request_props_from_custom_config_using_uri_instead_of_host_and_port(
     #[values(RadarrEvent::GetMovies, SonarrEvent::ListSeries)] network_event: impl Into<NetworkEvent>
-      + NetworkResource,
+    + NetworkResource,
   ) {
     let api_token = "testToken1234".to_owned();
     let app_arc = Arc::new(Mutex::new(App::test_default()));
@@ -552,7 +547,7 @@ mod tests {
       app.server_tabs.tabs[0].config = Some(servarr_config.clone());
       app.server_tabs.tabs[1].config = Some(servarr_config);
     }
-    let network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let network = test_network(&app_arc);
 
     let request_props = network
       .request_props_from(network_event, RequestMethod::Get, None::<()>, None, None)
@@ -577,7 +572,7 @@ mod tests {
     #[case] default_port: u16,
   ) {
     let app_arc = Arc::new(Mutex::new(App::test_default()));
-    let network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let network = test_network(&app_arc);
     let resource = network_event.resource();
     {
       let mut app = app_arc.lock().await;
@@ -609,7 +604,7 @@ mod tests {
   #[tokio::test]
   async fn test_request_props_from_custom_config_with_path_and_query_params(
     #[values(RadarrEvent::GetMovies, SonarrEvent::ListSeries)] network_event: impl Into<NetworkEvent>
-      + NetworkResource,
+    + NetworkResource,
   ) {
     let api_token = "testToken1234".to_owned();
     let app_arc = Arc::new(Mutex::new(App::test_default()));
@@ -626,7 +621,7 @@ mod tests {
       app.server_tabs.tabs[0].config = Some(servarr_config.clone());
       app.server_tabs.tabs[1].config = Some(servarr_config);
     }
-    let network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let network = test_network(&app_arc);
 
     let request_props = network
       .request_props_from(
@@ -652,7 +647,7 @@ mod tests {
   #[tokio::test]
   async fn test_request_props_from_custom_config_using_uri_instead_of_host_and_port_with_path_and_query_params(
     #[values(RadarrEvent::GetMovies, SonarrEvent::ListSeries)] network_event: impl Into<NetworkEvent>
-      + NetworkResource,
+    + NetworkResource,
   ) {
     let api_token = "testToken1234".to_owned();
     let app_arc = Arc::new(Mutex::new(App::test_default()));
@@ -667,7 +662,7 @@ mod tests {
       app.server_tabs.tabs[0].config = Some(servarr_config.clone());
       app.server_tabs.tabs[1].config = Some(servarr_config);
     }
-    let network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let network = test_network(&app_arc);
 
     let request_props = network
       .request_props_from(
@@ -725,72 +720,161 @@ pub(in crate::network) mod test_utils {
   use std::sync::Arc;
 
   use mockito::{Matcher, Mock, Server, ServerGuard};
+  use reqwest::Client;
   use serde_json::Value;
   use tokio::sync::Mutex;
+  use tokio_util::sync::CancellationToken;
 
   use crate::{
     app::{App, ServarrConfig},
-    network::{NetworkEvent, NetworkResource, RequestMethod},
+    network::{Network, NetworkEvent, NetworkResource, RequestMethod},
   };
 
-  pub async fn mock_servarr_api<'a>(
+  /// Creates a test HTTP client
+  pub fn test_client() -> Client {
+    Client::new()
+  }
+
+  /// Creates a test cancellation token
+  pub fn test_cancellation_token() -> CancellationToken {
+    CancellationToken::new()
+  }
+
+  /// Creates a test network instance
+  pub fn test_network<'a, 'b>(app: &'a Arc<Mutex<App<'b>>>) -> Network<'a, 'b> {
+    Network::new(app, test_cancellation_token(), test_client())
+  }
+
+  pub struct MockServarrApi {
     method: RequestMethod,
     request_body: Option<Value>,
     response_body: Option<Value>,
-    response_status: Option<usize>,
-    network_event: impl Into<NetworkEvent> + NetworkResource,
-    path: Option<&str>,
-    query_params: Option<&str>,
-  ) -> (Mock, Arc<Mutex<App<'a>>>, ServerGuard) {
-    let status = response_status.unwrap_or(200);
-    let resource = network_event.resource();
-    let mut server = Server::new_async().await;
-    let mut uri = format!("/api/v3{resource}");
+    response_status: usize,
+    path: Option<String>,
+    query_params: Option<String>,
+  }
 
-    if let Some(path) = path {
-      uri = format!("{uri}{path}");
+  impl MockServarrApi {
+    /// Create a GET request builder
+    pub fn get() -> Self {
+      Self::new(RequestMethod::Get)
     }
 
-    if let Some(params) = query_params {
-      uri = format!("{uri}?{params}");
+    /// Create a POST request builder
+    pub fn post() -> Self {
+      Self::new(RequestMethod::Post)
     }
 
-    let mut async_server = server
-      .mock(&method.to_string().to_uppercase(), uri.as_str())
-      .match_header("X-Api-Key", "test1234")
-      .with_status(status);
-
-    if let Some(body) = request_body {
-      async_server = async_server.match_body(Matcher::Json(body));
+    /// Create a PUT request builder
+    #[allow(dead_code)]
+    pub fn put() -> Self {
+      Self::new(RequestMethod::Put)
     }
 
-    if let Some(body) = response_body {
-      async_server = async_server.with_body(body.to_string());
+    /// Create a DELETE request builder
+    pub fn delete() -> Self {
+      Self::new(RequestMethod::Delete)
     }
 
-    async_server = async_server.create_async().await;
-
-    let host = Some(server.host_with_port().split(':').collect::<Vec<&str>>()[0].to_owned());
-    let port = Some(
-      server.host_with_port().split(':').collect::<Vec<&str>>()[1]
-        .parse()
-        .unwrap(),
-    );
-    let mut app = App::test_default();
-    let servarr_config = ServarrConfig {
-      host,
-      port,
-      api_token: Some("test1234".to_owned()),
-      ..ServarrConfig::default()
-    };
-
-    match network_event.into() {
-      NetworkEvent::Radarr(_) => app.server_tabs.tabs[0].config = Some(servarr_config),
-      NetworkEvent::Sonarr(_) => app.server_tabs.tabs[1].config = Some(servarr_config),
+    /// Create a builder with a specific request method
+    pub fn new(method: RequestMethod) -> Self {
+      Self {
+        method,
+        request_body: None,
+        response_body: None,
+        response_status: 200,
+        path: None,
+        query_params: None,
+      }
     }
 
-    let app_arc = Arc::new(Mutex::new(app));
+    /// Set the expected request body
+    pub fn with_request_body(mut self, body: Value) -> Self {
+      self.request_body = Some(body);
+      self
+    }
 
-    (async_server, app_arc, server)
+    /// Set the response body to return
+    pub fn returns(mut self, body: Value) -> Self {
+      self.response_body = Some(body);
+      self
+    }
+
+    /// Set the HTTP status code
+    pub fn status(mut self, status: usize) -> Self {
+      self.response_status = status;
+      self
+    }
+
+    /// Add a path suffix to the resource URL
+    pub fn path(mut self, path: impl Into<String>) -> Self {
+      self.path = Some(path.into());
+      self
+    }
+
+    /// Add query parameters
+    pub fn query(mut self, params: impl Into<String>) -> Self {
+      self.query_params = Some(params.into());
+      self
+    }
+
+    /// Build the mock for a specific network event
+    pub async fn build_for<E>(
+      self,
+      network_event: E,
+    ) -> (Mock, Arc<Mutex<App<'static>>>, ServerGuard)
+    where
+      E: Into<NetworkEvent> + NetworkResource,
+    {
+      let resource = network_event.resource();
+      let mut server = Server::new_async().await;
+      let mut uri = format!("/api/v3{resource}");
+
+      if let Some(path) = &self.path {
+        uri = format!("{uri}{path}");
+      }
+
+      if let Some(params) = &self.query_params {
+        uri = format!("{uri}?{params}");
+      }
+
+      let mut mock_builder = server
+        .mock(&self.method.to_string().to_uppercase(), uri.as_str())
+        .match_header("X-Api-Key", "test1234")
+        .with_status(self.response_status);
+
+      if let Some(body) = &self.request_body {
+        mock_builder = mock_builder.match_body(Matcher::Json(body.clone()));
+      }
+
+      if let Some(body) = &self.response_body {
+        mock_builder = mock_builder.with_body(body.to_string());
+      }
+
+      let mock = mock_builder.create_async().await;
+
+      let host = Some(server.host_with_port().split(':').collect::<Vec<&str>>()[0].to_owned());
+      let port = Some(
+        server.host_with_port().split(':').collect::<Vec<&str>>()[1]
+          .parse()
+          .unwrap(),
+      );
+      let mut app = App::test_default();
+      let servarr_config = ServarrConfig {
+        host,
+        port,
+        api_token: Some("test1234".to_owned()),
+        ..ServarrConfig::default()
+      };
+
+      match network_event.into() {
+        NetworkEvent::Radarr(_) => app.server_tabs.tabs[0].config = Some(servarr_config),
+        NetworkEvent::Sonarr(_) => app.server_tabs.tabs[1].config = Some(servarr_config),
+      }
+
+      let app_arc = Arc::new(Mutex::new(app));
+
+      (mock, app_arc, server)
+    }
   }
 }

src/network/radarr_network/blocklist/mod.rs

@@ -1,11 +1,11 @@
+use crate::models::Route;
 use crate::models::radarr_models::BlocklistResponse;
 use crate::models::servarr_data::radarr::radarr_data::ActiveRadarrBlock;
-use crate::models::Route;
 use crate::network::radarr_network::RadarrEvent;
 use crate::network::{Network, RequestMethod};
 use anyhow::Result;
 use log::info;
-use serde_json::{json, Value};
+use serde_json::{Value, json};
 
 #[cfg(test)]
 #[path = "radarr_blocklist_network_tests.rs"]

src/network/radarr_network/blocklist/radarr_blocklist_network_tests.rs

@@ -5,16 +5,13 @@ mod tests {
   use crate::models::radarr_models::BlocklistResponse;
   use crate::models::servarr_data::radarr::radarr_data::ActiveRadarrBlock;
   use crate::models::stateful_table::SortOption;
-  use crate::network::network_tests::test_utils::mock_servarr_api;
-  use crate::network::radarr_network::radarr_network_test_utils::test_utils::blocklist_item;
+  use crate::network::network_tests::test_utils::{MockServarrApi, test_network};
   use crate::network::radarr_network::RadarrEvent;
   use crate::network::radarr_network::RadarrSerdeable;
-  use crate::network::{Network, RequestMethod};
+  use crate::network::radarr_network::radarr_network_test_utils::test_utils::blocklist_item;
   use pretty_assertions::assert_eq;
-  use reqwest::Client;
   use rstest::rstest;
   use serde_json::json;
-  use tokio_util::sync::CancellationToken;
 
   #[tokio::test]
   async fn test_handle_clear_radarr_blocklist_event() {
@@ -33,53 +30,45 @@ mod tests {
       },
     ];
     let expected_request_json = json!({ "ids": [1, 2, 3]});
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Delete,
-      Some(expected_request_json),
-      None,
-      None,
-      RadarrEvent::ClearBlocklist,
-      None,
-      None,
-    )
-    .await;
-    app_arc
+    let (mock, app, _server) = MockServarrApi::delete()
+      .with_request_body(expected_request_json)
+      .build_for(RadarrEvent::ClearBlocklist)
+      .await;
+    app
       .lock()
       .await
       .data
       .radarr_data
       .blocklist
       .set_items(blocklist_items);
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let mut network = test_network(&app);
 
-    assert!(network
-      .handle_radarr_event(RadarrEvent::ClearBlocklist)
-      .await
-      .is_ok());
+    assert!(
+      network
+        .handle_radarr_event(RadarrEvent::ClearBlocklist)
+        .await
+        .is_ok()
+    );
 
-    async_server.assert_async().await;
+    mock.assert_async().await;
   }
 
   #[tokio::test]
   async fn test_handle_delete_radarr_blocklist_item_event() {
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Delete,
-      None,
-      None,
-      None,
-      RadarrEvent::DeleteBlocklistItem(1),
-      Some("/1"),
-      None,
-    )
-    .await;
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let (mock, app, _server) = MockServarrApi::delete()
+      .path("/1")
+      .build_for(RadarrEvent::DeleteBlocklistItem(1))
+      .await;
+    let mut network = test_network(&app);
 
-    assert!(network
-      .handle_radarr_event(RadarrEvent::DeleteBlocklistItem(1))
-      .await
-      .is_ok());
+    assert!(
+      network
+        .handle_radarr_event(RadarrEvent::DeleteBlocklistItem(1))
+        .await
+        .is_ok()
+    );
 
-    async_server.assert_async().await;
+    mock.assert_async().await;
   }
 
   #[rstest]
@@ -179,17 +168,11 @@ mod tests {
         ..blocklist_item()
       },
     ];
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(blocklist_json),
-      None,
-      RadarrEvent::GetBlocklist,
-      None,
-      None,
-    )
-    .await;
-    app_arc.lock().await.data.radarr_data.blocklist.sort_asc = true;
+    let (mock, app, _server) = MockServarrApi::get()
+      .returns(blocklist_json)
+      .build_for(RadarrEvent::GetBlocklist)
+      .await;
+    app.lock().await.data.radarr_data.blocklist.sort_asc = true;
     if use_custom_sorting {
       let cmp_fn = |a: &BlocklistItem, b: &BlocklistItem| {
         a.source_title
@@ -202,7 +185,7 @@ mod tests {
         name: "Source Title",
         cmp_fn: Some(cmp_fn),
       };
-      app_arc
+      app
         .lock()
         .await
         .data
@@ -210,19 +193,19 @@ mod tests {
         .blocklist
         .sorting(vec![blocklist_sort_option]);
     }
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let mut network = test_network(&app);
 
     if let RadarrSerdeable::BlocklistResponse(blocklist) = network
       .handle_radarr_event(RadarrEvent::GetBlocklist)
       .await
       .unwrap()
     {
-      async_server.assert_async().await;
+      mock.assert_async().await;
       assert_eq!(
-        app_arc.lock().await.data.radarr_data.blocklist.items,
+        app.lock().await.data.radarr_data.blocklist.items,
         expected_blocklist
       );
-      assert!(app_arc.lock().await.data.radarr_data.blocklist.sort_asc);
+      assert!(app.lock().await.data.radarr_data.blocklist.sort_asc);
       assert_eq!(blocklist, response);
     }
   }
@@ -302,18 +285,12 @@ mod tests {
           },
         },
     }]});
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(blocklist_json),
-      None,
-      RadarrEvent::GetBlocklist,
-      None,
-      None,
-    )
-    .await;
-    app_arc.lock().await.data.radarr_data.blocklist.sort_asc = true;
-    app_arc
+    let (mock, app, _server) = MockServarrApi::get()
+      .returns(blocklist_json)
+      .build_for(RadarrEvent::GetBlocklist)
+      .await;
+    app.lock().await.data.radarr_data.blocklist.sort_asc = true;
+    app
       .lock()
       .await
       .push_navigation_stack(ActiveRadarrBlock::BlocklistSortPrompt.into());
@@ -326,29 +303,24 @@ mod tests {
       name: "Source Title",
       cmp_fn: Some(cmp_fn),
     };
-    app_arc
+    app
       .lock()
       .await
       .data
       .radarr_data
       .blocklist
       .sorting(vec![blocklist_sort_option]);
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let mut network = test_network(&app);
 
-    assert!(network
-      .handle_radarr_event(RadarrEvent::GetBlocklist)
-      .await
-      .is_ok());
+    assert!(
+      network
+        .handle_radarr_event(RadarrEvent::GetBlocklist)
+        .await
+        .is_ok()
+    );
 
-    async_server.assert_async().await;
-    assert!(app_arc
-      .lock()
-      .await
-      .data
-      .radarr_data
-      .blocklist
-      .items
-      .is_empty());
-    assert!(app_arc.lock().await.data.radarr_data.blocklist.sort_asc);
+    mock.assert_async().await;
+    assert!(app.lock().await.data.radarr_data.blocklist.items.is_empty());
+    assert!(app.lock().await.data.radarr_data.blocklist.sort_asc);
   }
 }

src/network/radarr_network/collections/mod.rs

@@ -1,12 +1,12 @@
+use crate::models::Route;
 use crate::models::radarr_models::{Collection, EditCollectionParams};
 use crate::models::servarr_data::radarr::radarr_data::ActiveRadarrBlock;
 use crate::models::servarr_models::CommandBody;
-use crate::models::Route;
 use crate::network::radarr_network::RadarrEvent;
 use crate::network::{Network, RequestMethod};
 use anyhow::Result;
 use log::{debug, info};
-use serde_json::{json, Value};
+use serde_json::{Value, json};
 
 #[cfg(test)]
 #[path = "radarr_collections_network_tests.rs"]

src/network/radarr_network/collections/radarr_collections_network_tests.rs

@@ -5,16 +5,14 @@ mod tests {
   };
   use crate::models::servarr_data::radarr::radarr_data::ActiveRadarrBlock;
   use crate::models::stateful_table::SortOption;
-  use crate::network::network_tests::test_utils::mock_servarr_api;
-  use crate::network::radarr_network::radarr_network_test_utils::test_utils::collection;
+  use crate::network::NetworkResource;
+  use crate::network::network_tests::test_utils::{MockServarrApi, test_network};
   use crate::network::radarr_network::RadarrEvent;
-  use crate::network::{Network, NetworkResource, RequestMethod};
+  use crate::network::radarr_network::radarr_network_test_utils::test_utils::collection;
   use mockito::Matcher;
   use pretty_assertions::assert_eq;
-  use reqwest::Client;
   use rstest::rstest;
   use serde_json::json;
-  use tokio_util::sync::CancellationToken;
 
   #[tokio::test]
   async fn test_handle_edit_collection_event() {
@@ -64,17 +62,12 @@ mod tests {
       search_on_add: Some(false),
     };
 
-    let (async_details_server, app_arc, mut server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(detailed_collection_body),
-      None,
-      RadarrEvent::GetCollections,
-      Some("/123"),
-      None,
-    )
-    .await;
-    let async_edit_server = server
+    let (mock_details, app, mut server) = MockServarrApi::get()
+      .returns(detailed_collection_body)
+      .path("/123")
+      .build_for(RadarrEvent::GetCollections)
+      .await;
+    let mock_edit = server
       .mock(
         "PUT",
         format!(
@@ -88,20 +81,22 @@ mod tests {
       .match_body(Matcher::Json(expected_body))
       .create_async()
       .await;
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let mut network = test_network(&app);
 
-    assert!(network
-      .handle_radarr_event(RadarrEvent::EditCollection(edit_collection_params))
-      .await
-      .is_ok());
+    assert!(
+      network
+        .handle_radarr_event(RadarrEvent::EditCollection(edit_collection_params))
+        .await
+        .is_ok()
+    );
 
-    async_details_server.assert_async().await;
-    async_edit_server.assert_async().await;
+    mock_details.assert_async().await;
+    mock_edit.assert_async().await;
   }
 
   #[tokio::test]
-  async fn test_handle_edit_collection_event_defaults_to_previous_values_when_no_params_are_provided(
-  ) {
+  async fn test_handle_edit_collection_event_defaults_to_previous_values_when_no_params_are_provided()
+   {
     let detailed_collection_body = json!({
       "id": 123,
       "title": "Test Collection",
@@ -140,21 +135,16 @@ mod tests {
     *expected_body.get_mut("rootFolderPath").unwrap() = json!("/nfs/movies");
     *expected_body.get_mut("searchOnAdd").unwrap() = json!(true);
 
-    let (async_details_server, app_arc, mut server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(detailed_collection_body),
-      None,
-      RadarrEvent::GetCollections,
-      Some("/123"),
-      None,
-    )
-    .await;
+    let (mock_details, app, mut server) = MockServarrApi::get()
+      .returns(detailed_collection_body)
+      .path("/123")
+      .build_for(RadarrEvent::GetCollections)
+      .await;
     let edit_collection_params = EditCollectionParams {
       collection_id: 123,
       ..EditCollectionParams::default()
     };
-    let async_edit_server = server
+    let mock_edit = server
       .mock(
         "PUT",
         format!(
@@ -172,15 +162,17 @@ mod tests {
       collection_id: 123,
       ..EditCollectionParams::default()
     };
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let mut network = test_network(&app);
 
-    assert!(network
-      .handle_radarr_event(RadarrEvent::EditCollection(edit_collection_params))
-      .await
-      .is_ok());
+    assert!(
+      network
+        .handle_radarr_event(RadarrEvent::EditCollection(edit_collection_params))
+        .await
+        .is_ok()
+    );
 
-    async_details_server.assert_async().await;
-    async_edit_server.assert_async().await;
+    mock_details.assert_async().await;
+    mock_edit.assert_async().await;
   }
 
   #[rstest]
@@ -257,17 +249,11 @@ mod tests {
         ..collection()
       },
     ];
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(collections_json),
-      None,
-      RadarrEvent::GetCollections,
-      None,
-      None,
-    )
-    .await;
-    app_arc.lock().await.data.radarr_data.collections.sort_asc = true;
+    let (mock, app, _server) = MockServarrApi::get()
+      .returns(collections_json)
+      .build_for(RadarrEvent::GetCollections)
+      .await;
+    app.lock().await.data.radarr_data.collections.sort_asc = true;
     if use_custom_sorting {
       let cmp_fn = |a: &Collection, b: &Collection| {
         a.title
@@ -281,7 +267,7 @@ mod tests {
         name: "Collection",
         cmp_fn: Some(cmp_fn),
       };
-      app_arc
+      app
         .lock()
         .await
         .data
@@ -289,19 +275,19 @@ mod tests {
         .collections
         .sorting(vec![collection_sort_option]);
     }
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let mut network = test_network(&app);
 
     if let RadarrSerdeable::Collections(collections) = network
       .handle_radarr_event(RadarrEvent::GetCollections)
       .await
       .unwrap()
     {
-      async_server.assert_async().await;
+      mock.assert_async().await;
       assert_eq!(
-        app_arc.lock().await.data.radarr_data.collections.items,
+        app.lock().await.data.radarr_data.collections.items,
         expected_collections
       );
-      assert!(app_arc.lock().await.data.radarr_data.collections.sort_asc);
+      assert!(app.lock().await.data.radarr_data.collections.sort_asc);
       assert_eq!(collections, response);
     }
   }
@@ -366,18 +352,12 @@ mod tests {
         }
       }],
     }]);
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(collections_json),
-      None,
-      RadarrEvent::GetCollections,
-      None,
-      None,
-    )
-    .await;
-    app_arc.lock().await.data.radarr_data.collections.sort_asc = true;
-    app_arc
+    let (mock, app, _server) = MockServarrApi::get()
+      .returns(collections_json)
+      .build_for(RadarrEvent::GetCollections)
+      .await;
+    app.lock().await.data.radarr_data.collections.sort_asc = true;
+    app
       .lock()
       .await
       .push_navigation_stack(ActiveRadarrBlock::CollectionsSortPrompt.into());
@@ -391,53 +371,54 @@ mod tests {
       name: "Collection",
       cmp_fn: Some(cmp_fn),
     };
-    app_arc
+    app
       .lock()
       .await
       .data
       .radarr_data
       .collections
       .sorting(vec![collection_sort_option]);
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let mut network = test_network(&app);
 
-    assert!(network
-      .handle_radarr_event(RadarrEvent::GetCollections)
-      .await
-      .is_ok());
+    assert!(
+      network
+        .handle_radarr_event(RadarrEvent::GetCollections)
+        .await
+        .is_ok()
+    );
 
-    async_server.assert_async().await;
-    assert!(app_arc
-      .lock()
-      .await
-      .data
-      .radarr_data
-      .collections
-      .items
-      .is_empty());
-    assert!(app_arc.lock().await.data.radarr_data.collections.sort_asc);
+    mock.assert_async().await;
+    assert!(
+      app
+        .lock()
+        .await
+        .data
+        .radarr_data
+        .collections
+        .items
+        .is_empty()
+    );
+    assert!(app.lock().await.data.radarr_data.collections.sort_asc);
   }
 
   #[tokio::test]
   async fn test_handle_update_collections_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": "RefreshCollections"
-      })),
-      Some(json!({})),
-      None,
-      RadarrEvent::UpdateCollections,
-      None,
-      None,
-    )
-    .await;
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+      }))
+      .returns(json!({}))
+      .build_for(RadarrEvent::UpdateCollections)
+      .await;
+    let mut network = test_network(&app);
 
-    assert!(network
-      .handle_radarr_event(RadarrEvent::UpdateCollections)
-      .await
-      .is_ok());
+    assert!(
+      network
+        .handle_radarr_event(RadarrEvent::UpdateCollections)
+        .await
+        .is_ok()
+    );
 
-    async_server.assert_async().await;
+    mock.assert_async().await;
   }
 }

src/network/radarr_network/downloads/radarr_downloads_network_tests.rs

@@ -1,34 +1,27 @@
 #[cfg(test)]
 mod tests {
   use crate::models::radarr_models::{DownloadsResponse, RadarrSerdeable};
-  use crate::network::network_tests::test_utils::mock_servarr_api;
-  use crate::network::radarr_network::radarr_network_test_utils::test_utils::downloads_response;
+  use crate::network::network_tests::test_utils::{MockServarrApi, test_network};
   use crate::network::radarr_network::RadarrEvent;
-  use crate::network::{Network, RequestMethod};
-  use reqwest::Client;
+  use crate::network::radarr_network::radarr_network_test_utils::test_utils::downloads_response;
   use serde_json::json;
-  use tokio_util::sync::CancellationToken;
 
   #[tokio::test]
   async fn test_handle_delete_radarr_download_event() {
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Delete,
-      None,
-      None,
-      None,
-      RadarrEvent::DeleteDownload(1),
-      Some("/1"),
-      None,
-    )
-    .await;
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let (mock, app, _server) = MockServarrApi::delete()
+      .path("/1")
+      .build_for(RadarrEvent::DeleteDownload(1))
+      .await;
+    let mut network = test_network(&app);
 
-    assert!(network
-      .handle_radarr_event(RadarrEvent::DeleteDownload(1))
-      .await
-      .is_ok());
+    assert!(
+      network
+        .handle_radarr_event(RadarrEvent::DeleteDownload(1))
+        .await
+        .is_ok()
+    );
 
-    async_server.assert_async().await;
+    mock.assert_async().await;
   }
 
   #[tokio::test]
@@ -48,26 +41,21 @@ mod tests {
     });
     let response: DownloadsResponse =
       serde_json::from_value(downloads_response_json.clone()).unwrap();
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(downloads_response_json),
-      None,
-      RadarrEvent::GetDownloads(500),
-      None,
-      Some("pageSize=500"),
-    )
-    .await;
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let (mock, app, _server) = MockServarrApi::get()
+      .returns(downloads_response_json)
+      .path("?pageSize=500")
+      .build_for(RadarrEvent::GetDownloads(500))
+      .await;
+    let mut network = test_network(&app);
 
     if let RadarrSerdeable::DownloadsResponse(downloads) = network
       .handle_radarr_event(RadarrEvent::GetDownloads(500))
       .await
       .unwrap()
     {
-      async_server.assert_async().await;
+      mock.assert_async().await;
       pretty_assertions::assert_eq!(
-        app_arc.lock().await.data.radarr_data.downloads.items,
+        app.lock().await.data.radarr_data.downloads.items,
         downloads_response().records
       );
       pretty_assertions::assert_eq!(downloads, response);
@@ -76,25 +64,22 @@ mod tests {
 
   #[tokio::test]
   async fn test_handle_update_radarr_downloads_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": "RefreshMonitoredDownloads"
-      })),
-      Some(json!({})),
-      None,
-      RadarrEvent::UpdateDownloads,
-      None,
-      None,
-    )
-    .await;
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+      }))
+      .returns(json!({}))
+      .build_for(RadarrEvent::UpdateDownloads)
+      .await;
+    let mut network = test_network(&app);
 
-    assert!(network
-      .handle_radarr_event(RadarrEvent::UpdateDownloads)
-      .await
-      .is_ok());
+    assert!(
+      network
+        .handle_radarr_event(RadarrEvent::UpdateDownloads)
+        .await
+        .is_ok()
+    );
 
-    async_server.assert_async().await;
+    mock.assert_async().await;
   }
 }

src/network/radarr_network/indexers/mod.rs

@@ -6,7 +6,7 @@ use crate::network::radarr_network::RadarrEvent;
 use crate::network::{Network, RequestMethod};
 use anyhow::Result;
 use log::{debug, info};
-use serde_json::{json, Value};
+use serde_json::{Value, json};
 
 #[cfg(test)]
 #[path = "radarr_indexers_network_tests.rs"]

src/network/radarr_network/indexers/radarr_indexers_network_tests.rs

@@ -1,40 +1,34 @@
 #[cfg(test)]
 mod tests {
+  use crate::models::HorizontallyScrollableText;
   use crate::models::radarr_models::{IndexerSettings, RadarrSerdeable};
   use crate::models::servarr_data::modals::IndexerTestResultModalItem;
   use crate::models::servarr_models::{EditIndexerParams, Indexer, IndexerTestResult};
-  use crate::models::HorizontallyScrollableText;
-  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::radarr_network::RadarrEvent;
   use crate::network::radarr_network::radarr_network_test_utils::test_utils::{
     indexer, indexer_settings,
   };
-  use crate::network::radarr_network::RadarrEvent;
-  use crate::network::{Network, NetworkResource, RequestMethod};
   use bimap::BiMap;
   use mockito::Matcher;
   use pretty_assertions::assert_eq;
-  use reqwest::Client;
   use serde_json::json;
-  use tokio_util::sync::CancellationToken;
 
   #[tokio::test]
   async fn test_handle_delete_radarr_indexer_event() {
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Delete,
-      None,
-      None,
-      None,
-      RadarrEvent::DeleteIndexer(1),
-      Some("/1"),
-      None,
-    )
-    .await;
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let (async_server, app, _server) = MockServarrApi::delete()
+      .path("/1")
+      .build_for(RadarrEvent::DeleteIndexer(1))
+      .await;
+    let mut network = test_network(&app);
 
-    assert!(network
-      .handle_radarr_event(RadarrEvent::DeleteIndexer(1))
-      .await
-      .is_ok());
+    assert!(
+      network
+        .handle_radarr_event(RadarrEvent::DeleteIndexer(1))
+        .await
+        .is_ok()
+    );
 
     async_server.assert_async().await;
   }
@@ -52,22 +46,18 @@ mod tests {
         "whitelistedHardcodedSubs": "",
         "id": 1
     });
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Put,
-      Some(indexer_settings_json),
-      None,
-      None,
-      RadarrEvent::EditAllIndexerSettings(indexer_settings()),
-      None,
-      None,
-    )
-    .await;
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let (async_server, app, _server) = MockServarrApi::put()
+      .with_request_body(indexer_settings_json)
+      .build_for(RadarrEvent::EditAllIndexerSettings(indexer_settings()))
+      .await;
+    let mut network = test_network(&app);
 
-    assert!(network
-      .handle_radarr_event(RadarrEvent::EditAllIndexerSettings(indexer_settings()))
-      .await
-      .is_ok());
+    assert!(
+      network
+        .handle_radarr_event(RadarrEvent::EditAllIndexerSettings(indexer_settings()))
+        .await
+        .is_ok()
+    );
 
     async_server.assert_async().await;
   }
@@ -133,16 +123,11 @@ mod tests {
       priority: Some(0),
       ..EditIndexerParams::default()
     };
-    let (async_details_server, app_arc, mut server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(indexer_details_json),
-      None,
-      RadarrEvent::GetIndexers,
-      Some("/1"),
-      None,
-    )
-    .await;
+    let (async_details_server, app, mut server) = MockServarrApi::get()
+      .returns(indexer_details_json)
+      .path("/1")
+      .build_for(RadarrEvent::GetIndexers)
+      .await;
     let async_edit_server = server
       .mock(
         "PUT",
@@ -157,22 +142,24 @@ mod tests {
       .match_body(Matcher::Json(expected_indexer_edit_body_json))
       .create_async()
       .await;
-    app_arc.lock().await.data.radarr_data.tags_map =
+    app.lock().await.data.radarr_data.tags_map =
       BiMap::from_iter([(1, "usenet".to_owned()), (2, "testing".to_owned())]);
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let mut network = test_network(&app);
 
-    assert!(network
-      .handle_radarr_event(RadarrEvent::EditIndexer(edit_indexer_params))
-      .await
-      .is_ok());
+    assert!(
+      network
+        .handle_radarr_event(RadarrEvent::EditIndexer(edit_indexer_params))
+        .await
+        .is_ok()
+    );
 
     async_details_server.assert_async().await;
     async_edit_server.assert_async().await;
   }
 
   #[tokio::test]
-  async fn test_handle_edit_radarr_indexer_event_does_not_overwrite_tags_vec_if_tag_input_string_is_none(
-  ) {
+  async fn test_handle_edit_radarr_indexer_event_does_not_overwrite_tags_vec_if_tag_input_string_is_none()
+   {
     let indexer_details_json = json!({
         "enableRss": true,
         "enableAutomaticSearch": true,
@@ -232,16 +219,11 @@ mod tests {
       priority: Some(0),
       ..EditIndexerParams::default()
     };
-    let (async_details_server, app_arc, mut server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(indexer_details_json),
-      None,
-      RadarrEvent::GetIndexers,
-      Some("/1"),
-      None,
-    )
-    .await;
+    let (async_details_server, app, mut server) = MockServarrApi::get()
+      .returns(indexer_details_json)
+      .path("/1")
+      .build_for(RadarrEvent::GetIndexers)
+      .await;
     let async_edit_server = server
       .mock(
         "PUT",
@@ -256,22 +238,24 @@ mod tests {
       .match_body(Matcher::Json(expected_indexer_edit_body_json))
       .create_async()
       .await;
-    app_arc.lock().await.data.radarr_data.tags_map =
+    app.lock().await.data.radarr_data.tags_map =
       BiMap::from_iter([(1, "usenet".to_owned()), (2, "testing".to_owned())]);
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let mut network = test_network(&app);
 
-    assert!(network
-      .handle_radarr_event(RadarrEvent::EditIndexer(edit_indexer_params))
-      .await
-      .is_ok());
+    assert!(
+      network
+        .handle_radarr_event(RadarrEvent::EditIndexer(edit_indexer_params))
+        .await
+        .is_ok()
+    );
 
     async_details_server.assert_async().await;
     async_edit_server.assert_async().await;
   }
 
   #[tokio::test]
-  async fn test_handle_edit_radarr_indexer_event_does_not_add_seed_ratio_when_seed_ratio_field_is_none_in_details(
-  ) {
+  async fn test_handle_edit_radarr_indexer_event_does_not_add_seed_ratio_when_seed_ratio_field_is_none_in_details()
+   {
     let indexer_details_json = json!({
         "enableRss": true,
         "enableAutomaticSearch": true,
@@ -323,16 +307,11 @@ mod tests {
       priority: Some(0),
       ..EditIndexerParams::default()
     };
-    let (async_details_server, app_arc, mut server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(indexer_details_json),
-      None,
-      RadarrEvent::GetIndexers,
-      Some("/1"),
-      None,
-    )
-    .await;
+    let (async_details_server, app, mut server) = MockServarrApi::get()
+      .returns(indexer_details_json)
+      .path("/1")
+      .build_for(RadarrEvent::GetIndexers)
+      .await;
     let async_edit_server = server
       .mock(
         "PUT",
@@ -347,22 +326,24 @@ mod tests {
       .match_body(Matcher::Json(expected_indexer_edit_body_json))
       .create_async()
       .await;
-    app_arc.lock().await.data.radarr_data.tags_map =
+    app.lock().await.data.radarr_data.tags_map =
       BiMap::from_iter([(1, "usenet".to_owned()), (2, "testing".to_owned())]);
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let mut network = test_network(&app);
 
-    assert!(network
-      .handle_radarr_event(RadarrEvent::EditIndexer(edit_indexer_params))
-      .await
-      .is_ok());
+    assert!(
+      network
+        .handle_radarr_event(RadarrEvent::EditIndexer(edit_indexer_params))
+        .await
+        .is_ok()
+    );
 
     async_details_server.assert_async().await;
     async_edit_server.assert_async().await;
   }
 
   #[tokio::test]
-  async fn test_handle_edit_radarr_indexer_event_populates_the_seed_ratio_value_when_seed_ratio_field_is_present_in_details(
-  ) {
+  async fn test_handle_edit_radarr_indexer_event_populates_the_seed_ratio_value_when_seed_ratio_field_is_present_in_details()
+   {
     let indexer_details_json = json!({
         "enableRss": true,
         "enableAutomaticSearch": true,
@@ -421,16 +402,11 @@ mod tests {
       priority: Some(0),
       ..EditIndexerParams::default()
     };
-    let (async_details_server, app_arc, mut server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(indexer_details_json),
-      None,
-      RadarrEvent::GetIndexers,
-      Some("/1"),
-      None,
-    )
-    .await;
+    let (async_details_server, app, mut server) = MockServarrApi::get()
+      .returns(indexer_details_json)
+      .path("/1")
+      .build_for(RadarrEvent::GetIndexers)
+      .await;
     let async_edit_server = server
       .mock(
         "PUT",
@@ -445,14 +421,16 @@ mod tests {
       .match_body(Matcher::Json(expected_indexer_edit_body_json))
       .create_async()
       .await;
-    app_arc.lock().await.data.radarr_data.tags_map =
+    app.lock().await.data.radarr_data.tags_map =
       BiMap::from_iter([(1, "usenet".to_owned()), (2, "testing".to_owned())]);
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let mut network = test_network(&app);
 
-    assert!(network
-      .handle_radarr_event(RadarrEvent::EditIndexer(edit_indexer_params))
-      .await
-      .is_ok());
+    assert!(
+      network
+        .handle_radarr_event(RadarrEvent::EditIndexer(edit_indexer_params))
+        .await
+        .is_ok()
+    );
 
     async_details_server.assert_async().await;
     async_edit_server.assert_async().await;
@@ -488,16 +466,11 @@ mod tests {
       ..EditIndexerParams::default()
     };
 
-    let (async_details_server, app_arc, mut server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(indexer_details_json.clone()),
-      None,
-      RadarrEvent::GetIndexers,
-      Some("/1"),
-      None,
-    )
-    .await;
+    let (async_details_server, app, mut server) = MockServarrApi::get()
+      .returns(indexer_details_json.clone())
+      .path("/1")
+      .build_for(RadarrEvent::GetIndexers)
+      .await;
     let async_edit_server = server
       .mock(
         "PUT",
@@ -512,12 +485,14 @@ mod tests {
       .match_body(Matcher::Json(indexer_details_json))
       .create_async()
       .await;
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let mut network = test_network(&app);
 
-    assert!(network
-      .handle_radarr_event(RadarrEvent::EditIndexer(edit_indexer_params))
-      .await
-      .is_ok());
+    assert!(
+      network
+        .handle_radarr_event(RadarrEvent::EditIndexer(edit_indexer_params))
+        .await
+        .is_ok()
+    );
 
     async_details_server.assert_async().await;
     async_edit_server.assert_async().await;
@@ -577,16 +552,11 @@ mod tests {
       ..EditIndexerParams::default()
     };
 
-    let (async_details_server, app_arc, mut server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(indexer_details_json),
-      None,
-      RadarrEvent::GetIndexers,
-      Some("/1"),
-      None,
-    )
-    .await;
+    let (async_details_server, app, mut server) = MockServarrApi::get()
+      .returns(indexer_details_json)
+      .path("/1")
+      .build_for(RadarrEvent::GetIndexers)
+      .await;
     let async_edit_server = server
       .mock(
         "PUT",
@@ -601,12 +571,14 @@ mod tests {
       .match_body(Matcher::Json(expected_edit_indexer_body))
       .create_async()
       .await;
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let mut network = test_network(&app);
 
-    assert!(network
-      .handle_radarr_event(RadarrEvent::EditIndexer(edit_indexer_params))
-      .await
-      .is_ok());
+    assert!(
+      network
+        .handle_radarr_event(RadarrEvent::EditIndexer(edit_indexer_params))
+        .await
+        .is_ok()
+    );
 
     async_details_server.assert_async().await;
     async_edit_server.assert_async().await;
@@ -645,17 +617,11 @@ mod tests {
         "id": 1
     }]);
     let response: Vec<Indexer> = serde_json::from_value(indexers_response_json.clone()).unwrap();
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(indexers_response_json),
-      None,
-      RadarrEvent::GetIndexers,
-      None,
-      None,
-    )
-    .await;
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let (async_server, app, _server) = MockServarrApi::get()
+      .returns(indexers_response_json)
+      .build_for(RadarrEvent::GetIndexers)
+      .await;
+    let mut network = test_network(&app);
 
     if let RadarrSerdeable::Indexers(indexers) = network
       .handle_radarr_event(RadarrEvent::GetIndexers)
@@ -664,7 +630,7 @@ mod tests {
     {
       async_server.assert_async().await;
       assert_eq!(
-        app_arc.lock().await.data.radarr_data.indexers.items,
+        app.lock().await.data.radarr_data.indexers.items,
         vec![indexer()]
       );
       assert_eq!(indexers, response);
@@ -686,17 +652,11 @@ mod tests {
     });
     let response: IndexerSettings =
       serde_json::from_value(indexer_settings_response_json.clone()).unwrap();
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(indexer_settings_response_json),
-      None,
-      RadarrEvent::GetAllIndexerSettings,
-      None,
-      None,
-    )
-    .await;
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let (async_server, app, _server) = MockServarrApi::get()
+      .returns(indexer_settings_response_json)
+      .build_for(RadarrEvent::GetAllIndexerSettings)
+      .await;
+    let mut network = test_network(&app);
 
     if let RadarrSerdeable::IndexerSettings(settings) = network
       .handle_radarr_event(RadarrEvent::GetAllIndexerSettings)
@@ -705,7 +665,7 @@ mod tests {
     {
       async_server.assert_async().await;
       assert_eq!(
-        app_arc.lock().await.data.radarr_data.indexer_settings,
+        app.lock().await.data.radarr_data.indexer_settings,
         Some(indexer_settings())
       );
       assert_eq!(settings, response);
@@ -725,27 +685,23 @@ mod tests {
         "whitelistedHardcodedSubs": "",
         "id": 1
     });
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(indexer_settings_response_json),
-      None,
-      RadarrEvent::GetAllIndexerSettings,
-      None,
-      None,
-    )
-    .await;
-    app_arc.lock().await.data.radarr_data.indexer_settings = Some(IndexerSettings::default());
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let (async_server, app, _server) = MockServarrApi::get()
+      .returns(indexer_settings_response_json)
+      .build_for(RadarrEvent::GetAllIndexerSettings)
+      .await;
+    app.lock().await.data.radarr_data.indexer_settings = Some(IndexerSettings::default());
+    let mut network = test_network(&app);
 
-    assert!(network
-      .handle_radarr_event(RadarrEvent::GetAllIndexerSettings)
-      .await
-      .is_ok());
+    assert!(
+      network
+        .handle_radarr_event(RadarrEvent::GetAllIndexerSettings)
+        .await
+        .is_ok()
+    );
 
     async_server.assert_async().await;
     assert_eq!(
-      app_arc.lock().await.data.radarr_data.indexer_settings,
+      app.lock().await.data.radarr_data.indexer_settings,
       Some(IndexerSettings::default())
     );
   }
@@ -781,16 +737,11 @@ mod tests {
         "errorMessage": "test failure",
         "severity": "error"
     }]);
-    let (async_details_server, app_arc, mut server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(indexer_details_json.clone()),
-      None,
-      RadarrEvent::GetIndexers,
-      Some("/1"),
-      None,
-    )
-    .await;
+    let (async_details_server, app, mut server) = MockServarrApi::get()
+      .returns(indexer_details_json.clone())
+      .path("/1")
+      .build_for(RadarrEvent::GetIndexers)
+      .await;
     let async_test_server = server
       .mock(
         "POST",
@@ -802,7 +753,7 @@ mod tests {
       .with_body(response_json.to_string())
       .create_async()
       .await;
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let mut network = test_network(&app);
 
     if let RadarrSerdeable::Value(value) = network
       .handle_radarr_event(RadarrEvent::TestIndexer(1))
@@ -812,7 +763,7 @@ mod tests {
       async_details_server.assert_async().await;
       async_test_server.assert_async().await;
       assert_eq!(
-        app_arc.lock().await.data.radarr_data.indexer_test_errors,
+        app.lock().await.data.radarr_data.indexer_test_errors,
         Some("\"test failure\"".to_owned())
       );
       assert_eq!(value, response_json)
@@ -843,16 +794,11 @@ mod tests {
         "tags": [1],
         "id": 1
     });
-    let (async_details_server, app_arc, mut server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(indexer_details_json.clone()),
-      None,
-      RadarrEvent::GetIndexers,
-      Some("/1"),
-      None,
-    )
-    .await;
+    let (async_details_server, app, mut server) = MockServarrApi::get()
+      .returns(indexer_details_json.clone())
+      .path("/1")
+      .build_for(RadarrEvent::GetIndexers)
+      .await;
     let async_test_server = server
       .mock(
         "POST",
@@ -864,7 +810,7 @@ mod tests {
       .with_body("{}")
       .create_async()
       .await;
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let mut network = test_network(&app);
 
     if let RadarrSerdeable::Value(value) = network
       .handle_radarr_event(RadarrEvent::TestIndexer(1))
@@ -874,7 +820,7 @@ mod tests {
       async_details_server.assert_async().await;
       async_test_server.assert_async().await;
       assert_eq!(
-        app_arc.lock().await.data.radarr_data.indexer_test_errors,
+        app.lock().await.data.radarr_data.indexer_test_errors,
         Some(String::new())
       );
       assert_eq!(value, json!({}));
@@ -930,24 +876,19 @@ mod tests {
       ]
     }]);
     let response: Vec<IndexerTestResult> = serde_json::from_value(response_json.clone()).unwrap();
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Post,
-      None,
-      Some(response_json),
-      Some(400),
-      RadarrEvent::TestAllIndexers,
-      None,
-      None,
-    )
-    .await;
-    app_arc
+    let (async_server, app, _server) = MockServarrApi::post()
+      .returns(response_json)
+      .status(400)
+      .build_for(RadarrEvent::TestAllIndexers)
+      .await;
+    app
       .lock()
       .await
       .data
       .radarr_data
       .indexers
       .set_items(indexers);
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let mut network = test_network(&app);
 
     if let RadarrSerdeable::IndexerTestResults(results) = network
       .handle_radarr_event(RadarrEvent::TestAllIndexers)
@@ -955,15 +896,17 @@ mod tests {
       .unwrap()
     {
       async_server.assert_async().await;
-      assert!(app_arc
-        .lock()
-        .await
-        .data
-        .radarr_data
-        .indexer_test_all_results
-        .is_some());
+      assert!(
+        app
+          .lock()
+          .await
+          .data
+          .radarr_data
+          .indexer_test_all_results
+          .is_some()
+      );
       assert_eq!(
-        app_arc
+        app
           .lock()
           .await
           .data

src/network/radarr_network/library/mod.rs

@@ -13,7 +13,7 @@ use crate::utils::{convert_runtime, convert_to_gb};
 use anyhow::Result;
 use indoc::formatdoc;
 use log::{debug, info, warn};
-use serde_json::{json, Value};
+use serde_json::{Value, json};
 use urlencoding::encode;
 
 #[cfg(test)]
@@ -53,7 +53,9 @@ impl Network<'_, '_> {
       delete_movie_files,
       add_list_exclusion,
     } = delete_movie_params;
-    info!("Deleting Radarr movie with ID: {id} with deleteFiles={delete_movie_files} and addImportExclusion={add_list_exclusion}");
+    info!(
+      "Deleting Radarr movie with ID: {id} with deleteFiles={delete_movie_files} and addImportExclusion={add_list_exclusion}"
+    );
 
     let request_props = self
       .request_props_from(

src/network/radarr_network/mod.rs

@@ -2,7 +2,7 @@ use anyhow::Result;
 use std::fmt::Debug;
 
 use log::info;
-use serde_json::{json, Value};
+use serde_json::{Value, json};
 
 use crate::models::radarr_models::{
   AddMovieBody, DeleteMovieParams, EditCollectionParams, EditMovieParams, IndexerSettings,

src/network/radarr_network/radarr_network_test_utils.rs

@@ -1,5 +1,6 @@
 #[cfg(test)]
 pub(in crate::network::radarr_network) mod test_utils {
+  use crate::models::HorizontallyScrollableText;
   use crate::models::radarr_models::{
     AddMovieSearchResult, BlocklistItem, BlocklistItemMovie, Collection, CollectionMovie, Credit,
     CreditType, DownloadRecord, DownloadsResponse, IndexerSettings, MediaInfo, MinimumAvailability,
@@ -8,9 +9,8 @@ pub(in crate::network::radarr_network) mod test_utils {
   use crate::models::servarr_models::{
     Indexer, IndexerField, Language, Quality, QualityWrapper, RootFolder,
   };
-  use crate::models::HorizontallyScrollableText;
   use chrono::DateTime;
-  use serde_json::{json, Number};
+  use serde_json::{Number, Value, json};
 
   pub const MOVIE_JSON: &str = r#"{
         "id": 1,
@@ -378,4 +378,18 @@ pub(in crate::network::radarr_network) mod test_utils {
       ..IndexerSettings::default()
     }
   }
+
+  pub fn tag() -> Value {
+    json!({
+      "id": 3,
+      "label": "testing"
+    })
+  }
+
+  pub fn quality_profile() -> Value {
+    json!({
+      "id": 2222,
+      "name": "HD - 1080p"
+    })
+  }
 }

src/network/radarr_network/radarr_network_tests.rs

@@ -1,21 +1,22 @@
 #[cfg(test)]
 mod test {
   use super::super::*;
+  use crate::App;
   use crate::models::radarr_models::{
     EditCollectionParams, EditMovieParams, IndexerSettings, RadarrTaskName,
   };
   use crate::models::servarr_data::radarr::modals::EditMovieModal;
   use crate::models::servarr_models::EditIndexerParams;
-  use crate::network::network_tests::test_utils::mock_servarr_api;
-  use crate::App;
+  use crate::network::network_tests::test_utils::{MockServarrApi, test_network};
+  use crate::network::radarr_network::radarr_network_test_utils::test_utils::{
+    quality_profile, tag,
+  };
   use bimap::BiMap;
   use pretty_assertions::{assert_eq, assert_str_eq};
-  use reqwest::Client;
   use rstest::rstest;
   use serde_json::json;
   use std::sync::Arc;
   use tokio::sync::Mutex;
-  use tokio_util::sync::CancellationToken;
 
   #[rstest]
   fn test_resource_movie(
@@ -161,146 +162,129 @@ mod test {
 
   #[tokio::test]
   async fn test_handle_get_radarr_healthcheck_event() {
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      None,
-      None,
-      RadarrEvent::HealthCheck,
-      None,
-      None,
-    )
-    .await;
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let (mock, app, _server) = MockServarrApi::get()
+      .build_for(RadarrEvent::HealthCheck)
+      .await;
+
+    let mut network = test_network(&app);
 
     let _ = network.handle_radarr_event(RadarrEvent::HealthCheck).await;
 
-    async_server.assert_async().await;
+    mock.assert_async().await;
   }
 
   #[tokio::test]
   async fn test_handle_get_radarr_quality_profiles_event() {
-    let quality_profile_json = json!([{
-      "id": 2222,
-      "name": "HD - 1080p"
-    }]);
-    let response: Vec<QualityProfile> =
-      serde_json::from_value(quality_profile_json.clone()).unwrap();
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(quality_profile_json),
-      None,
-      RadarrEvent::GetQualityProfiles,
-      None,
-      None,
-    )
-    .await;
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let expected: Vec<QualityProfile> = vec![QualityProfile {
+      id: 2222,
+      name: "HD - 1080p".to_owned(),
+    }];
 
-    if let RadarrSerdeable::QualityProfiles(quality_profiles) = network
+    let (mock, app, _server) = MockServarrApi::get()
+      .returns(json!([quality_profile()]))
+      .build_for(RadarrEvent::GetQualityProfiles)
+      .await;
+
+    let mut network = test_network(&app);
+
+    let result = network
       .handle_radarr_event(RadarrEvent::GetQualityProfiles)
-      .await
-      .unwrap()
-    {
-      async_server.assert_async().await;
-      assert_eq!(
-        app_arc.lock().await.data.radarr_data.quality_profile_map,
-        BiMap::from_iter([(2222i64, "HD - 1080p".to_owned())])
-      );
-      assert_eq!(quality_profiles, response);
-    }
+      .await;
+
+    mock.assert_async().await;
+
+    let RadarrSerdeable::QualityProfiles(quality_profiles) = result.unwrap() else {
+      panic!("Expected QualityProfiles variant");
+    };
+    assert_eq!(quality_profiles, expected);
+    assert_eq!(
+      app.lock().await.data.radarr_data.quality_profile_map,
+      BiMap::from_iter([(2222i64, "HD - 1080p".to_owned())])
+    );
   }
 
   #[tokio::test]
   async fn test_handle_get_radarr_tags_event() {
-    let tags_json = json!([{
-      "id": 2222,
-      "label": "usenet"
-    }]);
-    let response: Vec<Tag> = serde_json::from_value(tags_json.clone()).unwrap();
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(tags_json),
-      None,
-      RadarrEvent::GetTags,
-      None,
-      None,
-    )
-    .await;
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let expected: Vec<Tag> = vec![Tag {
+      id: 2222,
+      label: "usenet".to_owned(),
+    }];
 
-    if let RadarrSerdeable::Tags(tags) = network
-      .handle_radarr_event(RadarrEvent::GetTags)
-      .await
-      .unwrap()
-    {
-      async_server.assert_async().await;
-      assert_eq!(
-        app_arc.lock().await.data.radarr_data.tags_map,
-        BiMap::from_iter([(2222i64, "usenet".to_owned())])
-      );
-      assert_eq!(tags, response);
-    }
+    let (mock, app, _server) = MockServarrApi::get()
+      .returns(json!([{
+        "id": 2222,
+        "label": "usenet"
+      }]))
+      .build_for(RadarrEvent::GetTags)
+      .await;
+
+    let mut network = test_network(&app);
+
+    let result = network.handle_radarr_event(RadarrEvent::GetTags).await;
+
+    mock.assert_async().await;
+
+    let RadarrSerdeable::Tags(tags) = result.unwrap() else {
+      panic!("Expected Tags variant");
+    };
+    assert_eq!(tags, expected);
+    assert_eq!(
+      app.lock().await.data.radarr_data.tags_map,
+      BiMap::from_iter([(2222i64, "usenet".to_owned())])
+    );
   }
 
   #[tokio::test]
   async fn test_handle_add_radarr_tag() {
-    let tag_json = json!({ "id": 3, "label": "testing" });
-    let response: Tag = serde_json::from_value(tag_json.clone()).unwrap();
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Post,
-      Some(json!({ "label": "testing" })),
-      Some(tag_json),
-      None,
-      RadarrEvent::AddTag(String::new()),
-      None,
-      None,
-    )
-    .await;
-    app_arc.lock().await.data.radarr_data.tags_map =
-      BiMap::from_iter([(1, "usenet".to_owned()), (2, "test".to_owned())]);
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let expected = Tag {
+      id: 3,
+      label: "testing".to_owned(),
+    };
 
-    if let RadarrSerdeable::Tag(tag) = network
+    let (mock, app, _server) = MockServarrApi::post()
+      .with_request_body(json!({ "label": "testing" }))
+      .returns(tag())
+      .build_for(RadarrEvent::AddTag(String::new()))
+      .await;
+
+    app.lock().await.data.radarr_data.tags_map =
+      BiMap::from_iter([(1, "usenet".to_owned()), (2, "test".to_owned())]);
+
+    let mut network = test_network(&app);
+
+    let result = network
       .handle_radarr_event(RadarrEvent::AddTag("testing".to_owned()))
-      .await
-      .unwrap()
-    {
-      async_server.assert_async().await;
-      assert_eq!(
-        app_arc.lock().await.data.radarr_data.tags_map,
-        BiMap::from_iter([
-          (1, "usenet".to_owned()),
-          (2, "test".to_owned()),
-          (3, "testing".to_owned())
-        ])
-      );
-      assert_eq!(tag, response);
-    }
+      .await;
+
+    mock.assert_async().await;
+
+    let RadarrSerdeable::Tag(tag) = result.unwrap() else {
+      panic!("Expected Tag variant");
+    };
+    assert_eq!(tag, expected);
+    assert_eq!(
+      app.lock().await.data.radarr_data.tags_map,
+      BiMap::from_iter([
+        (1, "usenet".to_owned()),
+        (2, "test".to_owned()),
+        (3, "testing".to_owned())
+      ])
+    );
   }
 
   #[tokio::test]
   async fn test_handle_delete_radarr_tag_event() {
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Delete,
-      None,
-      None,
-      None,
-      RadarrEvent::DeleteTag(1),
-      Some("/1"),
-      None,
-    )
-    .await;
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let (mock, app, _server) = MockServarrApi::delete()
+      .path("/1")
+      .build_for(RadarrEvent::DeleteTag(1))
+      .await;
 
-    assert!(network
-      .handle_radarr_event(RadarrEvent::DeleteTag(1))
-      .await
-      .is_ok());
+    let mut network = test_network(&app);
 
-    async_server.assert_async().await;
+    let result = network.handle_radarr_event(RadarrEvent::DeleteTag(1)).await;
+
+    mock.assert_async().await;
+    assert!(result.is_ok());
   }
 
   #[tokio::test]
@@ -315,7 +299,7 @@ mod test {
         (3, "hi".to_owned()),
       ]);
     }
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let mut network = test_network(&app_arc);
 
     assert_eq!(
       network.extract_and_add_radarr_tag_ids_vec(tags).await,
@@ -325,34 +309,29 @@ mod test {
 
   #[tokio::test]
   async fn test_extract_and_add_radarr_tag_ids_vec_add_missing_tags_first() {
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Post,
-      Some(json!({ "label": "TESTING" })),
-      Some(json!({ "id": 3, "label": "testing" })),
-      None,
-      RadarrEvent::GetTags,
-      None,
-      None,
-    )
-    .await;
+    let (async_server, app, _server) = MockServarrApi::post()
+      .with_request_body(json!({ "label": "TESTING" }))
+      .returns(json!({ "id": 3, "label": "testing" }))
+      .build_for(RadarrEvent::GetTags)
+      .await;
     let tags = "usenet, test, TESTING";
     {
-      let mut app = app_arc.lock().await;
-      app.data.radarr_data.edit_movie_modal = Some(EditMovieModal {
+      let mut app_guard = app.lock().await;
+      app_guard.data.radarr_data.edit_movie_modal = Some(EditMovieModal {
         tags: tags.into(),
         ..EditMovieModal::default()
       });
-      app.data.radarr_data.tags_map =
+      app_guard.data.radarr_data.tags_map =
         BiMap::from_iter([(1, "usenet".to_owned()), (2, "test".to_owned())]);
     }
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let mut network = test_network(&app);
 
     let tag_ids_vec = network.extract_and_add_radarr_tag_ids_vec(tags).await;
 
     async_server.assert_async().await;
     assert_eq!(tag_ids_vec, vec![1, 2, 3]);
     assert_eq!(
-      app_arc.lock().await.data.radarr_data.tags_map,
+      app.lock().await.data.radarr_data.tags_map,
       BiMap::from_iter([
         (1, "usenet".to_owned()),
         (2, "test".to_owned()),

src/network/radarr_network/root_folders/radarr_root_folders_network_tests.rs

@@ -2,62 +2,52 @@
 mod tests {
   use crate::models::radarr_models::RadarrSerdeable;
   use crate::models::servarr_models::{AddRootFolderBody, RootFolder};
-  use crate::network::network_tests::test_utils::mock_servarr_api;
-  use crate::network::radarr_network::radarr_network_test_utils::test_utils::root_folder;
+  use crate::network::network_tests::test_utils::{MockServarrApi, test_network};
   use crate::network::radarr_network::RadarrEvent;
-  use crate::network::{Network, RequestMethod};
+  use crate::network::radarr_network::radarr_network_test_utils::test_utils::root_folder;
   use pretty_assertions::assert_eq;
-  use reqwest::Client;
   use serde_json::json;
-  use tokio_util::sync::CancellationToken;
 
   #[tokio::test]
   async fn test_handle_add_radarr_root_folder_event() {
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Post,
-      Some(json!({
+    let (mock, app, _server) = MockServarrApi::post()
+      .with_request_body(json!({
         "path": "/nfs/test"
-      })),
-      Some(json!({})),
-      None,
-      RadarrEvent::AddRootFolder(AddRootFolderBody::default()),
-      None,
-      None,
-    )
-    .await;
+      }))
+      .returns(json!({}))
+      .build_for(RadarrEvent::AddRootFolder(AddRootFolderBody::default()))
+      .await;
     let add_root_folder_body = AddRootFolderBody {
       path: "/nfs/test".to_owned(),
     };
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let mut network = test_network(&app);
 
-    assert!(network
-      .handle_radarr_event(RadarrEvent::AddRootFolder(add_root_folder_body))
-      .await
-      .is_ok());
+    assert!(
+      network
+        .handle_radarr_event(RadarrEvent::AddRootFolder(add_root_folder_body))
+        .await
+        .is_ok()
+    );
 
-    async_server.assert_async().await;
+    mock.assert_async().await;
   }
 
   #[tokio::test]
   async fn test_handle_delete_radarr_root_folder_event() {
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Delete,
-      None,
-      None,
-      None,
-      RadarrEvent::DeleteRootFolder(1),
-      Some("/1"),
-      None,
-    )
-    .await;
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let (mock, app, _server) = MockServarrApi::delete()
+      .path("/1")
+      .build_for(RadarrEvent::DeleteRootFolder(1))
+      .await;
+    let mut network = test_network(&app);
 
-    assert!(network
-      .handle_radarr_event(RadarrEvent::DeleteRootFolder(1))
-      .await
-      .is_ok());
+    assert!(
+      network
+        .handle_radarr_event(RadarrEvent::DeleteRootFolder(1))
+        .await
+        .is_ok()
+    );
 
-    async_server.assert_async().await;
+    mock.assert_async().await;
   }
 
   #[tokio::test]
@@ -69,26 +59,20 @@ mod tests {
       "freeSpace": 219902325555200u64,
     }]);
     let response: Vec<RootFolder> = serde_json::from_value(root_folder_json.clone()).unwrap();
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(root_folder_json),
-      None,
-      RadarrEvent::GetRootFolders,
-      None,
-      None,
-    )
-    .await;
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let (mock, app, _server) = MockServarrApi::get()
+      .returns(root_folder_json)
+      .build_for(RadarrEvent::GetRootFolders)
+      .await;
+    let mut network = test_network(&app);
 
     if let RadarrSerdeable::RootFolders(root_folders) = network
       .handle_radarr_event(RadarrEvent::GetRootFolders)
       .await
       .unwrap()
     {
-      async_server.assert_async().await;
+      mock.assert_async().await;
       assert_eq!(
-        app_arc.lock().await.data.radarr_data.root_folders.items,
+        app.lock().await.data.radarr_data.root_folders.items,
         vec![root_folder()]
       );
       assert_eq!(root_folders, response);

src/network/radarr_network/system/radarr_system_network_tests.rs

@@ -5,22 +5,17 @@ mod tests {
     DiskSpace, HostConfig, LogResponse, QueueEvent, SecurityConfig, Update,
   };
   use crate::models::{HorizontallyScrollableText, ScrollableText};
-  use crate::network::network_tests::test_utils::mock_servarr_api;
+  use crate::network::network_tests::test_utils::{MockServarrApi, test_network};
   use crate::network::radarr_network::RadarrEvent;
-  use crate::network::{Network, RequestMethod};
   use chrono::DateTime;
   use indoc::formatdoc;
   use pretty_assertions::{assert_eq, assert_str_eq};
-  use reqwest::Client;
   use serde_json::json;
-  use tokio_util::sync::CancellationToken;
 
   #[tokio::test]
   async fn test_handle_get_radarr_diskspace_event() {
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(json!([
+    let (mock, app, _server) = MockServarrApi::get()
+      .returns(json!([
         {
           "freeSpace": 1111,
           "totalSpace": 2222,
@@ -29,14 +24,10 @@ mod tests {
           "freeSpace": 3333,
           "totalSpace": 4444
         }
-      ])),
-      None,
-      RadarrEvent::GetDiskSpace,
-      None,
-      None,
-    )
-    .await;
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+      ]))
+      .build_for(RadarrEvent::GetDiskSpace)
+      .await;
+    let mut network = test_network(&app);
     let disk_space_vec = vec![
       DiskSpace {
         free_space: 1111,
@@ -53,9 +44,9 @@ mod tests {
       .await
       .unwrap()
     {
-      async_server.assert_async().await;
+      mock.assert_async().await;
       assert_eq!(
-        app_arc.lock().await.data.radarr_data.disk_space_vec,
+        app.lock().await.data.radarr_data.disk_space_vec,
         disk_space_vec
       );
       assert_eq!(disk_space, disk_space_vec);
@@ -76,24 +67,18 @@ mod tests {
       "sslCertPassword": "test"
     });
     let response: HostConfig = serde_json::from_value(host_config_response.clone()).unwrap();
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(host_config_response),
-      None,
-      RadarrEvent::GetHostConfig,
-      None,
-      None,
-    )
-    .await;
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let (mock, app, _server) = MockServarrApi::get()
+      .returns(host_config_response)
+      .build_for(RadarrEvent::GetHostConfig)
+      .await;
+    let mut network = test_network(&app);
 
     if let RadarrSerdeable::HostConfig(host_config) = network
       .handle_radarr_event(RadarrEvent::GetHostConfig)
       .await
       .unwrap()
     {
-      async_server.assert_async().await;
+      mock.assert_async().await;
       assert_eq!(host_config, response);
     }
   }
@@ -131,37 +116,31 @@ mod tests {
         ]
     });
     let response: LogResponse = serde_json::from_value(logs_response_json.clone()).unwrap();
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(logs_response_json),
-      None,
-      RadarrEvent::GetLogs(500),
-      None,
-      Some("pageSize=500&sortDirection=descending&sortKey=time"),
-    )
-    .await;
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let (mock, app, _server) = MockServarrApi::get()
+      .returns(logs_response_json)
+      .query("pageSize=500&sortDirection=descending&sortKey=time")
+      .build_for(RadarrEvent::GetLogs(500))
+      .await;
+    let mut network = test_network(&app);
 
     if let RadarrSerdeable::LogResponse(logs) = network
       .handle_radarr_event(RadarrEvent::GetLogs(500))
       .await
       .unwrap()
     {
-      async_server.assert_async().await;
-      assert_eq!(
-        app_arc.lock().await.data.radarr_data.logs.items,
-        expected_logs
+      mock.assert_async().await;
+      assert_eq!(app.lock().await.data.radarr_data.logs.items, expected_logs);
+      assert!(
+        app
+          .lock()
+          .await
+          .data
+          .radarr_data
+          .logs
+          .current_selection()
+          .text
+          .contains("INFO")
       );
-      assert!(app_arc
-        .lock()
-        .await
-        .data
-        .radarr_data
-        .logs
-        .current_selection()
-        .text
-        .contains("INFO"));
       assert_eq!(logs, response);
     }
   }
@@ -191,26 +170,20 @@ mod tests {
       trigger: "scheduled".to_owned(),
     };
 
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(queued_events_json),
-      None,
-      RadarrEvent::GetQueuedEvents,
-      None,
-      None,
-    )
-    .await;
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let (mock, app, _server) = MockServarrApi::get()
+      .returns(queued_events_json)
+      .build_for(RadarrEvent::GetQueuedEvents)
+      .await;
+    let mut network = test_network(&app);
 
     if let RadarrSerdeable::QueueEvents(events) = network
       .handle_radarr_event(RadarrEvent::GetQueuedEvents)
       .await
       .unwrap()
     {
-      async_server.assert_async().await;
+      mock.assert_async().await;
       assert_eq!(
-        app_arc.lock().await.data.radarr_data.queued_events.items,
+        app.lock().await.data.radarr_data.queued_events.items,
         vec![expected_event]
       );
       assert_eq!(events, response);
@@ -229,44 +202,32 @@ mod tests {
     });
     let response: SecurityConfig =
       serde_json::from_value(security_config_response.clone()).unwrap();
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(security_config_response),
-      None,
-      RadarrEvent::GetSecurityConfig,
-      None,
-      None,
-    )
-    .await;
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let (mock, app, _server) = MockServarrApi::get()
+      .returns(security_config_response)
+      .build_for(RadarrEvent::GetSecurityConfig)
+      .await;
+    let mut network = test_network(&app);
 
     if let RadarrSerdeable::SecurityConfig(security_config) = network
       .handle_radarr_event(RadarrEvent::GetSecurityConfig)
       .await
       .unwrap()
     {
-      async_server.assert_async().await;
+      mock.assert_async().await;
       assert_eq!(security_config, response);
     }
   }
 
   #[tokio::test]
   async fn test_handle_get_radarr_status_event() {
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(json!({
+    let (async_server, app, _server) = MockServarrApi::get()
+      .returns(json!({
         "version": "v1",
         "startTime": "2023-02-25T20:16:43Z"
-      })),
-      None,
-      RadarrEvent::GetStatus,
-      None,
-      None,
-    )
-    .await;
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+      }))
+      .build_for(RadarrEvent::GetStatus)
+      .await;
+    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
@@ -275,8 +236,8 @@ mod tests {
       .unwrap()
     {
       async_server.assert_async().await;
-      assert_str_eq!(app_arc.lock().await.data.radarr_data.version, "v1");
-      assert_eq!(app_arc.lock().await.data.radarr_data.start_time, date_time);
+      assert_str_eq!(app.lock().await.data.radarr_data.version, "v1");
+      assert_eq!(app.lock().await.data.radarr_data.start_time, date_time);
       assert_eq!(
         status,
         SystemStatus {
@@ -356,17 +317,11 @@ mod tests {
       * Killed bug 1
       * Fixed bug 2"
     ));
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(updates_json),
-      None,
-      RadarrEvent::GetUpdates,
-      None,
-      None,
-    )
-    .await;
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let (async_server, app, _server) = MockServarrApi::get()
+      .returns(updates_json)
+      .build_for(RadarrEvent::GetUpdates)
+      .await;
+    let mut network = test_network(&app);
 
     if let RadarrSerdeable::Updates(updates) = network
       .handle_radarr_event(RadarrEvent::GetUpdates)
@@ -375,7 +330,7 @@ mod tests {
     {
       async_server.assert_async().await;
       assert_str_eq!(
-        app_arc.lock().await.data.radarr_data.updates.get_text(),
+        app.lock().await.data.radarr_data.updates.get_text(),
         expected_text.get_text()
       );
       assert_eq!(updates, response);
@@ -420,17 +375,11 @@ mod tests {
         last_duration: "00:00:00.5111547".to_owned(),
       },
     ];
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(tasks_json),
-      None,
-      RadarrEvent::GetTasks,
-      None,
-      None,
-    )
-    .await;
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let (async_server, app, _server) = MockServarrApi::get()
+      .returns(tasks_json)
+      .build_for(RadarrEvent::GetTasks)
+      .await;
+    let mut network = test_network(&app);
 
     if let RadarrSerdeable::Tasks(tasks) = network
       .handle_radarr_event(RadarrEvent::GetTasks)
@@ -439,7 +388,7 @@ mod tests {
     {
       async_server.assert_async().await;
       assert_eq!(
-        app_arc.lock().await.data.radarr_data.tasks.items,
+        app.lock().await.data.radarr_data.tasks.items,
         expected_tasks
       );
       assert_eq!(tasks, response);
@@ -449,19 +398,16 @@ mod tests {
   #[tokio::test]
   async fn test_handle_start_radarr_task_event() {
     let response = json!({ "test": "test"});
-    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": "ApplicationCheckUpdate"
-      })),
-      Some(response.clone()),
-      None,
-      RadarrEvent::StartTask(RadarrTaskName::ApplicationCheckUpdate),
-      None,
-      None,
-    )
-    .await;
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+      }))
+      .returns(response.clone())
+      .build_for(RadarrEvent::StartTask(
+        RadarrTaskName::ApplicationCheckUpdate,
+      ))
+      .await;
+    let mut network = test_network(&app);
 
     if let RadarrSerdeable::Value(value) = network
       .handle_radarr_event(RadarrEvent::StartTask(

src/network/sonarr_network/blocklist/mod.rs

@@ -1,11 +1,11 @@
+use crate::models::Route;
 use crate::models::servarr_data::sonarr::sonarr_data::ActiveSonarrBlock;
 use crate::models::sonarr_models::{BlocklistItem, BlocklistResponse};
-use crate::models::Route;
 use crate::network::sonarr_network::SonarrEvent;
 use crate::network::{Network, RequestMethod};
 use anyhow::Result;
 use log::info;
-use serde_json::{json, Value};
+use serde_json::{Value, json};
 
 #[cfg(test)]
 #[path = "sonarr_blocklist_network_tests.rs"]

src/network/sonarr_network/blocklist/sonarr_blocklist_network_tests.rs

@@ -3,17 +3,14 @@ mod tests {
   use crate::models::servarr_data::sonarr::sonarr_data::ActiveSonarrBlock;
   use crate::models::sonarr_models::{BlocklistItem, BlocklistResponse, Series, SonarrSerdeable};
   use crate::models::stateful_table::SortOption;
-  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::sonarr_network::sonarr_network_test_utils::test_utils::{
     blocklist_item, series,
   };
-  use crate::network::sonarr_network::SonarrEvent;
-  use crate::network::{Network, RequestMethod};
   use pretty_assertions::assert_eq;
-  use reqwest::Client;
   use rstest::rstest;
-  use serde_json::{json, Number};
-  use tokio_util::sync::CancellationToken;
+  use serde_json::{Number, json};
 
   #[tokio::test]
   async fn test_handle_clear_sonarr_blocklist_event() {
@@ -32,62 +29,54 @@ mod tests {
       },
     ];
     let expected_request_json = json!({ "ids": [1, 2, 3]});
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Delete,
-      Some(expected_request_json),
-      None,
-      None,
-      SonarrEvent::ClearBlocklist,
-      None,
-      None,
-    )
-    .await;
-    app_arc
+    let (mock, app, _server) = MockServarrApi::delete()
+      .with_request_body(expected_request_json)
+      .build_for(SonarrEvent::ClearBlocklist)
+      .await;
+    app
       .lock()
       .await
       .data
       .sonarr_data
       .blocklist
       .set_items(blocklist_items);
-    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::ClearBlocklist)
-      .await
-      .is_ok());
+    assert!(
+      network
+        .handle_sonarr_event(SonarrEvent::ClearBlocklist)
+        .await
+        .is_ok()
+    );
 
-    async_server.assert_async().await;
+    mock.assert_async().await;
   }
 
   #[tokio::test]
   async fn test_handle_delete_sonarr_blocklist_item_event() {
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Delete,
-      None,
-      None,
-      None,
-      SonarrEvent::DeleteBlocklistItem(1),
-      Some("/1"),
-      None,
-    )
-    .await;
-    app_arc
+    let (mock, app, _server) = MockServarrApi::delete()
+      .path("/1")
+      .build_for(SonarrEvent::DeleteBlocklistItem(1))
+      .await;
+    app
       .lock()
       .await
       .data
       .sonarr_data
       .blocklist
       .set_items(vec![blocklist_item()]);
-    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::DeleteBlocklistItem(1))
-      .await
-      .is_ok());
+    assert!(
+      network
+        .handle_sonarr_event(SonarrEvent::DeleteBlocklistItem(1))
+        .await
+        .is_ok()
+    );
 
-    async_server.assert_async().await;
+    mock.assert_async().await;
   }
 
   #[rstest]
@@ -135,17 +124,11 @@ mod tests {
         ..blocklist_item()
       },
     ];
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(blocklist_json),
-      None,
-      SonarrEvent::GetBlocklist,
-      None,
-      None,
-    )
-    .await;
-    app_arc
+    let (mock, app, _server) = MockServarrApi::get()
+      .returns(blocklist_json)
+      .build_for(SonarrEvent::GetBlocklist)
+      .await;
+    app
       .lock()
       .await
       .data
@@ -156,7 +139,7 @@ mod tests {
         title: "Z Series".into(),
         ..series()
       }]);
-    app_arc.lock().await.data.sonarr_data.blocklist.sort_asc = true;
+    app.lock().await.data.sonarr_data.blocklist.sort_asc = true;
     if use_custom_sorting {
       let cmp_fn = |a: &BlocklistItem, b: &BlocklistItem| {
         a.source_title
@@ -169,7 +152,7 @@ mod tests {
         name: "Source Title",
         cmp_fn: Some(cmp_fn),
       };
-      app_arc
+      app
         .lock()
         .await
         .data
@@ -177,20 +160,20 @@ mod tests {
         .blocklist
         .sorting(vec![blocklist_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::BlocklistResponse(blocklist) = network
       .handle_sonarr_event(SonarrEvent::GetBlocklist)
       .await
       .unwrap()
     {
-      async_server.assert_async().await;
+      mock.assert_async().await;
       assert_eq!(
-        app_arc.lock().await.data.sonarr_data.blocklist.items,
+        app.lock().await.data.sonarr_data.blocklist.items,
         expected_blocklist
       );
-      assert!(app_arc.lock().await.data.sonarr_data.blocklist.sort_asc);
+      assert!(app.lock().await.data.sonarr_data.blocklist.sort_asc);
       assert_eq!(blocklist, response);
     }
   }
@@ -222,18 +205,12 @@ mod tests {
         "id": 456
     }]});
     let response: BlocklistResponse = serde_json::from_value(blocklist_json.clone()).unwrap();
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(blocklist_json),
-      None,
-      SonarrEvent::GetBlocklist,
-      None,
-      None,
-    )
-    .await;
-    app_arc.lock().await.data.sonarr_data.blocklist.sort_asc = true;
-    app_arc
+    let (mock, app, _server) = MockServarrApi::get()
+      .returns(blocklist_json)
+      .build_for(SonarrEvent::GetBlocklist)
+      .await;
+    app.lock().await.data.sonarr_data.blocklist.sort_asc = true;
+    app
       .lock()
       .await
       .push_navigation_stack(ActiveSonarrBlock::BlocklistSortPrompt.into());
@@ -246,24 +223,24 @@ mod tests {
       name: "Source Title",
       cmp_fn: Some(cmp_fn),
     };
-    app_arc
+    app
       .lock()
       .await
       .data
       .sonarr_data
       .blocklist
       .sorting(vec![blocklist_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::BlocklistResponse(blocklist) = network
       .handle_sonarr_event(SonarrEvent::GetBlocklist)
       .await
       .unwrap()
     {
-      async_server.assert_async().await;
-      assert!(app_arc.lock().await.data.sonarr_data.blocklist.is_empty());
-      assert!(app_arc.lock().await.data.sonarr_data.blocklist.sort_asc);
+      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

@@ -1,45 +1,38 @@
 #[cfg(test)]
 mod tests {
   use crate::models::sonarr_models::{DownloadsResponse, SonarrSerdeable};
-  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::sonarr_network::sonarr_network_test_utils::test_utils::{
     download_record, downloads_response,
   };
-  use crate::network::sonarr_network::SonarrEvent;
-  use crate::network::{Network, RequestMethod};
   use pretty_assertions::assert_eq;
-  use reqwest::Client;
   use serde_json::json;
-  use tokio_util::sync::CancellationToken;
 
   #[tokio::test]
   async fn test_handle_delete_sonarr_download_event() {
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Delete,
-      None,
-      None,
-      None,
-      SonarrEvent::DeleteDownload(1),
-      Some("/1"),
-      None,
-    )
-    .await;
-    app_arc
+    let (mock, app, _server) = MockServarrApi::delete()
+      .path("/1")
+      .build_for(SonarrEvent::DeleteDownload(1))
+      .await;
+    app
       .lock()
       .await
       .data
       .sonarr_data
       .downloads
       .set_items(vec![download_record()]);
-    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::DeleteDownload(1))
-      .await
-      .is_ok());
+    assert!(
+      network
+        .handle_sonarr_event(SonarrEvent::DeleteDownload(1))
+        .await
+        .is_ok()
+    );
 
-    async_server.assert_async().await;
+    mock.assert_async().await;
   }
 
   #[tokio::test]
@@ -59,27 +52,22 @@ mod tests {
     });
     let response: DownloadsResponse =
       serde_json::from_value(downloads_response_json.clone()).unwrap();
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(downloads_response_json),
-      None,
-      SonarrEvent::GetDownloads(500),
-      None,
-      Some("pageSize=500"),
-    )
-    .await;
-    app_arc.lock().await.server_tabs.next();
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let (mock, app, _server) = MockServarrApi::get()
+      .returns(downloads_response_json)
+      .query("pageSize=500")
+      .build_for(SonarrEvent::GetDownloads(500))
+      .await;
+    app.lock().await.server_tabs.next();
+    let mut network = test_network(&app);
 
     if let SonarrSerdeable::DownloadsResponse(downloads) = network
       .handle_sonarr_event(SonarrEvent::GetDownloads(500))
       .await
       .unwrap()
     {
-      async_server.assert_async().await;
+      mock.assert_async().await;
       assert_eq!(
-        app_arc.lock().await.data.sonarr_data.downloads.items,
+        app.lock().await.data.sonarr_data.downloads.items,
         downloads_response().records
       );
       assert_eq!(downloads, response);
@@ -88,26 +76,23 @@ mod tests {
 
   #[tokio::test]
   async fn test_handle_update_sonarr_downloads_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": "RefreshMonitoredDownloads"
-      })),
-      Some(json!({})),
-      None,
-      SonarrEvent::UpdateDownloads,
-      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::UpdateDownloads)
+      .await;
+    app.lock().await.server_tabs.next();
+    let mut network = test_network(&app);
 
-    assert!(network
-      .handle_sonarr_event(SonarrEvent::UpdateDownloads)
-      .await
-      .is_ok());
+    assert!(
+      network
+        .handle_sonarr_event(SonarrEvent::UpdateDownloads)
+        .await
+        .is_ok()
+    );
 
-    async_server.assert_async().await;
+    mock.assert_async().await;
   }
 }

src/network/sonarr_network/history/mod.rs

@@ -1,6 +1,6 @@
+use crate::models::Route;
 use crate::models::servarr_data::sonarr::sonarr_data::ActiveSonarrBlock;
 use crate::models::sonarr_models::SonarrHistoryWrapper;
-use crate::models::Route;
 use crate::network::sonarr_network::SonarrEvent;
 use crate::network::{Network, RequestMethod};
 use anyhow::Result;

src/network/sonarr_network/history/sonarr_history_network_tests.rs

@@ -3,15 +3,12 @@ mod tests {
   use crate::models::servarr_data::sonarr::sonarr_data::ActiveSonarrBlock;
   use crate::models::sonarr_models::{SonarrHistoryItem, SonarrHistoryWrapper, SonarrSerdeable};
   use crate::models::stateful_table::SortOption;
-  use crate::network::network_tests::test_utils::mock_servarr_api;
-  use crate::network::sonarr_network::sonarr_network_test_utils::test_utils::history_item;
+  use crate::network::network_tests::test_utils::{MockServarrApi, test_network};
   use crate::network::sonarr_network::SonarrEvent;
-  use crate::network::{Network, RequestMethod};
+  use crate::network::sonarr_network::sonarr_network_test_utils::test_utils::history_item;
   use pretty_assertions::assert_eq;
-  use reqwest::Client;
   use rstest::rstest;
   use serde_json::json;
-  use tokio_util::sync::CancellationToken;
 
   #[rstest]
   #[tokio::test]
@@ -57,17 +54,12 @@ mod tests {
         ..history_item()
       },
     ];
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(history_json),
-      None,
-      SonarrEvent::GetHistory(500),
-      None,
-      Some("pageSize=500&sortDirection=descending&sortKey=date"),
-    )
-    .await;
-    app_arc.lock().await.data.sonarr_data.history.sort_asc = true;
+    let (mock, app, _server) = MockServarrApi::get()
+      .returns(history_json)
+      .query("pageSize=500&sortDirection=descending&sortKey=date")
+      .build_for(SonarrEvent::GetHistory(500))
+      .await;
+    app.lock().await.data.sonarr_data.history.sort_asc = true;
     if use_custom_sorting {
       let cmp_fn = |a: &SonarrHistoryItem, b: &SonarrHistoryItem| {
         a.source_title
@@ -81,7 +73,7 @@ mod tests {
         name: "Source Title",
         cmp_fn: Some(cmp_fn),
       };
-      app_arc
+      app
         .lock()
         .await
         .data
@@ -89,20 +81,20 @@ mod tests {
         .history
         .sorting(vec![history_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::SonarrHistoryWrapper(history) = network
       .handle_sonarr_event(SonarrEvent::GetHistory(500))
       .await
       .unwrap()
     {
-      async_server.assert_async().await;
+      mock.assert_async().await;
       assert_eq!(
-        app_arc.lock().await.data.sonarr_data.history.items,
+        app.lock().await.data.sonarr_data.history.items,
         expected_history_items
       );
-      assert!(app_arc.lock().await.data.sonarr_data.history.sort_asc);
+      assert!(app.lock().await.data.sonarr_data.history.sort_asc);
       assert_eq!(history, response);
     }
   }
@@ -136,18 +128,13 @@ mod tests {
       }
     }]});
     let response: SonarrHistoryWrapper = 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::GetHistory(500),
-      None,
-      Some("pageSize=500&sortDirection=descending&sortKey=date"),
-    )
-    .await;
-    app_arc.lock().await.data.sonarr_data.history.sort_asc = true;
-    app_arc
+    let (mock, app, _server) = MockServarrApi::get()
+      .returns(history_json)
+      .query("pageSize=500&sortDirection=descending&sortKey=date")
+      .build_for(SonarrEvent::GetHistory(500))
+      .await;
+    app.lock().await.data.sonarr_data.history.sort_asc = true;
+    app
       .lock()
       .await
       .push_navigation_stack(ActiveSonarrBlock::HistorySortPrompt.into());
@@ -161,24 +148,24 @@ mod tests {
       name: "Source Title",
       cmp_fn: Some(cmp_fn),
     };
-    app_arc
+    app
       .lock()
       .await
       .data
       .sonarr_data
       .history
       .sorting(vec![history_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::SonarrHistoryWrapper(history) = network
       .handle_sonarr_event(SonarrEvent::GetHistory(500))
       .await
       .unwrap()
     {
-      async_server.assert_async().await;
-      assert!(app_arc.lock().await.data.sonarr_data.history.is_empty());
-      assert!(app_arc.lock().await.data.sonarr_data.history.sort_asc);
+      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);
     }
   }
@@ -186,25 +173,24 @@ mod tests {
   #[tokio::test]
   async fn test_handle_mark_sonarr_history_item_as_failed_event() {
     let expected_history_item_id = 1;
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Post,
-      None,
-      Some(json!({})),
-      None,
-      SonarrEvent::MarkHistoryItemAsFailed(expected_history_item_id),
-      Some("/1"),
-      None,
-    )
-    .await;
-    app_arc.lock().await.server_tabs.next();
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
-
-    assert!(network
-      .handle_sonarr_event(SonarrEvent::MarkHistoryItemAsFailed(
-        expected_history_item_id
+    let (mock, app, _server) = MockServarrApi::post()
+      .returns(json!({}))
+      .path("/1")
+      .build_for(SonarrEvent::MarkHistoryItemAsFailed(
+        expected_history_item_id,
       ))
-      .await
-      .is_ok());
-    async_server.assert_async().await;
+      .await;
+    app.lock().await.server_tabs.next();
+    let mut network = test_network(&app);
+
+    assert!(
+      network
+        .handle_sonarr_event(SonarrEvent::MarkHistoryItemAsFailed(
+          expected_history_item_id
+        ))
+        .await
+        .is_ok()
+    );
+    mock.assert_async().await;
   }
 }

src/network/sonarr_network/indexers/mod.rs

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

src/network/sonarr_network/indexers/sonarr_indexers_network_tests.rs

@@ -1,50 +1,44 @@
 #[cfg(test)]
 mod tests {
+  use crate::models::HorizontallyScrollableText;
   use crate::models::servarr_data::modals::IndexerTestResultModalItem;
   use crate::models::servarr_models::{EditIndexerParams, Indexer, IndexerTestResult};
   use crate::models::sonarr_models::SonarrSerdeable;
-  use crate::models::HorizontallyScrollableText;
-  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::sonarr_network_test_utils::test_utils::{
     indexer, indexer_settings,
   };
-  use crate::network::sonarr_network::SonarrEvent;
-  use crate::network::{Network, NetworkResource, RequestMethod};
   use bimap::BiMap;
   use mockito::Matcher;
   use pretty_assertions::assert_eq;
-  use reqwest::Client;
   use serde_json::json;
-  use tokio_util::sync::CancellationToken;
 
   #[tokio::test]
   async fn test_handle_delete_sonarr_indexer_event() {
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Delete,
-      None,
-      None,
-      None,
-      SonarrEvent::DeleteIndexer(1),
-      Some("/1"),
-      None,
-    )
-    .await;
-    app_arc
+    let (mock, app, _server) = MockServarrApi::delete()
+      .path("/1")
+      .build_for(SonarrEvent::DeleteIndexer(1))
+      .await;
+    app
       .lock()
       .await
       .data
       .sonarr_data
       .indexers
       .set_items(vec![indexer()]);
-    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::DeleteIndexer(1))
-      .await
-      .is_ok());
+    assert!(
+      network
+        .handle_sonarr_event(SonarrEvent::DeleteIndexer(1))
+        .await
+        .is_ok()
+    );
 
-    async_server.assert_async().await;
+    mock.assert_async().await;
   }
 
   #[tokio::test]
@@ -56,26 +50,22 @@ mod tests {
         "retention": 1,
         "rssSyncInterval": 60
     });
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Put,
-      Some(indexer_settings_json),
-      None,
-      None,
-      SonarrEvent::EditAllIndexerSettings(indexer_settings()),
-      None,
-      None,
-    )
-    .await;
+    let (mock, app, _server) = MockServarrApi::put()
+      .with_request_body(indexer_settings_json)
+      .build_for(SonarrEvent::EditAllIndexerSettings(indexer_settings()))
+      .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::EditAllIndexerSettings(indexer_settings()))
-      .await
-      .is_ok());
+    assert!(
+      network
+        .handle_sonarr_event(SonarrEvent::EditAllIndexerSettings(indexer_settings()))
+        .await
+        .is_ok()
+    );
 
-    async_server.assert_async().await;
+    mock.assert_async().await;
   }
 
   #[tokio::test]
@@ -139,17 +129,12 @@ mod tests {
         "tags": [1, 2],
         "id": 1
     });
-    let (async_details_server, app_arc, mut server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(indexer_details_json),
-      None,
-      SonarrEvent::GetIndexers,
-      Some("/1"),
-      None,
-    )
-    .await;
-    let async_edit_server = server
+    let (mock_details_server, app, mut server) = MockServarrApi::get()
+      .returns(indexer_details_json)
+      .path("/1")
+      .build_for(SonarrEvent::GetIndexers)
+      .await;
+    let mock_edit_server = server
       .mock(
         "PUT",
         format!(
@@ -163,23 +148,25 @@ mod tests {
       .match_body(Matcher::Json(expected_indexer_edit_body_json))
       .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::EditIndexer(expected_edit_indexer_params))
-      .await
-      .is_ok());
+    assert!(
+      network
+        .handle_sonarr_event(SonarrEvent::EditIndexer(expected_edit_indexer_params))
+        .await
+        .is_ok()
+    );
 
-    async_details_server.assert_async().await;
-    async_edit_server.assert_async().await;
+    mock_details_server.assert_async().await;
+    mock_edit_server.assert_async().await;
   }
 
   #[tokio::test]
-  async fn test_handle_edit_sonarr_indexer_event_does_not_overwrite_tags_vec_if_tag_input_string_is_none(
-  ) {
+  async fn test_handle_edit_sonarr_indexer_event_does_not_overwrite_tags_vec_if_tag_input_string_is_none()
+   {
     let expected_edit_indexer_params = EditIndexerParams {
       indexer_id: 1,
       name: Some("Test Update".to_owned()),
@@ -239,17 +226,12 @@ mod tests {
         "tags": [1, 2],
         "id": 1
     });
-    let (async_details_server, app_arc, mut server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(indexer_details_json),
-      None,
-      SonarrEvent::GetIndexers,
-      Some("/1"),
-      None,
-    )
-    .await;
-    let async_edit_server = server
+    let (mock_details_server, app, mut server) = MockServarrApi::get()
+      .returns(indexer_details_json)
+      .path("/1")
+      .build_for(SonarrEvent::GetIndexers)
+      .await;
+    let mock_edit_server = server
       .mock(
         "PUT",
         format!(
@@ -263,21 +245,23 @@ mod tests {
       .match_body(Matcher::Json(expected_indexer_edit_body_json))
       .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::EditIndexer(expected_edit_indexer_params))
-      .await
-      .is_ok());
+    assert!(
+      network
+        .handle_sonarr_event(SonarrEvent::EditIndexer(expected_edit_indexer_params))
+        .await
+        .is_ok()
+    );
 
-    async_details_server.assert_async().await;
-    async_edit_server.assert_async().await;
+    mock_details_server.assert_async().await;
+    mock_edit_server.assert_async().await;
   }
 
   #[tokio::test]
-  async fn test_handle_edit_sonarr_indexer_event_does_not_add_seed_ratio_when_seed_ratio_field_is_none_in_details(
-  ) {
+  async fn test_handle_edit_sonarr_indexer_event_does_not_add_seed_ratio_when_seed_ratio_field_is_none_in_details()
+   {
     let expected_edit_indexer_params = EditIndexerParams {
       indexer_id: 1,
       name: Some("Test Update".to_owned()),
@@ -330,17 +314,12 @@ mod tests {
         "id": 1
     });
 
-    let (async_details_server, app_arc, mut server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(indexer_details_json),
-      None,
-      SonarrEvent::GetIndexers,
-      Some("/1"),
-      None,
-    )
-    .await;
-    let async_edit_server = server
+    let (mock_details_server, app, mut server) = MockServarrApi::get()
+      .returns(indexer_details_json)
+      .path("/1")
+      .build_for(SonarrEvent::GetIndexers)
+      .await;
+    let mock_edit_server = server
       .mock(
         "PUT",
         format!(
@@ -354,23 +333,25 @@ mod tests {
       .match_body(Matcher::Json(expected_indexer_edit_body_json))
       .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::EditIndexer(expected_edit_indexer_params))
-      .await
-      .is_ok());
+    assert!(
+      network
+        .handle_sonarr_event(SonarrEvent::EditIndexer(expected_edit_indexer_params))
+        .await
+        .is_ok()
+    );
 
-    async_details_server.assert_async().await;
-    async_edit_server.assert_async().await;
+    mock_details_server.assert_async().await;
+    mock_edit_server.assert_async().await;
   }
 
   #[tokio::test]
-  async fn test_handle_edit_sonarr_indexer_event_populates_the_seed_ratio_value_when_seed_ratio_field_is_present_in_details(
-  ) {
+  async fn test_handle_edit_sonarr_indexer_event_populates_the_seed_ratio_value_when_seed_ratio_field_is_present_in_details()
+   {
     let expected_edit_indexer_params = EditIndexerParams {
       indexer_id: 1,
       name: Some("Test Update".to_owned()),
@@ -430,17 +411,12 @@ mod tests {
         "id": 1
     });
 
-    let (async_details_server, app_arc, mut server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(indexer_details_json),
-      None,
-      SonarrEvent::GetIndexers,
-      Some("/1"),
-      None,
-    )
-    .await;
-    let async_edit_server = server
+    let (mock_details_server, app, mut server) = MockServarrApi::get()
+      .returns(indexer_details_json)
+      .path("/1")
+      .build_for(SonarrEvent::GetIndexers)
+      .await;
+    let mock_edit_server = server
       .mock(
         "PUT",
         format!(
@@ -454,18 +430,20 @@ mod tests {
       .match_body(Matcher::Json(expected_indexer_edit_body_json))
       .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::EditIndexer(expected_edit_indexer_params))
-      .await
-      .is_ok());
+    assert!(
+      network
+        .handle_sonarr_event(SonarrEvent::EditIndexer(expected_edit_indexer_params))
+        .await
+        .is_ok()
+    );
 
-    async_details_server.assert_async().await;
-    async_edit_server.assert_async().await;
+    mock_details_server.assert_async().await;
+    mock_edit_server.assert_async().await;
   }
 
   #[tokio::test]
@@ -497,17 +475,12 @@ mod tests {
       indexer_id: 1,
       ..EditIndexerParams::default()
     };
-    let (async_details_server, app_arc, mut server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(indexer_details_json.clone()),
-      None,
-      SonarrEvent::GetIndexers,
-      Some("/1"),
-      None,
-    )
-    .await;
-    let async_edit_server = server
+    let (mock_details_server, app, mut server) = MockServarrApi::get()
+      .returns(indexer_details_json.clone())
+      .path("/1")
+      .build_for(SonarrEvent::GetIndexers)
+      .await;
+    let mock_edit_server = server
       .mock(
         "PUT",
         format!(
@@ -521,16 +494,18 @@ mod tests {
       .match_body(Matcher::Json(indexer_details_json))
       .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::EditIndexer(edit_indexer_params))
-      .await
-      .is_ok());
+    assert!(
+      network
+        .handle_sonarr_event(SonarrEvent::EditIndexer(edit_indexer_params))
+        .await
+        .is_ok()
+    );
 
-    async_details_server.assert_async().await;
-    async_edit_server.assert_async().await;
+    mock_details_server.assert_async().await;
+    mock_edit_server.assert_async().await;
   }
 
   #[tokio::test]
@@ -587,16 +562,11 @@ mod tests {
       ..EditIndexerParams::default()
     };
 
-    let (async_details_server, app_arc, mut server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(indexer_details_json),
-      None,
-      SonarrEvent::GetIndexers,
-      Some("/1"),
-      None,
-    )
-    .await;
+    let (async_details_server, app, mut server) = MockServarrApi::get()
+      .returns(indexer_details_json)
+      .path("/1")
+      .build_for(SonarrEvent::GetIndexers)
+      .await;
     let async_edit_server = server
       .mock(
         "PUT",
@@ -611,13 +581,15 @@ mod tests {
       .match_body(Matcher::Json(expected_edit_indexer_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::EditIndexer(edit_indexer_params))
-      .await
-      .is_ok());
+    assert!(
+      network
+        .handle_sonarr_event(SonarrEvent::EditIndexer(edit_indexer_params))
+        .await
+        .is_ok()
+    );
 
     async_details_server.assert_async().await;
     async_edit_server.assert_async().await;
@@ -656,18 +628,12 @@ mod tests {
         "id": 1
     }]);
     let response: Vec<Indexer> = serde_json::from_value(indexers_response_json.clone()).unwrap();
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(indexers_response_json),
-      None,
-      SonarrEvent::GetIndexers,
-      None,
-      None,
-    )
-    .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::get()
+      .returns(indexers_response_json)
+      .build_for(SonarrEvent::GetIndexers)
+      .await;
+    app.lock().await.server_tabs.next();
+    let mut network = test_network(&app);
 
     if let SonarrSerdeable::Indexers(indexers) = network
       .handle_sonarr_event(SonarrEvent::GetIndexers)
@@ -676,7 +642,7 @@ mod tests {
     {
       async_server.assert_async().await;
       assert_eq!(
-        app_arc.lock().await.data.sonarr_data.indexers.items,
+        app.lock().await.data.sonarr_data.indexers.items,
         vec![indexer()]
       );
       assert_eq!(indexers, response);
@@ -714,16 +680,11 @@ mod tests {
         "errorMessage": "test failure",
         "severity": "error"
     }]);
-    let (async_details_server, app_arc, mut server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(indexer_details_json.clone()),
-      None,
-      SonarrEvent::GetIndexers,
-      Some("/1"),
-      None,
-    )
-    .await;
+    let (async_details_server, app, mut server) = MockServarrApi::get()
+      .returns(indexer_details_json.clone())
+      .path("/1")
+      .build_for(SonarrEvent::GetIndexers)
+      .await;
     let async_test_server = server
       .mock(
         "POST",
@@ -735,15 +696,15 @@ mod tests {
       .with_body(response_json.to_string())
       .create_async()
       .await;
-    app_arc
+    app
       .lock()
       .await
       .data
       .sonarr_data
       .indexers
       .set_items(vec![indexer()]);
-    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::Value(value) = network
       .handle_sonarr_event(SonarrEvent::TestIndexer(1))
@@ -753,7 +714,7 @@ mod tests {
       async_details_server.assert_async().await;
       async_test_server.assert_async().await;
       assert_eq!(
-        app_arc.lock().await.data.sonarr_data.indexer_test_errors,
+        app.lock().await.data.sonarr_data.indexer_test_errors,
         Some("\"test failure\"".to_owned())
       );
       assert_eq!(value, response_json)
@@ -784,16 +745,11 @@ mod tests {
         "tags": [1],
         "id": 1
     });
-    let (async_details_server, app_arc, mut server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(indexer_details_json.clone()),
-      None,
-      SonarrEvent::GetIndexers,
-      Some("/1"),
-      None,
-    )
-    .await;
+    let (async_details_server, app, mut server) = MockServarrApi::get()
+      .returns(indexer_details_json.clone())
+      .path("/1")
+      .build_for(SonarrEvent::GetIndexers)
+      .await;
     let async_test_server = server
       .mock(
         "POST",
@@ -805,15 +761,15 @@ mod tests {
       .with_body("{}")
       .create_async()
       .await;
-    app_arc
+    app
       .lock()
       .await
       .data
       .sonarr_data
       .indexers
       .set_items(vec![indexer()]);
-    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::Value(value) = network
       .handle_sonarr_event(SonarrEvent::TestIndexer(1))
@@ -823,7 +779,7 @@ mod tests {
       async_details_server.assert_async().await;
       async_test_server.assert_async().await;
       assert_eq!(
-        app_arc.lock().await.data.sonarr_data.indexer_test_errors,
+        app.lock().await.data.sonarr_data.indexer_test_errors,
         Some(String::new())
       );
       assert_eq!(value, json!({}));
@@ -879,25 +835,20 @@ mod tests {
       ]
     }]);
     let response: Vec<IndexerTestResult> = serde_json::from_value(response_json.clone()).unwrap();
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Post,
-      None,
-      Some(response_json),
-      Some(400),
-      SonarrEvent::TestAllIndexers,
-      None,
-      None,
-    )
-    .await;
-    app_arc
+    let (async_server, app, _server) = MockServarrApi::post()
+      .returns(response_json)
+      .status(400)
+      .build_for(SonarrEvent::TestAllIndexers)
+      .await;
+    app
       .lock()
       .await
       .data
       .sonarr_data
       .indexers
       .set_items(indexers);
-    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::IndexerTestResults(results) = network
       .handle_sonarr_event(SonarrEvent::TestAllIndexers)
@@ -905,15 +856,17 @@ mod tests {
       .unwrap()
     {
       async_server.assert_async().await;
-      assert!(app_arc
-        .lock()
-        .await
-        .data
-        .sonarr_data
-        .indexer_test_all_results
-        .is_some());
+      assert!(
+        app
+          .lock()
+          .await
+          .data
+          .sonarr_data
+          .indexer_test_all_results
+          .is_some()
+      );
       assert_eq!(
-        app_arc
+        app
           .lock()
           .await
           .data

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());
   }
 }

src/network/sonarr_network/mod.rs

@@ -1,6 +1,6 @@
 use anyhow::Result;
 use log::info;
-use serde_json::{json, Value};
+use serde_json::{Value, json};
 
 use super::{Network, NetworkEvent, NetworkResource};
 use crate::{

src/network/sonarr_network/root_folders/sonarr_root_folders_network_tests.rs

@@ -2,71 +2,57 @@
 mod tests {
   use crate::models::servarr_models::{AddRootFolderBody, RootFolder};
   use crate::models::sonarr_models::SonarrSerdeable;
-  use crate::network::network_tests::test_utils::mock_servarr_api;
-  use crate::network::sonarr_network::sonarr_network_test_utils::test_utils::root_folder;
+  use crate::network::network_tests::test_utils::{MockServarrApi, test_network};
   use crate::network::sonarr_network::SonarrEvent;
-  use crate::network::{Network, RequestMethod};
+  use crate::network::sonarr_network::sonarr_network_test_utils::test_utils::root_folder;
   use pretty_assertions::assert_eq;
-  use reqwest::Client;
   use serde_json::json;
-  use tokio_util::sync::CancellationToken;
 
   #[tokio::test]
   async fn test_handle_add_sonarr_root_folder_event() {
     let expected_add_root_folder_body = AddRootFolderBody {
       path: "/nfs/test".to_owned(),
     };
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Post,
-      Some(json!({
+    let (mock, app, _server) = MockServarrApi::post()
+      .with_request_body(json!({
         "path": "/nfs/test"
-      })),
-      Some(json!({})),
-      None,
-      SonarrEvent::AddRootFolder(expected_add_root_folder_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::AddRootFolder(
+        expected_add_root_folder_body.clone(),
+      ))
+      .await;
+    app.lock().await.server_tabs.next();
+    let mut network = test_network(&app);
 
-    assert!(network
-      .handle_sonarr_event(SonarrEvent::AddRootFolder(expected_add_root_folder_body))
-      .await
-      .is_ok());
+    assert!(
+      network
+        .handle_sonarr_event(SonarrEvent::AddRootFolder(expected_add_root_folder_body))
+        .await
+        .is_ok()
+    );
 
-    async_server.assert_async().await;
-    assert!(app_arc
-      .lock()
-      .await
-      .data
-      .sonarr_data
-      .edit_root_folder
-      .is_none());
+    mock.assert_async().await;
+    assert!(app.lock().await.data.sonarr_data.edit_root_folder.is_none());
   }
 
   #[tokio::test]
   async fn test_handle_delete_sonarr_root_folder_event() {
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Delete,
-      None,
-      None,
-      None,
-      SonarrEvent::DeleteRootFolder(1),
-      Some("/1"),
-      None,
-    )
-    .await;
-    app_arc.lock().await.server_tabs.next();
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let (mock, app, _server) = MockServarrApi::delete()
+      .path("/1")
+      .build_for(SonarrEvent::DeleteRootFolder(1))
+      .await;
+    app.lock().await.server_tabs.next();
+    let mut network = test_network(&app);
 
-    assert!(network
-      .handle_sonarr_event(SonarrEvent::DeleteRootFolder(1))
-      .await
-      .is_ok());
+    assert!(
+      network
+        .handle_sonarr_event(SonarrEvent::DeleteRootFolder(1))
+        .await
+        .is_ok()
+    );
 
-    async_server.assert_async().await;
+    mock.assert_async().await;
   }
 
   #[tokio::test]
@@ -78,27 +64,21 @@ mod tests {
       "freeSpace": 219902325555200u64,
     }]);
     let response: Vec<RootFolder> = serde_json::from_value(root_folder_json.clone()).unwrap();
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(root_folder_json),
-      None,
-      SonarrEvent::GetRootFolders,
-      None,
-      None,
-    )
-    .await;
-    app_arc.lock().await.server_tabs.next();
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let (mock, app, _server) = MockServarrApi::get()
+      .returns(root_folder_json)
+      .build_for(SonarrEvent::GetRootFolders)
+      .await;
+    app.lock().await.server_tabs.next();
+    let mut network = test_network(&app);
 
     if let SonarrSerdeable::RootFolders(root_folders) = network
       .handle_sonarr_event(SonarrEvent::GetRootFolders)
       .await
       .unwrap()
     {
-      async_server.assert_async().await;
+      mock.assert_async().await;
       assert_eq!(
-        app_arc.lock().await.data.sonarr_data.root_folders.items,
+        app.lock().await.data.sonarr_data.root_folders.items,
         vec![root_folder()]
       );
       assert_eq!(root_folders, response);

src/network/sonarr_network/sonarr_network_test_utils.rs

@@ -1,5 +1,6 @@
 #[cfg(test)]
 pub(in crate::network::sonarr_network) mod test_utils {
+  use crate::models::HorizontallyScrollableText;
   use crate::models::servarr_models::{
     Indexer, IndexerField, Language, Quality, QualityWrapper, RootFolder,
   };
@@ -9,9 +10,8 @@ pub(in crate::network::sonarr_network) mod test_utils {
     Season, SeasonStatistics, Series, SeriesStatistics, SeriesStatus, SeriesType,
     SonarrHistoryData, SonarrHistoryEventType, SonarrHistoryItem, SonarrRelease,
   };
-  use crate::models::HorizontallyScrollableText;
   use chrono::DateTime;
-  use serde_json::{json, Number};
+  use serde_json::{Number, Value, json};
 
   pub const SERIES_JSON: &str = r#"{
         "title": "Test",
@@ -392,4 +392,11 @@ pub(in crate::network::sonarr_network) mod test_utils {
       unmapped_folders: None,
     }
   }
+
+  pub fn tag() -> Value {
+    json!({
+      "id": 3,
+      "label": "testing"
+    })
+  }
 }

src/network/sonarr_network/sonarr_network_tests.rs

@@ -9,18 +9,15 @@ mod test {
     AddSeriesBody, EditSeriesParams, IndexerSettings, SonarrTaskName,
   };
   use crate::models::sonarr_models::{DeleteSeriesParams, SonarrSerdeable};
-  use crate::network::{
-    network_tests::test_utils::mock_servarr_api, sonarr_network::SonarrEvent, Network,
-    NetworkEvent, NetworkResource, RequestMethod,
-  };
+  use crate::network::network_tests::test_utils::{MockServarrApi, test_network};
+  use crate::network::sonarr_network::sonarr_network_test_utils::test_utils::tag;
+  use crate::network::{NetworkEvent, NetworkResource, sonarr_network::SonarrEvent};
   use bimap::BiMap;
   use pretty_assertions::{assert_eq, assert_str_eq};
-  use reqwest::Client;
   use rstest::rstest;
   use serde_json::json;
   use std::sync::Arc;
   use tokio::sync::Mutex;
-  use tokio_util::sync::CancellationToken;
 
   #[rstest]
   fn test_resource_all_indexer_settings(
@@ -191,82 +188,73 @@ mod test {
 
   #[tokio::test]
   async fn test_handle_add_sonarr_tag() {
-    let tag_json = json!({ "id": 3, "label": "testing" });
-    let response: Tag = serde_json::from_value(tag_json.clone()).unwrap();
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Post,
-      Some(json!({ "label": "testing" })),
-      Some(tag_json),
-      None,
-      SonarrEvent::AddTag(String::new()),
-      None,
-      None,
-    )
-    .await;
-    app_arc.lock().await.data.sonarr_data.tags_map =
-      BiMap::from_iter([(1, "usenet".to_owned()), (2, "test".to_owned())]);
-    app_arc.lock().await.server_tabs.next();
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let expected = Tag {
+      id: 3,
+      label: "testing".to_owned(),
+    };
 
-    if let SonarrSerdeable::Tag(tag) = network
+    let (mock, app, _server) = MockServarrApi::post()
+      .with_request_body(json!({ "label": "testing" }))
+      .returns(tag())
+      .build_for(SonarrEvent::AddTag(String::new()))
+      .await;
+
+    app.lock().await.data.sonarr_data.tags_map =
+      BiMap::from_iter([(1, "usenet".to_owned()), (2, "test".to_owned())]);
+    app.lock().await.server_tabs.next();
+
+    let mut network = test_network(&app);
+
+    let result = network
       .handle_sonarr_event(SonarrEvent::AddTag("testing".to_owned()))
-      .await
-      .unwrap()
-    {
-      async_server.assert_async().await;
-      assert_eq!(
-        app_arc.lock().await.data.sonarr_data.tags_map,
-        BiMap::from_iter([
-          (1, "usenet".to_owned()),
-          (2, "test".to_owned()),
-          (3, "testing".to_owned())
-        ])
-      );
-      assert_eq!(tag, response);
-    }
+      .await;
+
+    mock.assert_async().await;
+
+    let SonarrSerdeable::Tag(tag) = result.unwrap() else {
+      panic!("Expected Tag variant");
+    };
+    assert_eq!(tag, expected);
+    assert_eq!(
+      app.lock().await.data.sonarr_data.tags_map,
+      BiMap::from_iter([
+        (1, "usenet".to_owned()),
+        (2, "test".to_owned()),
+        (3, "testing".to_owned())
+      ])
+    );
   }
 
   #[tokio::test]
   async fn test_handle_delete_sonarr_tag_event() {
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Delete,
-      None,
-      None,
-      None,
-      SonarrEvent::DeleteTag(1),
-      Some("/1"),
-      None,
-    )
-    .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")
+      .build_for(SonarrEvent::DeleteTag(1))
+      .await;
+    app.lock().await.server_tabs.next();
+    let mut network = test_network(&app);
 
-    assert!(network
-      .handle_sonarr_event(SonarrEvent::DeleteTag(1))
-      .await
-      .is_ok());
+    assert!(
+      network
+        .handle_sonarr_event(SonarrEvent::DeleteTag(1))
+        .await
+        .is_ok()
+    );
 
     async_server.assert_async().await;
   }
 
   #[tokio::test]
   async fn test_handle_get_sonarr_healthcheck_event() {
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      None,
-      None,
-      SonarrEvent::HealthCheck,
-      None,
-      None,
-    )
-    .await;
-    app_arc.lock().await.server_tabs.next();
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let (mock, app, _server) = MockServarrApi::get()
+      .build_for(SonarrEvent::HealthCheck)
+      .await;
+    app.lock().await.server_tabs.next();
+    let mut network = test_network(&app);
 
     let _ = network.handle_sonarr_event(SonarrEvent::HealthCheck).await;
 
-    async_server.assert_async().await;
+    mock.assert_async().await;
   }
 
   #[tokio::test]
@@ -276,31 +264,27 @@ mod test {
       "name": "English"
     }]);
     let response: Vec<Language> = serde_json::from_value(language_profiles_json.clone()).unwrap();
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(language_profiles_json),
-      None,
-      SonarrEvent::GetLanguageProfiles,
-      None,
-      None,
-    )
-    .await;
-    app_arc.lock().await.server_tabs.next();
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let (mock, app, _server) = MockServarrApi::get()
+      .returns(language_profiles_json)
+      .build_for(SonarrEvent::GetLanguageProfiles)
+      .await;
+    app.lock().await.server_tabs.next();
+    let mut network = test_network(&app);
 
-    if let SonarrSerdeable::LanguageProfiles(language_profiles) = network
+    let result = network
       .handle_sonarr_event(SonarrEvent::GetLanguageProfiles)
-      .await
-      .unwrap()
-    {
-      async_server.assert_async().await;
-      assert_eq!(
-        app_arc.lock().await.data.sonarr_data.language_profiles_map,
-        BiMap::from_iter([(2222i64, "English".to_owned())])
-      );
-      assert_eq!(language_profiles, response);
-    }
+      .await;
+
+    mock.assert_async().await;
+
+    let SonarrSerdeable::LanguageProfiles(language_profiles) = result.unwrap() else {
+      panic!("Expected the LanguageProfiles variant")
+    };
+    assert_eq!(
+      app.lock().await.data.sonarr_data.language_profiles_map,
+      BiMap::from_iter([(2222i64, "English".to_owned())])
+    );
+    assert_eq!(language_profiles, response);
   }
 
   #[tokio::test]
@@ -311,31 +295,27 @@ mod test {
     }]);
     let response: Vec<QualityProfile> =
       serde_json::from_value(quality_profile_json.clone()).unwrap();
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(quality_profile_json),
-      None,
-      SonarrEvent::GetQualityProfiles,
-      None,
-      None,
-    )
-    .await;
-    app_arc.lock().await.server_tabs.next();
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let (mock, app, _server) = MockServarrApi::get()
+      .returns(quality_profile_json)
+      .build_for(SonarrEvent::GetQualityProfiles)
+      .await;
+    app.lock().await.server_tabs.next();
+    let mut network = test_network(&app);
 
-    if let SonarrSerdeable::QualityProfiles(quality_profiles) = network
+    let result = network
       .handle_sonarr_event(SonarrEvent::GetQualityProfiles)
-      .await
-      .unwrap()
-    {
-      async_server.assert_async().await;
-      assert_eq!(
-        app_arc.lock().await.data.sonarr_data.quality_profile_map,
-        BiMap::from_iter([(2222i64, "HD - 1080p".to_owned())])
-      );
-      assert_eq!(quality_profiles, response);
-    }
+      .await;
+
+    mock.assert_async().await;
+
+    let SonarrSerdeable::QualityProfiles(quality_profiles) = result.unwrap() else {
+      panic!("Expected the QualityProfiles variant")
+    };
+    assert_eq!(
+      app.lock().await.data.sonarr_data.quality_profile_map,
+      BiMap::from_iter([(2222i64, "HD - 1080p".to_owned())])
+    );
+    assert_eq!(quality_profiles, response);
   }
 
   #[tokio::test]
@@ -345,31 +325,26 @@ mod test {
       "label": "usenet"
     }]);
     let response: Vec<Tag> = serde_json::from_value(tags_json.clone()).unwrap();
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(tags_json),
-      None,
-      SonarrEvent::GetTags,
-      None,
-      None,
-    )
-    .await;
-    app_arc.lock().await.server_tabs.next();
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let (mock, app, _server) = MockServarrApi::get()
+      .returns(tags_json)
+      .build_for(SonarrEvent::GetTags)
+      .await;
+    app.lock().await.server_tabs.next();
+    let mut network = test_network(&app);
 
-    if let SonarrSerdeable::Tags(tags) = network
-      .handle_sonarr_event(SonarrEvent::GetTags)
-      .await
-      .unwrap()
-    {
-      async_server.assert_async().await;
-      assert_eq!(
-        app_arc.lock().await.data.sonarr_data.tags_map,
-        BiMap::from_iter([(2222i64, "usenet".to_owned())])
-      );
-      assert_eq!(tags, response);
-    }
+    let result = network.handle_sonarr_event(SonarrEvent::GetTags).await;
+
+    mock.assert_async().await;
+
+    let SonarrSerdeable::Tags(tags) = result.unwrap() else {
+      panic!("Expected the Tag variant")
+    };
+    mock.assert_async().await;
+    assert_eq!(
+      app.lock().await.data.sonarr_data.tags_map,
+      BiMap::from_iter([(2222i64, "usenet".to_owned())])
+    );
+    assert_eq!(tags, response);
   }
 
   #[tokio::test]
@@ -385,7 +360,7 @@ mod test {
       ]);
     }
     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_eq!(
       network.extract_and_add_sonarr_tag_ids_vec(tags).await,
@@ -395,35 +370,30 @@ mod test {
 
   #[tokio::test]
   async fn test_extract_and_add_sonarr_tag_ids_vec_add_missing_tags_first() {
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Post,
-      Some(json!({ "label": "TESTING" })),
-      Some(json!({ "id": 3, "label": "testing" })),
-      None,
-      SonarrEvent::GetTags,
-      None,
-      None,
-    )
-    .await;
+    let (mock, app, _server) = MockServarrApi::post()
+      .with_request_body(json!({ "label": "TESTING" }))
+      .returns(json!({ "id": 3, "label": "testing" }))
+      .build_for(SonarrEvent::GetTags)
+      .await;
     let tags = "usenet, test, TESTING";
     {
-      let mut app = app_arc.lock().await;
-      app.data.sonarr_data.add_series_modal = Some(AddSeriesModal {
+      let mut app_guard = app.lock().await;
+      app_guard.data.sonarr_data.add_series_modal = Some(AddSeriesModal {
         tags: tags.into(),
         ..AddSeriesModal::default()
       });
-      app.data.sonarr_data.tags_map =
+      app_guard.data.sonarr_data.tags_map =
         BiMap::from_iter([(1, "usenet".to_owned()), (2, "test".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);
 
     let tag_ids_vec = network.extract_and_add_sonarr_tag_ids_vec(tags).await;
 
-    async_server.assert_async().await;
+    mock.assert_async().await;
     assert_eq!(tag_ids_vec, vec![1, 2, 3]);
     assert_eq!(
-      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, "test".to_owned()),

src/network/sonarr_network/system/sonarr_system_network_tests.rs

@@ -5,15 +5,12 @@ mod tests {
   };
   use crate::models::sonarr_models::{SonarrSerdeable, SonarrTask, SonarrTaskName, SystemStatus};
   use crate::models::{HorizontallyScrollableText, ScrollableText};
-  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 chrono::DateTime;
   use indoc::formatdoc;
   use pretty_assertions::{assert_eq, assert_str_eq};
-  use reqwest::Client;
   use serde_json::json;
-  use tokio_util::sync::CancellationToken;
 
   #[tokio::test]
   async fn test_handle_get_sonarr_host_config_event() {
@@ -29,25 +26,19 @@ mod tests {
       "sslCertPassword": "test"
     });
     let response: HostConfig = serde_json::from_value(host_config_response.clone()).unwrap();
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(host_config_response),
-      None,
-      SonarrEvent::GetHostConfig,
-      None,
-      None,
-    )
-    .await;
-    app_arc.lock().await.server_tabs.next();
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let (mock, app, _server) = MockServarrApi::get()
+      .returns(host_config_response)
+      .build_for(SonarrEvent::GetHostConfig)
+      .await;
+    app.lock().await.server_tabs.next();
+    let mut network = test_network(&app);
 
     if let SonarrSerdeable::HostConfig(host_config) = network
       .handle_sonarr_event(SonarrEvent::GetHostConfig)
       .await
       .unwrap()
     {
-      async_server.assert_async().await;
+      mock.assert_async().await;
       assert_eq!(host_config, response);
     }
   }
@@ -85,48 +76,40 @@ mod tests {
         ]
     });
     let response: LogResponse = serde_json::from_value(logs_response_json.clone()).unwrap();
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(logs_response_json),
-      None,
-      SonarrEvent::GetLogs(500),
-      None,
-      Some("pageSize=500&sortDirection=descending&sortKey=time"),
-    )
-    .await;
-    app_arc.lock().await.server_tabs.next();
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let (mock, app, _server) = MockServarrApi::get()
+      .returns(logs_response_json)
+      .query("pageSize=500&sortDirection=descending&sortKey=time")
+      .build_for(SonarrEvent::GetLogs(500))
+      .await;
+    app.lock().await.server_tabs.next();
+    let mut network = test_network(&app);
 
     if let SonarrSerdeable::LogResponse(logs) = network
       .handle_sonarr_event(SonarrEvent::GetLogs(500))
       .await
       .unwrap()
     {
-      async_server.assert_async().await;
-      assert_eq!(
-        app_arc.lock().await.data.sonarr_data.logs.items,
-        expected_logs
+      mock.assert_async().await;
+      assert_eq!(app.lock().await.data.sonarr_data.logs.items, expected_logs);
+      assert!(
+        app
+          .lock()
+          .await
+          .data
+          .sonarr_data
+          .logs
+          .current_selection()
+          .text
+          .contains("INFO")
       );
-      assert!(app_arc
-        .lock()
-        .await
-        .data
-        .sonarr_data
-        .logs
-        .current_selection()
-        .text
-        .contains("INFO"));
       assert_eq!(logs, response);
     }
   }
 
   #[tokio::test]
   async fn test_handle_get_sonarr_diskspace_event() {
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(json!([
+    let (mock, app, _server) = MockServarrApi::get()
+      .returns(json!([
         {
           "freeSpace": 1111,
           "totalSpace": 2222,
@@ -135,15 +118,11 @@ mod tests {
           "freeSpace": 3333,
           "totalSpace": 4444
         }
-      ])),
-      None,
-      SonarrEvent::GetDiskSpace,
-      None,
-      None,
-    )
-    .await;
-    app_arc.lock().await.server_tabs.next();
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+      ]))
+      .build_for(SonarrEvent::GetDiskSpace)
+      .await;
+    app.lock().await.server_tabs.next();
+    let mut network = test_network(&app);
     let disk_space_vec = vec![
       DiskSpace {
         free_space: 1111,
@@ -160,9 +139,9 @@ mod tests {
       .await
       .unwrap()
     {
-      async_server.assert_async().await;
+      mock.assert_async().await;
       assert_eq!(
-        app_arc.lock().await.data.sonarr_data.disk_space_vec,
+        app.lock().await.data.sonarr_data.disk_space_vec,
         disk_space_vec
       );
       assert_eq!(disk_space, disk_space_vec);
@@ -194,27 +173,21 @@ mod tests {
       trigger: "scheduled".to_owned(),
     };
 
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(queued_events_json),
-      None,
-      SonarrEvent::GetQueuedEvents,
-      None,
-      None,
-    )
-    .await;
-    app_arc.lock().await.server_tabs.next();
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let (mock, app, _server) = MockServarrApi::get()
+      .returns(queued_events_json)
+      .build_for(SonarrEvent::GetQueuedEvents)
+      .await;
+    app.lock().await.server_tabs.next();
+    let mut network = test_network(&app);
 
     if let SonarrSerdeable::QueueEvents(events) = network
       .handle_sonarr_event(SonarrEvent::GetQueuedEvents)
       .await
       .unwrap()
     {
-      async_server.assert_async().await;
+      mock.assert_async().await;
       assert_eq!(
-        app_arc.lock().await.data.sonarr_data.queued_events.items,
+        app.lock().await.data.sonarr_data.queued_events.items,
         vec![expected_event]
       );
       assert_eq!(events, response);
@@ -233,46 +206,34 @@ mod tests {
     });
     let response: SecurityConfig =
       serde_json::from_value(security_config_response.clone()).unwrap();
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(security_config_response),
-      None,
-      SonarrEvent::GetSecurityConfig,
-      None,
-      None,
-    )
-    .await;
-    app_arc.lock().await.server_tabs.next();
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let (mock, app, _server) = MockServarrApi::get()
+      .returns(security_config_response)
+      .build_for(SonarrEvent::GetSecurityConfig)
+      .await;
+    app.lock().await.server_tabs.next();
+    let mut network = test_network(&app);
 
     if let SonarrSerdeable::SecurityConfig(security_config) = network
       .handle_sonarr_event(SonarrEvent::GetSecurityConfig)
       .await
       .unwrap()
     {
-      async_server.assert_async().await;
+      mock.assert_async().await;
       assert_eq!(security_config, response);
     }
   }
 
   #[tokio::test]
   async fn test_handle_get_status_event() {
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(json!({
+    let (mock, app, _server) = MockServarrApi::get()
+      .returns(json!({
         "version": "v1",
         "startTime": "2023-02-25T20:16:43Z"
-      })),
-      None,
-      SonarrEvent::GetStatus,
-      None,
-      None,
-    )
-    .await;
-    app_arc.lock().await.server_tabs.next();
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+      }))
+      .build_for(SonarrEvent::GetStatus)
+      .await;
+    app.lock().await.server_tabs.next();
+    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
@@ -280,9 +241,9 @@ mod tests {
       .await
       .unwrap()
     {
-      async_server.assert_async().await;
-      assert_str_eq!(app_arc.lock().await.data.sonarr_data.version, "v1");
-      assert_eq!(app_arc.lock().await.data.sonarr_data.start_time, date_time);
+      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);
       assert_eq!(
         status,
         SystemStatus {
@@ -327,27 +288,21 @@ mod tests {
         next_execution: timestamp,
       },
     ];
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(tasks_json),
-      None,
-      SonarrEvent::GetTasks,
-      None,
-      None,
-    )
-    .await;
-    app_arc.lock().await.server_tabs.next();
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let (mock, app, _server) = MockServarrApi::get()
+      .returns(tasks_json)
+      .build_for(SonarrEvent::GetTasks)
+      .await;
+    app.lock().await.server_tabs.next();
+    let mut network = test_network(&app);
 
     if let SonarrSerdeable::Tasks(tasks) = network
       .handle_sonarr_event(SonarrEvent::GetTasks)
       .await
       .unwrap()
     {
-      async_server.assert_async().await;
+      mock.assert_async().await;
       assert_eq!(
-        app_arc.lock().await.data.sonarr_data.tasks.items,
+        app.lock().await.data.sonarr_data.tasks.items,
         expected_tasks
       );
       assert_eq!(tasks, response);
@@ -408,43 +363,44 @@ mod tests {
       * Cool new thing
     Fixed:
       * Some bugs killed
-    
-    
+
+
     3.2.1.0 - 2023-04-15 02:02:53 UTC (Previously Installed)
     {line_break}
     New:
       * Cool new thing (old)
       * Other cool new thing (old)
-    
-    
-    2.1.0 - 2023-04-15 02:02:53 UTC 
+
+
+    2.1.0 - 2023-04-15 02:02:53 UTC
     {line_break}
     Fixed:
       * Killed bug 1
       * Fixed bug 2"
     ));
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(updates_json),
-      None,
-      SonarrEvent::GetUpdates,
-      None,
-      None,
-    )
-    .await;
-    app_arc.lock().await.server_tabs.next();
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let (mock, app, _server) = MockServarrApi::get()
+      .returns(updates_json)
+      .build_for(SonarrEvent::GetUpdates)
+      .await;
+    app.lock().await.server_tabs.next();
+    let mut network = test_network(&app);
 
     if let SonarrSerdeable::Updates(updates) = network
       .handle_sonarr_event(SonarrEvent::GetUpdates)
       .await
       .unwrap()
     {
-      async_server.assert_async().await;
-      assert_str_eq!(
-        app_arc.lock().await.data.sonarr_data.updates.get_text(),
-        expected_text.get_text()
+      mock.assert_async().await;
+      let actual_text = app.lock().await.data.sonarr_data.updates.get_text();
+      let expected = expected_text.get_text();
+
+      // Trim trailing whitespace from each line for comparison
+      let actual_trimmed: Vec<&str> = actual_text.lines().map(|l| l.trim_end()).collect();
+      let expected_trimmed: Vec<&str> = expected.lines().map(|l| l.trim_end()).collect();
+
+      assert_eq!(
+        actual_trimmed, expected_trimmed,
+        "Updates text mismatch (after trimming trailing whitespace)"
       );
       assert_eq!(updates, response);
     }
@@ -453,19 +409,16 @@ mod tests {
   #[tokio::test]
   async fn test_handle_start_sonarr_task_event() {
     let response = json!({ "test": "test"});
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Post,
-      Some(json!({
+    let (mock, app, _server) = MockServarrApi::post()
+      .with_request_body(json!({
         "name": "ApplicationUpdateCheck"
-      })),
-      Some(response.clone()),
-      None,
-      SonarrEvent::StartTask(SonarrTaskName::ApplicationUpdateCheck),
-      None,
-      None,
-    )
-    .await;
-    app_arc
+      }))
+      .returns(response.clone())
+      .build_for(SonarrEvent::StartTask(
+        SonarrTaskName::ApplicationUpdateCheck,
+      ))
+      .await;
+    app
       .lock()
       .await
       .data
@@ -475,8 +428,8 @@ mod tests {
         task_name: SonarrTaskName::default(),
         ..SonarrTask::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::Value(value) = network
       .handle_sonarr_event(SonarrEvent::StartTask(
@@ -485,7 +438,7 @@ mod tests {
       .await
       .unwrap()
     {
-      async_server.assert_async().await;
+      mock.assert_async().await;
       assert_eq!(value, response);
     }
   }