feat: Added initial Sonarr CLI support and the initial network handler setup for the TUI

2024-11-10 21:23:55 -07:00
parent b6f5b9d08c
commit 60d61b9e31
28 changed files with 2419 additions and 761 deletions
@@ -12,9 +12,11 @@ mod tests {
  use tokio::sync::{mpsc, Mutex};
  use tokio_util::sync::CancellationToken;

-  use crate::app::{App, AppConfig, RadarrConfig};
+  use crate::app::{App, AppConfig, ServarrConfig};
  use crate::models::HorizontallyScrollableText;
  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]
@@ -34,12 +36,12 @@ mod tests {
    );
    let mut app = App::default();
    app.is_loading = true;
-    let radarr_config = RadarrConfig {
+    let radarr_config = ServarrConfig {
      host,
      api_token: String::new(),
      port,
      ssl_cert_path: None,
-      ..RadarrConfig::default()
+      ..ServarrConfig::default()
    };
    app.config.radarr = radarr_config;
    let app_arc = Arc::new(Mutex::new(app));
@@ -395,6 +397,214 @@ mod tests {
    async_server.assert_async().await;
  }

+  #[rstest]
+  #[case(RadarrEvent::GetMovies, 7878)]
+  #[case(SonarrEvent::ListSeries, 8989)]
+  #[tokio::test]
+  async fn test_request_props_from_default_config(
+    #[case] network_event: impl Into<NetworkEvent> + NetworkResource,
+    #[case] default_port: u16,
+  ) {
+    let app_arc = Arc::new(Mutex::new(App::default()));
+    let network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let resource = network_event.resource();
+
+    let request_props = network
+      .request_props_from(network_event, RequestMethod::Get, None::<()>, None, None)
+      .await;
+
+    assert_str_eq!(
+      request_props.uri,
+      format!("http://localhost:{default_port}/api/v3{resource}")
+    );
+    assert_eq!(request_props.method, RequestMethod::Get);
+    assert_eq!(request_props.body, None);
+    assert!(request_props.api_token.is_empty());
+  }
+
+  #[rstest]
+  #[tokio::test]
+  async fn test_request_props_from_custom_config(
+    #[values(RadarrEvent::GetMovies, SonarrEvent::ListSeries)] network_event: impl Into<NetworkEvent>
+      + NetworkResource,
+  ) {
+    let api_token = "testToken1234".to_owned();
+    let app_arc = Arc::new(Mutex::new(App::default()));
+    let resource = network_event.resource();
+    let servarr_config = ServarrConfig {
+      host: Some("192.168.0.123".to_owned()),
+      port: Some(8080),
+      api_token: api_token.clone(),
+      ssl_cert_path: Some("/test/cert.crt".to_owned()),
+      ..ServarrConfig::default()
+    };
+    {
+      let mut app = app_arc.lock().await;
+      app.config.radarr = servarr_config.clone();
+      app.config.sonarr = servarr_config;
+    }
+    let network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+
+    let request_props = network
+      .request_props_from(network_event, RequestMethod::Get, None::<()>, None, None)
+      .await;
+
+    assert_str_eq!(
+      request_props.uri,
+      format!("https://192.168.0.123:8080/api/v3{resource}")
+    );
+    assert_eq!(request_props.method, RequestMethod::Get);
+    assert_eq!(request_props.body, None);
+    assert_str_eq!(request_props.api_token, api_token);
+  }
+
+  #[rstest]
+  #[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,
+  ) {
+    let api_token = "testToken1234".to_owned();
+    let app_arc = Arc::new(Mutex::new(App::default()));
+    let resource = network_event.resource();
+    let servarr_config = ServarrConfig {
+      uri: Some("https://192.168.0.123:8080".to_owned()),
+      api_token: api_token.clone(),
+      ..ServarrConfig::default()
+    };
+    {
+      let mut app = app_arc.lock().await;
+      app.config.radarr = servarr_config.clone();
+      app.config.sonarr = servarr_config;
+    }
+    let network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+
+    let request_props = network
+      .request_props_from(network_event, RequestMethod::Get, None::<()>, None, None)
+      .await;
+
+    assert_str_eq!(
+      request_props.uri,
+      format!("https://192.168.0.123:8080/api/v3{resource}")
+    );
+    assert_eq!(request_props.method, RequestMethod::Get);
+    assert_eq!(request_props.body, None);
+    assert_str_eq!(request_props.api_token, api_token);
+  }
+
+  #[rstest]
+  #[case(RadarrEvent::GetMovies, 7878)]
+  #[case(SonarrEvent::ListSeries, 8989)]
+  #[tokio::test]
+  async fn test_request_props_from_default_config_with_path_and_query_params(
+    #[case] network_event: impl Into<NetworkEvent> + NetworkResource,
+    #[case] default_port: u16,
+  ) {
+    let app_arc = Arc::new(Mutex::new(App::default()));
+    let network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+    let resource = network_event.resource();
+
+    let request_props = network
+      .request_props_from(
+        network_event,
+        RequestMethod::Get,
+        None::<()>,
+        Some("/test".to_owned()),
+        Some("id=1".to_owned()),
+      )
+      .await;
+
+    assert_str_eq!(
+      request_props.uri,
+      format!("http://localhost:{default_port}/api/v3{resource}/test?id=1")
+    );
+    assert_eq!(request_props.method, RequestMethod::Get);
+    assert_eq!(request_props.body, None);
+    assert!(request_props.api_token.is_empty());
+  }
+
+  #[rstest]
+  #[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,
+  ) {
+    let api_token = "testToken1234".to_owned();
+    let app_arc = Arc::new(Mutex::new(App::default()));
+    let resource = network_event.resource();
+    let servarr_config = ServarrConfig {
+      host: Some("192.168.0.123".to_owned()),
+      port: Some(8080),
+      api_token: api_token.clone(),
+      ssl_cert_path: Some("/test/cert.crt".to_owned()),
+      ..ServarrConfig::default()
+    };
+    {
+      let mut app = app_arc.lock().await;
+      app.config.radarr = servarr_config.clone();
+      app.config.sonarr = servarr_config;
+    }
+    let network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+
+    let request_props = network
+      .request_props_from(
+        network_event,
+        RequestMethod::Get,
+        None::<()>,
+        Some("/test".to_owned()),
+        Some("id=1".to_owned()),
+      )
+      .await;
+
+    assert_str_eq!(
+      request_props.uri,
+      format!("https://192.168.0.123:8080/api/v3{resource}/test?id=1")
+    );
+    assert_eq!(request_props.method, RequestMethod::Get);
+    assert_eq!(request_props.body, None);
+    assert_str_eq!(request_props.api_token, api_token);
+  }
+
+  #[rstest]
+  #[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,
+  ) {
+    let api_token = "testToken1234".to_owned();
+    let app_arc = Arc::new(Mutex::new(App::default()));
+    let resource = network_event.resource();
+    let servarr_config = ServarrConfig {
+      uri: Some("https://192.168.0.123:8080".to_owned()),
+      api_token: api_token.clone(),
+      ..ServarrConfig::default()
+    };
+    {
+      let mut app = app_arc.lock().await;
+      app.config.radarr = servarr_config.clone();
+      app.config.sonarr = servarr_config;
+    }
+    let network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+
+    let request_props = network
+      .request_props_from(
+        network_event,
+        RequestMethod::Get,
+        None::<()>,
+        Some("/test".to_owned()),
+        Some("id=1".to_owned()),
+      )
+      .await;
+
+    assert_str_eq!(
+      request_props.uri,
+      format!("https://192.168.0.123:8080/api/v3{resource}/test?id=1")
+    );
+    assert_eq!(request_props.method, RequestMethod::Get);
+    assert_eq!(request_props.body, None);
+    assert_str_eq!(request_props.api_token, api_token);
+  }
+
  #[derive(Clone, Serialize, Deserialize, Debug, Default, PartialEq, Eq)]
  struct Test {
    pub value: String,
@@ -425,3 +635,78 @@ mod tests {
    (async_server, app_arc, server)
  }
 }
+
+#[cfg(test)]
+pub(in crate::network) mod test_utils {
+  use std::sync::Arc;
+
+  use mockito::{Matcher, Mock, Server, ServerGuard};
+  use serde_json::Value;
+  use tokio::sync::Mutex;
+
+  use crate::{
+    app::{App, ServarrConfig},
+    network::{NetworkEvent, NetworkResource, RequestMethod},
+  };
+
+  pub async fn mock_servarr_api<'a>(
+    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}");
+
+    if let Some(path) = path {
+      uri = format!("{uri}{path}");
+    }
+
+    if let Some(params) = query_params {
+      uri = format!("{uri}?{params}");
+    }
+
+    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));
+    }
+
+    if let Some(body) = response_body {
+      async_server = async_server.with_body(body.to_string());
+    }
+
+    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::default();
+    let servarr_config = ServarrConfig {
+      host,
+      port,
+      api_token: "test1234".to_owned(),
+      ..ServarrConfig::default()
+    };
+
+    match network_event.into() {
+      NetworkEvent::Radarr(_) => app.config.radarr = servarr_config,
+      NetworkEvent::Sonarr(_) => app.config.sonarr = servarr_config,
+    }
+
+    let app_arc = Arc::new(Mutex::new(app));
+
+    (async_server, app_arc, server)
+  }
+}