chore: release v0.1.5

Added HTTPS support for all Servarrs
Merge pull request #5 from Dark-Alex-17/release-plz-2024-11-01T19-06-52Z
2024-11-03 00:33:11 +00:00 · 2024-11-02 18:32:44 -06:00 · 2024-11-01 13:13:03 -06:00 · 2024-11-01 19:06:53 +00:00 · 2024-11-01 13:02:39 -06:00 · 2024-10-31 15:53:08 -06:00
16 changed files with 555 additions and 149 deletions
@@ -1,7 +1,7 @@
 # Adapted from https://github.com/joshka/github-workflows/blob/main/.github/workflows/rust-release-plz.yml
 # Thanks to joshka for permission to use this template!

-name: Create Release PR and publish to crates.io
+name: Create Release PR and Publish Release

 permissions:
  pull-requests: write
@@ -7,6 +7,19 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0

 ## [Unreleased]

+## [0.1.5](https://github.com/Dark-Alex-17/managarr/compare/v0.1.4...v0.1.5) - 2024-11-03
+
+### Other
+
+- Added HTTPS support for all Servarrs
+
+## [0.1.4](https://github.com/Dark-Alex-17/managarr/compare/v0.1.3...v0.1.4) - 2024-11-01
+
+### Other
+
+- Added the ability to fetch host configs and security configs to the CLI
+- Updated README to be more clear about what features are supported [skip ci]
+
 ## [0.1.2](https://github.com/Dark-Alex-17/managarr/compare/v0.1.1...v0.1.2) - 2024-10-30

 ### Other
@@ -1148,7 +1148,7 @@ dependencies = [

 [[package]]
 name = "managarr"
-version = "0.1.3"
+version = "0.1.5"
 dependencies = [
 "anyhow",
 "assert_cmd",
@@ -1,6 +1,6 @@
 [package]
 name = "managarr"
-version = "0.1.3"
+version = "0.1.5"
 authors = ["Alex Clarke <alex.j.tusa@gmail.com>"]
 description = "A TUI and CLI to manage your Servarrs"
 keywords = ["managarr", "tui-rs", "dashboard", "servarr", "tui"]
@@ -17,14 +17,14 @@ Managarr is a TUI and CLI to help you manage your HTPC (Home Theater PC). Built

 ## What Servarrs are supported?

- ![radarr_logo](logos/radarr.png) [Radarr](https://wiki.servarr.com/radarr)
- ![sonarr_logo](logos/sonarr.png) [Sonarr](https://wiki.servarr.com/en/sonarr)
- ![readarr_logo](logos/readarr.png) [Readarr](https://wiki.servarr.com/en/readarr)
- ![lidarr_logo](logos/lidarr.png) [Lidarr](https://wiki.servarr.com/en/lidarr)
- ![prowlarr_logo](logos/prowlarr.png) [Prowlarr](https://wiki.servarr.com/en/prowlarr)
- ![whisparr_logo](logos/whisparr.png) [Whisparr](https://wiki.servarr.com/whisparr)
- ![bazarr_logo](logos/bazarr.png) [Bazarr](https://www.bazarr.media/)
- ![tautulli_logo](logos/tautulli.png) [Tautulli](https://tautulli.com/)
+- [x] ![radarr_logo](logos/radarr.png) [Radarr](https://wiki.servarr.com/radarr)
+- [ ] ![sonarr_logo](logos/sonarr.png) [Sonarr](https://wiki.servarr.com/en/sonarr)
+- [ ] ![readarr_logo](logos/readarr.png) [Readarr](https://wiki.servarr.com/en/readarr)
+- [ ] ![lidarr_logo](logos/lidarr.png) [Lidarr](https://wiki.servarr.com/en/lidarr)
+- [ ] ![prowlarr_logo](logos/prowlarr.png) [Prowlarr](https://wiki.servarr.com/en/prowlarr)
+- [ ] ![whisparr_logo](logos/whisparr.png) [Whisparr](https://wiki.servarr.com/whisparr)
+- [ ] ![bazarr_logo](logos/bazarr.png) [Bazarr](https://www.bazarr.media/)
+- [ ] ![tautulli_logo](logos/tautulli.png) [Tautulli](https://tautulli.com/)

 ## Try Before You Buy
 To try out Managarr before linking it to your HTPC, you can use the purpose built [managarr-demo](https://github.com/Dark-Alex-17/managarr-demo) repository.
@@ -60,6 +60,7 @@ You can also clone this repo and run `make docker` to build a docker image local
 - [x] View your library, downloads, collections, and blocklist
 - [x] View details of a specific movie including description, history, downloaded file info, or the credits
 - [x] View details of any collection and the movies in them
+- [x] View your host and security configs from the CLI to programmatically fetch the API token, among other settings
 - [x] Search your library or collections
 - [x] Add movies to your library
 - [x] Delete movies, downloads, and indexers
@@ -103,7 +104,8 @@ You can also clone this repo and run `make docker` to build a docker image local
 ### The Managarr CLI
 Managarr can be used in one of two ways: As a TUI, or as a CLI for managing your Servarrs. 

-All management features available in the TUI are also available in the CLI.
+All management features available in the TUI are also available in the CLI. However, the CLI is
+equipped with additional features to allow for more advanced usage and automation.

 The CLI can be helpful for automating tasks or for use in scripts. For example, you can use the CLI to trigger a search for a movie, or to add a movie to your library.

@@ -111,12 +113,12 @@ To see all available commands, simply run `managarr --help`:

 ```shell
 $ managarr --help
-managarr 0.0.36
+managarr 0.1.3
 Alex Clarke <alex.j.tusa@gmail.com>

 A TUI and CLI to manage your Servarrs

-Usage: managarr [COMMAND]
+Usage: managarr [OPTIONS] [COMMAND]

 Commands:
  radarr       Commands for manging your Radarr instance
@@ -124,8 +126,10 @@ Commands:
  help         Print this message or the help of the given subcommand(s)

 Options:
-  -h, --help     Print help
-  -V, --version  Print version
+      --config <CONFIG>               The Managarr configuration file to use
+      --disable-terminal-size-checks  Disable the terminal size checks
+  -h, --help                          Print help
+  -V, --version                       Print version
 ```

 All subcommands also have detailed help menus to show you how to use them. For example, to see all available commands for Radarr, you would run:
@@ -134,7 +138,7 @@ All subcommands also have detailed help menus to show you how to use them. For e
 $ managarr radarr --help
 Commands for manging your Radarr instance

-Usage: managarr radarr <COMMAND>
+Usage: managarr radarr [OPTIONS] <COMMAND>

 Commands:
  add                       Commands to add or create new resources within your Radarr instance
@@ -154,7 +158,9 @@ Commands:
  help                      Print this message or the help of the given subcommand(s)

 Options:
-  -h, --help  Print help
+      --config <CONFIG>               The Managarr configuration file to use
+      --disable-terminal-size-checks  Disable the terminal size checks
+  -h, --help                          Print help
 ```

 **Pro Tip:** The CLI is even more powerful and useful when used in conjunction with the `jq` CLI tool. This allows you to parse the JSON response from the Managarr CLI and use it in your scripts; For example, to extract the `movieId` of the movie "Ad Astra", you would run:
@@ -185,7 +191,7 @@ $HOME/Library/Application Support/managarr/config.yml
 %APPDATA%/Roaming/managarr/config.yml
 ```

-## Specify Configuration File
+## Specify Which Configuration File to Use
 It can sometimes be useful to specify the configuration file you wish to use. This is useful in cases
 where you may have more than one instance of a given Servarr running. Thus, you can specify the 
 config file using the `--config` flag:
@@ -200,6 +206,8 @@ radarr:
  host: 127.0.0.1
  port: 7878
  api_token: someApiToken1234567890
+  use_ssl: true
+  ssl_cert_path: /path/to/radarr.crt
 sonarr:
  host: 127.0.0.1
  port: 8989
@@ -208,26 +216,32 @@ readarr:
  host: 127.0.0.1
  port: 8787
  api_token: someApiToken1234567890
+  use_ssl: false
 lidarr:
  host: 127.0.0.1
  port: 8686
  api_token: someApiToken1234567890
+  use_ssl: false
 whisparr:
  host: 127.0.0.1
  port: 6969
  api_token: someApiToken1234567890
+  use_ssl: false
 bazarr:
  host: 127.0.0.1
  port: 6767
  api_token: someApiToken1234567890
+  use_ssl: false
 prowlarr:
  host: 127.0.0.1
  port: 9696
  api_token: someApiToken1234567890
+  use_ssl: false
 tautulli:
  host: 127.0.0.1
  port: 8181
  api_token: someApiToken1234567890
+  use_ssl: false
 ```

 ## Track My Progress for the Beta release (With Sonarr Support!)
@@ -224,5 +224,7 @@ mod tests {
    assert_str_eq!(radarr_config.host, "localhost");
    assert_eq!(radarr_config.port, Some(7878));
    assert!(radarr_config.api_token.is_empty());
+    assert!(!radarr_config.use_ssl);
+    assert_eq!(radarr_config.ssl_cert_path, None);
  }
 }
@@ -176,6 +176,9 @@ pub struct RadarrConfig {
  pub host: String,
  pub port: Option<u16>,
  pub api_token: String,
+  #[serde(default)]
+  pub use_ssl: bool,
+  pub ssl_cert_path: Option<String>,
 }

 impl Default for RadarrConfig {
@@ -184,6 +187,8 @@ impl Default for RadarrConfig {
      host: "localhost".to_string(),
      port: Some(7878),
      api_token: "".to_string(),
+      use_ssl: false,
+      ssl_cert_path: None,
    }
  }
 }
@@ -21,6 +21,8 @@ mod get_command_handler_tests;
 pub enum RadarrGetCommand {
  #[command(about = "Get the shared settings for all indexers")]
  AllIndexerSettings,
+  #[command(about = "Fetch the host config for your Radarr instance")]
+  HostConfig,
  #[command(about = "Get detailed information for the movie with the given ID")]
  MovieDetails {
    #[arg(
@@ -39,6 +41,8 @@ pub enum RadarrGetCommand {
    )]
    movie_id: i64,
  },
+  #[command(about = "Fetch the security config for your Radarr instance")]
+  SecurityConfig,
  #[command(about = "Get the system status")]
  SystemStatus,
 }
@@ -73,12 +77,18 @@ impl<'a, 'b> CliCommandHandler<'a, 'b, RadarrGetCommand> for RadarrGetCommandHan
      RadarrGetCommand::AllIndexerSettings => {
        execute_network_event!(self, RadarrEvent::GetAllIndexerSettings);
      }
+      RadarrGetCommand::HostConfig => {
+        execute_network_event!(self, RadarrEvent::GetHostConfig);
+      }
      RadarrGetCommand::MovieDetails { movie_id } => {
        execute_network_event!(self, RadarrEvent::GetMovieDetails(Some(movie_id)));
      }
      RadarrGetCommand::MovieHistory { movie_id } => {
        execute_network_event!(self, RadarrEvent::GetMovieHistory(Some(movie_id)));
      }
+      RadarrGetCommand::SecurityConfig => {
+        execute_network_event!(self, RadarrEvent::GetSecurityConfig);
+      }
      RadarrGetCommand::SystemStatus => {
        execute_network_event!(self, RadarrEvent::GetStatus);
      }
@@ -29,6 +29,14 @@ mod test {
      assert!(result.is_ok());
    }

+    #[test]
+    fn test_get_host_config_has_no_arg_requirements() {
+      let result =
+        Cli::command().try_get_matches_from(["managarr", "radarr", "get", "host-config"]);
+
+      assert!(result.is_ok());
+    }
+
    #[test]
    fn test_movie_details_requires_movie_id() {
      let result =
@@ -81,6 +89,14 @@ mod test {
      assert!(result.is_ok());
    }

+    #[test]
+    fn test_get_security_config_has_no_arg_requirements() {
+      let result =
+        Cli::command().try_get_matches_from(["managarr", "radarr", "get", "security-config"]);
+
+      assert!(result.is_ok());
+    }
+
    #[test]
    fn test_system_status_has_no_arg_requirements() {
      let result =
@@ -135,6 +151,29 @@ mod test {
      assert!(result.is_ok());
    }

+    #[tokio::test]
+    async fn test_handle_get_host_config_command() {
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(RadarrEvent::GetHostConfig.into()))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Radarr(RadarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::default()));
+      let get_host_config_command = RadarrGetCommand::HostConfig;
+
+      let result =
+        RadarrGetCommandHandler::with(&app_arc, get_host_config_command, &mut mock_network)
+          .handle()
+          .await;
+
+      assert!(result.is_ok());
+    }
+
    #[tokio::test]
    async fn test_handle_get_movie_details_command() {
      let expected_movie_id = 1;
@@ -187,6 +226,29 @@ mod test {
      assert!(result.is_ok());
    }

+    #[tokio::test]
+    async fn test_handle_get_security_config_command() {
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(RadarrEvent::GetSecurityConfig.into()))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Radarr(RadarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::default()));
+      let get_security_config_command = RadarrGetCommand::SecurityConfig;
+
+      let result =
+        RadarrGetCommandHandler::with(&app_arc, get_security_config_command, &mut mock_network)
+          .handle()
+          .await;
+
+      assert!(result.is_ok());
+    }
+
    #[tokio::test]
    async fn test_handle_get_system_status_command() {
      let mut mock_network = MockNetworkTrait::new();
@@ -1,6 +1,6 @@
 #![warn(rust_2018_idioms)]

-use std::fs::File;
+use std::fs::{self, File};
 use std::io::BufReader;
 use std::panic::PanicHookInfo;
 use std::path::PathBuf;
@@ -24,6 +24,7 @@ use log::error;
 use network::NetworkTrait;
 use ratatui::backend::CrosstermBackend;
 use ratatui::Terminal;
+use reqwest::{Certificate, Client};
 use tokio::sync::mpsc::Receiver;
 use tokio::sync::{mpsc, Mutex};
 use tokio_util::sync::CancellationToken;
@@ -77,13 +78,6 @@ struct Cli {
  disable_terminal_size_checks: bool,
 }

-fn load_config(path: &str) -> Result<AppConfig> {
-  let file = File::open(path).map_err(|e| anyhow!(e))?;
-  let reader = BufReader::new(file);
-  let config = serde_yaml::from_reader(reader)?;
-  Ok(config)
-}
-
 #[tokio::main]
 async fn main() -> Result<()> {
  log4rs::init_config(utils::init_logging_config())?;
@@ -98,6 +92,7 @@ async fn main() -> Result<()> {
  } else {
    confy::load("managarr", "config")?
  };
+  let reqwest_client = build_network_client(&config);
  let (sync_network_tx, sync_network_rx) = mpsc::channel(500);
  let cancellation_token = CancellationToken::new();
  let ctrlc_cancellation_token = cancellation_token.clone();
@@ -119,7 +114,7 @@ async fn main() -> Result<()> {
    Some(command) => match command {
      Command::Radarr(_) => {
        let app_nw = Arc::clone(&app);
-        let mut network = Network::new(&app_nw, cancellation_token);
+        let mut network = Network::new(&app_nw, cancellation_token, reqwest_client);

        if let Err(e) = cli::handle_command(&app, command, &mut network).await {
          eprintln!("error: {}", e.to_string().red());
@@ -133,7 +128,9 @@ async fn main() -> Result<()> {
    },
    None => {
      let app_nw = Arc::clone(&app);
-      std::thread::spawn(move || start_networking(sync_network_rx, &app_nw, cancellation_token));
+      std::thread::spawn(move || {
+        start_networking(sync_network_rx, &app_nw, cancellation_token, reqwest_client)
+      });
      start_ui(&app, !args.disable_terminal_size_checks).await?;
    }
  }
@@ -146,8 +143,9 @@ async fn start_networking(
  mut network_rx: Receiver<NetworkEvent>,
  app: &Arc<Mutex<App<'_>>>,
  cancellation_token: CancellationToken,
+  client: Client,
 ) {
-  let mut network = Network::new(app, cancellation_token);
+  let mut network = Network::new(app, cancellation_token, client);

  while let Some(network_event) = network_rx.recv().await {
    if let Err(e) = network.handle_network_event(network_event).await {
@@ -238,6 +236,60 @@ fn panic_hook(info: &PanicHookInfo<'_>) {
  .unwrap();
 }

+fn load_config(path: &str) -> Result<AppConfig> {
+  let file = File::open(path).map_err(|e| anyhow!(e))?;
+  let reader = BufReader::new(file);
+  let config = serde_yaml::from_reader(reader)?;
+  Ok(config)
+}
+
+fn build_network_client(config: &AppConfig) -> Client {
+  let mut client_builder = Client::builder();
+
+  if config.radarr.use_ssl {
+    let cert = add_cert_to_builder(config.radarr.ssl_cert_path.clone(), "Radarr");
+    client_builder = client_builder.add_root_certificate(cert);
+  }
+
+  match client_builder.build() {
+    Ok(client) => client,
+    Err(e) => {
+      error!("Unable to create reqwest client: {}", e);
+      eprintln!("error: {}", e.to_string().red());
+      process::exit(1);
+    }
+  }
+}
+
+fn add_cert_to_builder(cert_path: Option<String>, servarr_name: &str) -> Certificate {
+  let err = |error: String| {
+    error!("{}", error);
+    eprintln!("error: {}", error.red());
+    process::exit(1);
+  };
+
+  if cert_path.is_none() {
+    err(format!(
+      "A {} cert path is required when 'use_ssl' is 'true'",
+      servarr_name
+    ));
+  }
+
+  match fs::read(cert_path.unwrap()) {
+    Ok(cert) => match Certificate::from_pem(&cert) {
+      Ok(certificate) => certificate,
+      Err(_) => err(format!(
+        "Unable to read the specified {} SSL certificate",
+        servarr_name
+      )),
+    },
+    Err(_) => err(format!(
+      "Unable to open specified {} SSL certificate",
+      servarr_name
+    )),
+  }
+}
+
 #[cfg(not(debug_assertions))]
 fn panic_hook(info: &PanicHookInfo<'_>) {
  use human_panic::{handle_dump, print_msg, Metadata};
@@ -57,6 +57,44 @@ pub struct AddRootFolderBody {
  pub path: String,
 }

+#[derive(Serialize, Deserialize, Default, PartialEq, Eq, Clone, Copy, Debug, ValueEnum)]
+#[serde(rename_all = "camelCase")]
+pub enum AuthenticationMethod {
+  #[default]
+  Basic,
+  Forms,
+  None,
+}
+
+impl Display for AuthenticationMethod {
+  fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+    let authentication_method = match self {
+      AuthenticationMethod::Basic => "basic",
+      AuthenticationMethod::Forms => "forms",
+      AuthenticationMethod::None => "none",
+    };
+    write!(f, "{authentication_method}")
+  }
+}
+
+#[derive(Serialize, Deserialize, Default, PartialEq, Eq, Clone, Copy, Debug, ValueEnum)]
+#[serde(rename_all = "camelCase")]
+pub enum AuthenticationRequired {
+  Enabled,
+  #[default]
+  DisabledForLocalAddresses,
+}
+
+impl Display for AuthenticationRequired {
+  fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+    let authentication_required = match self {
+      AuthenticationRequired::Enabled => "enabled",
+      AuthenticationRequired::DisabledForLocalAddresses => "disabledForLocalAddresses",
+    };
+    write!(f, "{authentication_required}")
+  }
+}
+
 #[derive(Default, Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
 pub struct BlocklistResponse {
  pub records: Vec<BlocklistItem>,
@@ -85,6 +123,26 @@ pub struct BlocklistItemMovie {
  pub title: HorizontallyScrollableText,
 }

+#[derive(Serialize, Deserialize, Default, PartialEq, Eq, Clone, Copy, Debug, ValueEnum)]
+#[serde(rename_all = "camelCase")]
+pub enum CertificateValidation {
+  #[default]
+  Enabled,
+  DisabledForLocalAddresses,
+  Disabled,
+}
+
+impl Display for CertificateValidation {
+  fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+    let certificate_validation = match self {
+      CertificateValidation::Enabled => "enabled",
+      CertificateValidation::DisabledForLocalAddresses => "disabledForLocalAddresses",
+      CertificateValidation::Disabled => "disabled",
+    };
+    write!(f, "{certificate_validation}")
+  }
+}
+
 #[derive(Serialize, Deserialize, Derivative, Default, Clone, Debug, PartialEq, Eq)]
 #[serde(rename_all = "camelCase")]
 pub struct Collection {
@@ -223,6 +281,22 @@ pub struct EditMovieParams {
  pub clear_tags: bool,
 }

+#[derive(Default, Deserialize, Serialize, Debug, Clone, Eq, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct HostConfig {
+  pub bind_address: HorizontallyScrollableText,
+  #[serde(deserialize_with = "super::from_i64")]
+  pub port: i64,
+  pub url_base: Option<HorizontallyScrollableText>,
+  pub instance_name: Option<HorizontallyScrollableText>,
+  pub application_url: Option<HorizontallyScrollableText>,
+  pub enable_ssl: bool,
+  #[serde(deserialize_with = "super::from_i64")]
+  pub ssl_port: i64,
+  pub ssl_cert_path: Option<String>,
+  pub ssl_cert_password: Option<String>,
+}
+
 #[derive(Default, Deserialize, Serialize, Debug, Clone, Eq, PartialEq)]
 #[serde(rename_all = "camelCase")]
 pub struct Indexer {
@@ -560,6 +634,17 @@ pub struct RootFolder {
  pub unmapped_folders: Option<Vec<UnmappedFolder>>,
 }

+#[derive(Default, Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct SecurityConfig {
+  pub authentication_method: AuthenticationMethod,
+  pub authentication_required: AuthenticationRequired,
+  pub username: String,
+  pub password: Option<String>,
+  pub api_key: String,
+  pub certificate_validation: CertificateValidation,
+}
+
 #[derive(Default, Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
 #[serde(rename_all = "camelCase")]
 pub struct SystemStatus {
@@ -647,6 +732,7 @@ pub enum RadarrSerdeable {
  Credits(Vec<Credit>),
  DiskSpaces(Vec<DiskSpace>),
  DownloadsResponse(DownloadsResponse),
+  HostConfig(HostConfig),
  Indexers(Vec<Indexer>),
  IndexerSettings(IndexerSettings),
  LogResponse(LogResponse),
@@ -657,6 +743,7 @@ pub enum RadarrSerdeable {
  QueueEvents(Vec<QueueEvent>),
  Releases(Vec<Release>),
  RootFolders(Vec<RootFolder>),
+  SecurityConfig(SecurityConfig),
  SystemStatus(SystemStatus),
  Tags(Vec<Tag>),
  Tasks(Vec<Task>),
@@ -686,6 +773,7 @@ serde_enum_from!(
    Credits(Vec<Credit>),
    DiskSpaces(Vec<DiskSpace>),
    DownloadsResponse(DownloadsResponse),
+    HostConfig(HostConfig),
    Indexers(Vec<Indexer>),
    IndexerSettings(IndexerSettings),
    LogResponse(LogResponse),
@@ -696,6 +784,7 @@ serde_enum_from!(
    QueueEvents(Vec<QueueEvent>),
    Releases(Vec<Release>),
    RootFolders(Vec<RootFolder>),
+    SecurityConfig(SecurityConfig),
    SystemStatus(SystemStatus),
    Tags(Vec<Tag>),
    Tasks(Vec<Task>),
@@ -5,14 +5,41 @@ mod tests {

  use crate::models::{
    radarr_models::{
-      AddMovieSearchResult, BlocklistItem, BlocklistResponse, Collection, Credit, DiskSpace,
-      DownloadRecord, DownloadsResponse, Indexer, IndexerSettings, IndexerTestResult, Log,
-      LogResponse, MinimumAvailability, Monitor, Movie, MovieHistoryItem, QualityProfile,
-      QueueEvent, RadarrSerdeable, Release, RootFolder, SystemStatus, Tag, Task, TaskName, Update,
+      AddMovieSearchResult, AuthenticationMethod, AuthenticationRequired, BlocklistItem,
+      BlocklistResponse, CertificateValidation, Collection, Credit, DiskSpace, DownloadRecord,
+      DownloadsResponse, Indexer, IndexerSettings, IndexerTestResult, Log, LogResponse,
+      MinimumAvailability, Monitor, Movie, MovieHistoryItem, QualityProfile, QueueEvent,
+      RadarrSerdeable, Release, RootFolder, SystemStatus, Tag, Task, TaskName, Update,
    },
    Serdeable,
  };

+  #[test]
+  fn test_authentication_method_display() {
+    assert_str_eq!(AuthenticationMethod::Basic.to_string(), "basic");
+    assert_str_eq!(AuthenticationMethod::Forms.to_string(), "forms");
+    assert_str_eq!(AuthenticationMethod::None.to_string(), "none");
+  }
+
+  #[test]
+  fn test_authentication_required_display() {
+    assert_str_eq!(AuthenticationRequired::Enabled.to_string(), "enabled");
+    assert_str_eq!(
+      AuthenticationRequired::DisabledForLocalAddresses.to_string(),
+      "disabledForLocalAddresses"
+    );
+  }
+
+  #[test]
+  fn test_certificate_validation_display() {
+    assert_str_eq!(CertificateValidation::Enabled.to_string(), "enabled");
+    assert_str_eq!(
+      CertificateValidation::DisabledForLocalAddresses.to_string(),
+      "disabledForLocalAddresses"
+    );
+    assert_str_eq!(CertificateValidation::Disabled.to_string(), "disabled");
+  }
+
  #[test]
  fn test_task_name_display() {
    assert_str_eq!(
@@ -62,9 +62,13 @@ impl<'a, 'b> NetworkTrait for Network<'a, 'b> {
 }

 impl<'a, 'b> Network<'a, 'b> {
-  pub fn new(app: &'a Arc<Mutex<App<'b>>>, cancellation_token: CancellationToken) -> Self {
+  pub fn new(
+    app: &'a Arc<Mutex<App<'b>>>,
+    cancellation_token: CancellationToken,
+    client: Client,
+  ) -> Self {
    Network {
-      client: Client::new(),
+      client,
      app,
      cancellation_token,
    }
@@ -6,6 +6,7 @@ mod tests {

  use mockito::{Mock, Server, ServerGuard};
  use pretty_assertions::assert_str_eq;
+  use reqwest::Client;
  use rstest::rstest;
  use serde::{Deserialize, Serialize};
  use tokio::sync::{mpsc, Mutex};
@@ -37,10 +38,12 @@ mod tests {
      host,
      api_token: String::new(),
      port,
+      use_ssl: false,
+      ssl_cert_path: None,
    };
    app.config.radarr = radarr_config;
    let app_arc = Arc::new(Mutex::new(app));
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    let _ = network
      .handle_network_event(RadarrEvent::HealthCheck.into())
@@ -64,7 +67,7 @@ mod tests {
      .create_async()
      .await;
    let app_arc = Arc::new(Mutex::new(App::default()));
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    let _ = network
      .handle_request::<Test, ()>(
@@ -90,7 +93,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());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    let resp = network
      .handle_request::<(), Test>(
@@ -122,7 +125,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());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
    let mut test_result = String::new();

    let resp = network
@@ -160,7 +163,7 @@ mod tests {
      cancellation_token.clone(),
    )));
    app_arc.lock().await.is_loading = true;
-    let mut network = Network::new(&app_arc, cancellation_token);
+    let mut network = Network::new(&app_arc, cancellation_token, Client::new());
    network.cancellation_token.cancel();

    let resp = network
@@ -194,7 +197,7 @@ mod tests {
      .create_async()
      .await;
    let app_arc = Arc::new(Mutex::new(App::default()));
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    let resp = network
      .handle_request::<(), Test>(
@@ -226,7 +229,7 @@ mod tests {
  #[tokio::test]
  async fn test_handle_request_failure_to_send_request() {
    let app_arc = Arc::new(Mutex::new(App::default()));
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    let resp = network
      .handle_request::<(), Test>(
@@ -266,7 +269,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());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    let resp = network
      .handle_request::<(), Test>(
@@ -296,7 +299,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());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    let resp = network
      .handle_request::<(), Test>(
@@ -354,7 +357,7 @@ mod tests {

    async_server = async_server.create_async().await;
    let app_arc = Arc::new(Mutex::new(App::default()));
-    let network = Network::new(&app_arc, CancellationToken::new());
+    let network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    network
      .call_api(RequestProps {
@@ -11,10 +11,10 @@ use crate::app::RadarrConfig;
 use crate::models::radarr_models::{
  AddMovieBody, AddMovieSearchResult, AddOptions, AddRootFolderBody, BlocklistResponse, Collection,
  CollectionMovie, CommandBody, Credit, CreditType, DeleteMovieParams, DiskSpace, DownloadRecord,
-  DownloadsResponse, EditCollectionParams, EditIndexerParams, EditMovieParams, Indexer,
+  DownloadsResponse, EditCollectionParams, EditIndexerParams, EditMovieParams, HostConfig, Indexer,
  IndexerSettings, IndexerTestResult, LogResponse, Movie, MovieCommandBody, MovieHistoryItem,
  QualityProfile, QueueEvent, RadarrSerdeable, Release, ReleaseDownloadBody, RootFolder,
-  SystemStatus, Tag, Task, TaskName, Update,
+  SecurityConfig, SystemStatus, Tag, Task, TaskName, Update,
 };
 use crate::models::servarr_data::radarr::modals::{
  AddMovieModal, EditCollectionModal, EditIndexerModal, EditMovieModal, IndexerTestResultModalItem,
@@ -50,6 +50,7 @@ pub enum RadarrEvent {
  GetBlocklist,
  GetCollections,
  GetDownloads,
+  GetHostConfig,
  GetIndexers,
  GetAllIndexerSettings,
  GetLogs(Option<u64>),
@@ -62,6 +63,7 @@ pub enum RadarrEvent {
  GetQueuedEvents,
  GetReleases(Option<i64>),
  GetRootFolders,
+  GetSecurityConfig,
  GetStatus,
  GetTags,
  GetTasks,
@@ -86,6 +88,7 @@ impl RadarrEvent {
      RadarrEvent::GetBlocklist => "/blocklist?page=1&pageSize=10000",
      RadarrEvent::GetCollections | RadarrEvent::EditCollection(_) => "/collection",
      RadarrEvent::GetDownloads | RadarrEvent::DeleteDownload(_) => "/queue",
+      RadarrEvent::GetHostConfig | RadarrEvent::GetSecurityConfig => "/config/host",
      RadarrEvent::GetIndexers | RadarrEvent::EditIndexer(_) | RadarrEvent::DeleteIndexer(_) => {
        "/indexer"
      }
@@ -179,14 +182,15 @@ impl<'a, 'b> Network<'a, 'b> {
        self.edit_indexer(params).await.map(RadarrSerdeable::from)
      }
      RadarrEvent::EditMovie(params) => self.edit_movie(params).await.map(RadarrSerdeable::from),
-      RadarrEvent::GetBlocklist => self.get_blocklist().await.map(RadarrSerdeable::from),
-      RadarrEvent::GetCollections => self.get_collections().await.map(RadarrSerdeable::from),
-      RadarrEvent::GetDownloads => self.get_downloads().await.map(RadarrSerdeable::from),
-      RadarrEvent::GetIndexers => self.get_indexers().await.map(RadarrSerdeable::from),
      RadarrEvent::GetAllIndexerSettings => self
        .get_all_indexer_settings()
        .await
        .map(RadarrSerdeable::from),
+      RadarrEvent::GetBlocklist => self.get_blocklist().await.map(RadarrSerdeable::from),
+      RadarrEvent::GetCollections => self.get_collections().await.map(RadarrSerdeable::from),
+      RadarrEvent::GetDownloads => self.get_downloads().await.map(RadarrSerdeable::from),
+      RadarrEvent::GetHostConfig => self.get_host_config().await.map(RadarrSerdeable::from),
+      RadarrEvent::GetIndexers => self.get_indexers().await.map(RadarrSerdeable::from),
      RadarrEvent::GetLogs(events) => self.get_logs(events).await.map(RadarrSerdeable::from),
      RadarrEvent::GetMovieCredits(movie_id) => {
        self.get_credits(movie_id).await.map(RadarrSerdeable::from)
@@ -209,6 +213,7 @@ impl<'a, 'b> Network<'a, 'b> {
        self.get_releases(movie_id).await.map(RadarrSerdeable::from)
      }
      RadarrEvent::GetRootFolders => self.get_root_folders().await.map(RadarrSerdeable::from),
+      RadarrEvent::GetSecurityConfig => self.get_security_config().await.map(RadarrSerdeable::from),
      RadarrEvent::GetStatus => self.get_status().await.map(RadarrSerdeable::from),
      RadarrEvent::GetTags => self.get_tags().await.map(RadarrSerdeable::from),
      RadarrEvent::GetTasks => self.get_tasks().await.map(RadarrSerdeable::from),
@@ -1354,6 +1359,22 @@ impl<'a, 'b> Network<'a, 'b> {
      .await
  }

+  async fn get_host_config(&mut self) -> Result<HostConfig> {
+    info!("Fetching Radarr host config");
+
+    let request_props = self
+      .radarr_request_props_from(
+        RadarrEvent::GetHostConfig.resource(),
+        RequestMethod::Get,
+        None::<()>,
+      )
+      .await;
+
+    self
+      .handle_request::<(), HostConfig>(request_props, |_, _| ())
+      .await
+  }
+
  async fn get_indexers(&mut self) -> Result<Vec<Indexer>> {
    info!("Fetching Radarr indexers");

@@ -1765,6 +1786,22 @@ impl<'a, 'b> Network<'a, 'b> {
      .await
  }

+  async fn get_security_config(&mut self) -> Result<SecurityConfig> {
+    info!("Fetching Radarr security config");
+
+    let request_props = self
+      .radarr_request_props_from(
+        RadarrEvent::GetSecurityConfig.resource(),
+        RequestMethod::Get,
+        None::<()>,
+      )
+      .await;
+
+    self
+      .handle_request::<(), SecurityConfig>(request_props, |_, _| ())
+      .await
+  }
+
  async fn get_status(&mut self) -> Result<SystemStatus> {
    info!("Fetching Radarr system status");

@@ -2225,8 +2262,14 @@ impl<'a, 'b> Network<'a, 'b> {
      host,
      port,
      api_token,
+      use_ssl,
+      ..
    } = &app.config.radarr;
-    let uri = format!("http://{host}:{}/api/v3{resource}", port.unwrap_or(7878));
+    let protocol = if *use_ssl { "https" } else { "http" };
+    let uri = format!(
+      "{protocol}://{host}:{}/api/v3{resource}",
+      port.unwrap_or(7878)
+    );

    RequestProps {
      uri,
@@ -6,6 +6,7 @@ mod test {
  use chrono::{DateTime, Utc};
  use mockito::{Matcher, Mock, Server, ServerGuard};
  use pretty_assertions::{assert_eq, assert_str_eq};
+  use reqwest::Client;
  use rstest::rstest;
  use serde_json::{json, Number, Value};
  use strum::IntoEnumIterator;
@@ -174,6 +175,13 @@ mod test {
    assert_str_eq!(event.resource(), "/queue");
  }

+  #[rstest]
+  fn test_resource_host_config(
+    #[values(RadarrEvent::GetHostConfig, RadarrEvent::GetSecurityConfig)] event: RadarrEvent,
+  ) {
+    assert_str_eq!(event.resource(), "/config/host");
+  }
+
  #[rstest]
  fn test_resource_command(
    #[values(
@@ -229,7 +237,7 @@ mod test {
      RadarrEvent::HealthCheck.resource(),
    )
    .await;
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    let _ = network.handle_radarr_event(RadarrEvent::HealthCheck).await;

@@ -255,7 +263,7 @@ mod test {
      RadarrEvent::GetOverview.resource(),
    )
    .await;
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
    let disk_space_vec = vec![
      DiskSpace {
        free_space: 1111,
@@ -294,7 +302,7 @@ mod test {
      RadarrEvent::GetStatus.resource(),
    )
    .await;
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
    let date_time = DateTime::from(DateTime::parse_from_rfc3339("2023-02-25T20:16:43Z").unwrap())
      as DateTime<Utc>;

@@ -378,7 +386,7 @@ mod test {
        .movies
        .sorting(vec![title_sort_option]);
    }
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    if let RadarrSerdeable::Movies(movies) = network
      .handle_radarr_event(RadarrEvent::GetMovies)
@@ -433,7 +441,7 @@ mod test {
      .radarr_data
      .movies
      .sorting(vec![title_sort_option]);
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    assert!(network
      .handle_radarr_event(RadarrEvent::GetMovies)
@@ -486,7 +494,7 @@ mod test {
      .movies
      .set_items(vec![movie()]);
    app_arc.lock().await.data.radarr_data.movie_details_modal = Some(MovieDetailsModal::default());
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    if let RadarrSerdeable::Releases(releases_vec) = network
      .handle_radarr_event(RadarrEvent::GetReleases(None))
@@ -544,7 +552,7 @@ mod test {
      .radarr_data
      .movies
      .set_items(vec![movie()]);
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    assert!(network
      .handle_radarr_event(RadarrEvent::GetReleases(None))
@@ -603,7 +611,7 @@ mod test {
    )
    .await;
    app_arc.lock().await.data.radarr_data.add_movie_search = Some("test term".into());
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    if let RadarrSerdeable::AddMovieSearchResults(add_movie_search_results) = network
      .handle_radarr_event(RadarrEvent::SearchNewMovie(None))
@@ -669,7 +677,7 @@ mod test {
      &resource,
    )
    .await;
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    if let RadarrSerdeable::AddMovieSearchResults(add_movie_search_results) = network
      .handle_radarr_event(RadarrEvent::SearchNewMovie(Some("test term".into())))
@@ -704,7 +712,7 @@ mod test {
        task_name: TaskName::default(),
        ..Task::default()
      }]);
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    if let RadarrSerdeable::Value(value) = network
      .handle_radarr_event(RadarrEvent::StartTask(None))
@@ -729,7 +737,7 @@ mod test {
      RadarrEvent::StartTask(None).resource(),
    )
    .await;
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    if let RadarrSerdeable::Value(value) = network
      .handle_radarr_event(RadarrEvent::StartTask(Some(TaskName::default())))
@@ -750,7 +758,7 @@ mod test {
    let (async_server, app_arc, _server) =
      mock_radarr_api(RequestMethod::Get, None, Some(json!([])), None, &resource).await;
    app_arc.lock().await.data.radarr_data.add_movie_search = Some("test term".into());
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    assert!(network
      .handle_radarr_event(RadarrEvent::SearchNewMovie(None))
@@ -797,10 +805,12 @@ mod test {
      host,
      port,
      api_token: "test1234".to_owned(),
+      use_ssl: false,
+      ssl_cert_path: None,
    };
    app.config.radarr = radarr_config;
    let app_arc = Arc::new(Mutex::new(app));
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    assert!(network
      .handle_radarr_event(RadarrEvent::SearchNewMovie(None))
@@ -879,7 +889,7 @@ mod test {
      .radarr_data
      .indexers
      .set_items(vec![indexer()]);
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    if let RadarrSerdeable::Value(value) = network
      .handle_radarr_event(RadarrEvent::TestIndexer(None))
@@ -947,7 +957,7 @@ mod test {
      .radarr_data
      .indexers
      .set_items(vec![indexer()]);
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    if let RadarrSerdeable::Value(value) = network
      .handle_radarr_event(RadarrEvent::TestIndexer(None))
@@ -1008,7 +1018,7 @@ mod test {
      .with_body("{}")
      .create_async()
      .await;
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    if let RadarrSerdeable::Value(value) = network
      .handle_radarr_event(RadarrEvent::TestIndexer(Some(1)))
@@ -1085,7 +1095,7 @@ mod test {
      .radarr_data
      .indexers
      .set_items(indexers);
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    if let RadarrSerdeable::IndexerTestResults(results) = network
      .handle_radarr_event(RadarrEvent::TestAllIndexers)
@@ -1136,7 +1146,7 @@ mod test {
      .radarr_data
      .movies
      .set_items(vec![movie()]);
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    assert!(network
      .handle_radarr_event(RadarrEvent::TriggerAutomaticSearch(None))
@@ -1159,7 +1169,7 @@ mod test {
      RadarrEvent::TriggerAutomaticSearch(None).resource(),
    )
    .await;
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    assert!(network
      .handle_radarr_event(RadarrEvent::TriggerAutomaticSearch(Some(1)))
@@ -1189,7 +1199,7 @@ mod test {
      .radarr_data
      .movies
      .set_items(vec![movie()]);
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    assert!(network
      .handle_radarr_event(RadarrEvent::UpdateAndScan(None))
@@ -1212,7 +1222,7 @@ mod test {
      RadarrEvent::UpdateAndScan(None).resource(),
    )
    .await;
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    assert!(network
      .handle_radarr_event(RadarrEvent::UpdateAndScan(Some(1)))
@@ -1235,7 +1245,7 @@ mod test {
      RadarrEvent::UpdateAllMovies.resource(),
    )
    .await;
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    assert!(network
      .handle_radarr_event(RadarrEvent::UpdateAllMovies)
@@ -1257,7 +1267,7 @@ mod test {
      RadarrEvent::UpdateDownloads.resource(),
    )
    .await;
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    assert!(network
      .handle_radarr_event(RadarrEvent::UpdateDownloads)
@@ -1279,7 +1289,7 @@ mod test {
      RadarrEvent::UpdateCollections.resource(),
    )
    .await;
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    assert!(network
      .handle_radarr_event(RadarrEvent::UpdateCollections)
@@ -1310,7 +1320,7 @@ mod test {
      .set_items(vec![movie()]);
    app_arc.lock().await.data.radarr_data.quality_profile_map =
      BiMap::from_iter([(2222, "HD - 1080p".to_owned())]);
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    if let RadarrSerdeable::Movie(movie) = network
      .handle_radarr_event(RadarrEvent::GetMovieDetails(None))
@@ -1395,7 +1405,7 @@ mod test {
      &resource,
    )
    .await;
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    if let RadarrSerdeable::Movie(movie) = network
      .handle_radarr_event(RadarrEvent::GetMovieDetails(Some(1)))
@@ -1449,7 +1459,7 @@ mod test {
      .set_items(vec![movie()]);
    app_arc.lock().await.data.radarr_data.quality_profile_map =
      BiMap::from_iter([(2222, "HD - 1080p".to_owned())]);
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    assert!(network
      .handle_radarr_event(RadarrEvent::GetMovieDetails(None))
@@ -1523,7 +1533,7 @@ mod test {
      .movies
      .set_items(vec![movie()]);
    app_arc.lock().await.data.radarr_data.movie_details_modal = Some(MovieDetailsModal::default());
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    if let RadarrSerdeable::MovieHistoryItems(history) = network
      .handle_radarr_event(RadarrEvent::GetMovieHistory(None))
@@ -1571,7 +1581,7 @@ mod test {
      &resource,
    )
    .await;
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    if let RadarrSerdeable::MovieHistoryItems(history) = network
      .handle_radarr_event(RadarrEvent::GetMovieHistory(Some(1)))
@@ -1611,7 +1621,7 @@ mod test {
      .radarr_data
      .movies
      .set_items(vec![movie()]);
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    assert!(network
      .handle_radarr_event(RadarrEvent::GetMovieHistory(None))
@@ -1760,7 +1770,7 @@ mod test {
        .blocklist
        .sorting(vec![blocklist_sort_option]);
    }
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    if let RadarrSerdeable::BlocklistResponse(blocklist) = network
      .handle_radarr_event(RadarrEvent::GetBlocklist)
@@ -1881,7 +1891,7 @@ mod test {
      .radarr_data
      .blocklist
      .sorting(vec![blocklist_sort_option]);
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    assert!(network
      .handle_radarr_event(RadarrEvent::GetBlocklist)
@@ -2004,7 +2014,7 @@ mod test {
        .collections
        .sorting(vec![collection_sort_option]);
    }
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    if let RadarrSerdeable::Collections(collections) = network
      .handle_radarr_event(RadarrEvent::GetCollections)
@@ -2111,7 +2121,7 @@ mod test {
      .radarr_data
      .collections
      .sorting(vec![collection_sort_option]);
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    assert!(network
      .handle_radarr_event(RadarrEvent::GetCollections)
@@ -2155,7 +2165,7 @@ mod test {
      RadarrEvent::GetDownloads.resource(),
    )
    .await;
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    if let RadarrSerdeable::DownloadsResponse(downloads) = network
      .handle_radarr_event(RadarrEvent::GetDownloads)
@@ -2171,6 +2181,40 @@ mod test {
    }
  }

+  #[tokio::test]
+  async fn test_handle_get_host_config_event() {
+    let host_config_response = json!({
+      "bindAddress": "*",
+      "port": 7878,
+      "urlBase": "some.test.site/radarr",
+      "instanceName": "Radarr",
+      "applicationUrl": "https://some.test.site:7878/radarr",
+      "enableSsl": true,
+      "sslPort": 9898,
+      "sslCertPath": "/app/radarr.pfx",
+      "sslCertPassword": "test"
+    });
+    let response: HostConfig = serde_json::from_value(host_config_response.clone()).unwrap();
+    let (async_server, app_arc, _server) = mock_radarr_api(
+      RequestMethod::Get,
+      None,
+      Some(host_config_response),
+      None,
+      RadarrEvent::GetHostConfig.resource(),
+    )
+    .await;
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+
+    if let RadarrSerdeable::HostConfig(host_config) = network
+      .handle_radarr_event(RadarrEvent::GetHostConfig)
+      .await
+      .unwrap()
+    {
+      async_server.assert_async().await;
+      assert_eq!(host_config, response);
+    }
+  }
+
  #[tokio::test]
  async fn test_handle_get_indexers_event() {
    let indexers_response_json = json!([{
@@ -2212,7 +2256,7 @@ mod test {
      RadarrEvent::GetIndexers.resource(),
    )
    .await;
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    if let RadarrSerdeable::Indexers(indexers) = network
      .handle_radarr_event(RadarrEvent::GetIndexers)
@@ -2251,7 +2295,7 @@ mod test {
      RadarrEvent::GetAllIndexerSettings.resource(),
    )
    .await;
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    if let RadarrSerdeable::IndexerSettings(settings) = network
      .handle_radarr_event(RadarrEvent::GetAllIndexerSettings)
@@ -2289,7 +2333,7 @@ mod test {
    )
    .await;
    app_arc.lock().await.data.radarr_data.indexer_settings = Some(IndexerSettings::default());
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    assert!(network
      .handle_radarr_event(RadarrEvent::GetAllIndexerSettings)
@@ -2336,7 +2380,7 @@ mod test {
      RadarrEvent::GetQueuedEvents.resource(),
    )
    .await;
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    if let RadarrSerdeable::QueueEvents(events) = network
      .handle_radarr_event(RadarrEvent::GetQueuedEvents)
@@ -2397,7 +2441,7 @@ mod test {
      &resource,
    )
    .await;
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    if let RadarrSerdeable::LogResponse(logs) = network
      .handle_radarr_event(RadarrEvent::GetLogs(None))
@@ -2467,7 +2511,7 @@ mod test {
      &resource,
    )
    .await;
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    if let RadarrSerdeable::LogResponse(logs) = network
      .handle_radarr_event(RadarrEvent::GetLogs(Some(1000)))
@@ -2508,7 +2552,7 @@ mod test {
      RadarrEvent::GetQualityProfiles.resource(),
    )
    .await;
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    if let RadarrSerdeable::QualityProfiles(quality_profiles) = network
      .handle_radarr_event(RadarrEvent::GetQualityProfiles)
@@ -2539,7 +2583,7 @@ mod test {
      RadarrEvent::GetTags.resource(),
    )
    .await;
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    if let RadarrSerdeable::Tags(tags) = network
      .handle_radarr_event(RadarrEvent::GetTags)
@@ -2601,7 +2645,7 @@ mod test {
      RadarrEvent::GetTasks.resource(),
    )
    .await;
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    if let RadarrSerdeable::Tasks(tasks) = network
      .handle_radarr_event(RadarrEvent::GetTasks)
@@ -2694,7 +2738,7 @@ mod test {
      RadarrEvent::GetUpdates.resource(),
    )
    .await;
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    if let RadarrSerdeable::Updates(updates) = network
      .handle_radarr_event(RadarrEvent::GetUpdates)
@@ -2711,7 +2755,7 @@ mod test {
  }

  #[tokio::test]
-  async fn test_add_tag() {
+  async fn test_handle_add_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_radarr_api(
@@ -2724,7 +2768,7 @@ mod test {
    .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());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    if let RadarrSerdeable::Tag(tag) = network
      .handle_radarr_event(RadarrEvent::AddTag("testing".to_owned()))
@@ -2749,7 +2793,7 @@ mod test {
    let resource = format!("{}/1", RadarrEvent::DeleteTag(1).resource());
    let (async_server, app_arc, _server) =
      mock_radarr_api(RequestMethod::Delete, None, None, None, &resource).await;
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    assert!(network
      .handle_radarr_event(RadarrEvent::DeleteTag(1))
@@ -2776,7 +2820,7 @@ mod test {
      RadarrEvent::GetRootFolders.resource(),
    )
    .await;
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    if let RadarrSerdeable::RootFolders(root_folders) = network
      .handle_radarr_event(RadarrEvent::GetRootFolders)
@@ -2792,6 +2836,38 @@ mod test {
    }
  }

+  #[tokio::test]
+  async fn test_handle_get_security_config_event() {
+    let security_config_response = json!({
+      "authenticationMethod": "forms",
+      "authenticationRequired": "disabledForLocalAddresses",
+      "username": "test",
+      "password": "some password",
+      "apiKey": "someApiKey12345",
+      "certificateValidation": "disabledForLocalAddresses",
+    });
+    let response: SecurityConfig =
+      serde_json::from_value(security_config_response.clone()).unwrap();
+    let (async_server, app_arc, _server) = mock_radarr_api(
+      RequestMethod::Get,
+      None,
+      Some(security_config_response),
+      None,
+      RadarrEvent::GetSecurityConfig.resource(),
+    )
+    .await;
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+
+    if let RadarrSerdeable::SecurityConfig(security_config) = network
+      .handle_radarr_event(RadarrEvent::GetSecurityConfig)
+      .await
+      .unwrap()
+    {
+      async_server.assert_async().await;
+      assert_eq!(security_config, response);
+    }
+  }
+
  #[tokio::test]
  async fn test_handle_get_movie_credits_event() {
    let credits_json = json!([
@@ -2828,7 +2904,7 @@ mod test {
      .movies
      .set_items(vec![movie()]);
    app_arc.lock().await.data.radarr_data.movie_details_modal = Some(MovieDetailsModal::default());
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    if let RadarrSerdeable::Credits(credits) = network
      .handle_radarr_event(RadarrEvent::GetMovieCredits(None))
@@ -2873,7 +2949,7 @@ mod test {
      &resource,
    )
    .await;
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    if let RadarrSerdeable::Credits(credits) = network
      .handle_radarr_event(RadarrEvent::GetMovieCredits(Some(1)))
@@ -2919,7 +2995,7 @@ mod test {
      .radarr_data
      .movies
      .set_items(vec![movie()]);
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    assert!(network
      .handle_radarr_event(RadarrEvent::GetMovieCredits(None))
@@ -2948,7 +3024,7 @@ mod test {
      app.data.radarr_data.delete_movie_files = true;
      app.data.radarr_data.add_list_exclusion = true;
    }
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    assert!(network
      .handle_radarr_event(RadarrEvent::DeleteMovie(None))
@@ -2968,7 +3044,7 @@ mod test {
    );
    let (async_server, app_arc, _server) =
      mock_radarr_api(RequestMethod::Delete, None, None, None, &resource).await;
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
    let delete_movie_params = DeleteMovieParams {
      id: 1,
      delete_movie_files: true,
@@ -3017,7 +3093,7 @@ mod test {
      .radarr_data
      .blocklist
      .set_items(blocklist_items);
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    assert!(network
      .handle_radarr_event(RadarrEvent::ClearBlocklist)
@@ -3039,7 +3115,7 @@ mod test {
      .radarr_data
      .blocklist
      .set_items(vec![blocklist_item()]);
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    assert!(network
      .handle_radarr_event(RadarrEvent::DeleteBlocklistItem(None))
@@ -3054,7 +3130,7 @@ mod test {
    let resource = format!("{}/1", RadarrEvent::DeleteBlocklistItem(None).resource());
    let (async_server, app_arc, _server) =
      mock_radarr_api(RequestMethod::Delete, None, None, None, &resource).await;
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    assert!(network
      .handle_radarr_event(RadarrEvent::DeleteBlocklistItem(Some(1)))
@@ -3076,7 +3152,7 @@ mod test {
      .radarr_data
      .downloads
      .set_items(vec![download_record()]);
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    assert!(network
      .handle_radarr_event(RadarrEvent::DeleteDownload(None))
@@ -3091,7 +3167,7 @@ mod test {
    let resource = format!("{}/1", RadarrEvent::DeleteDownload(None).resource());
    let (async_server, app_arc, _server) =
      mock_radarr_api(RequestMethod::Delete, None, None, None, &resource).await;
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    assert!(network
      .handle_radarr_event(RadarrEvent::DeleteDownload(Some(1)))
@@ -3113,7 +3189,7 @@ mod test {
      .radarr_data
      .indexers
      .set_items(vec![indexer()]);
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    assert!(network
      .handle_radarr_event(RadarrEvent::DeleteIndexer(None))
@@ -3128,7 +3204,7 @@ mod test {
    let resource = format!("{}/1", RadarrEvent::DeleteIndexer(None).resource());
    let (async_server, app_arc, _server) =
      mock_radarr_api(RequestMethod::Delete, None, None, None, &resource).await;
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    assert!(network
      .handle_radarr_event(RadarrEvent::DeleteIndexer(Some(1)))
@@ -3150,7 +3226,7 @@ mod test {
      .radarr_data
      .root_folders
      .set_items(vec![root_folder()]);
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    assert!(network
      .handle_radarr_event(RadarrEvent::DeleteRootFolder(None))
@@ -3165,7 +3241,7 @@ mod test {
    let resource = format!("{}/1", RadarrEvent::DeleteRootFolder(None).resource());
    let (async_server, app_arc, _server) =
      mock_radarr_api(RequestMethod::Delete, None, None, None, &resource).await;
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    assert!(network
      .handle_radarr_event(RadarrEvent::DeleteRootFolder(Some(1)))
@@ -3249,7 +3325,7 @@ mod test {
        app.data.radarr_data.add_searched_movies = Some(add_searched_movies);
      }
    }
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    assert!(network
      .handle_radarr_event(RadarrEvent::AddMovie(None))
@@ -3302,7 +3378,7 @@ mod test {
      },
    };

-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    assert!(network
      .handle_radarr_event(RadarrEvent::AddMovie(Some(body)))
@@ -3388,7 +3464,7 @@ mod test {
      add_searched_movies.scroll_to_bottom();
      app.data.radarr_data.add_searched_movies = Some(add_searched_movies);
    }
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    assert!(network
      .handle_radarr_event(RadarrEvent::AddMovie(None))
@@ -3432,7 +3508,7 @@ mod test {
    .await;

    app_arc.lock().await.data.radarr_data.edit_root_folder = Some("/nfs/test".into());
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    assert!(network
      .handle_radarr_event(RadarrEvent::AddRootFolder(None))
@@ -3462,7 +3538,7 @@ mod test {
    )
    .await;

-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    assert!(network
      .handle_radarr_event(RadarrEvent::AddRootFolder(Some("/test/test".to_owned())))
@@ -3502,7 +3578,7 @@ mod test {
    .await;

    app_arc.lock().await.data.radarr_data.indexer_settings = Some(indexer_settings());
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    assert!(network
      .handle_radarr_event(RadarrEvent::EditAllIndexerSettings(None))
@@ -3541,7 +3617,7 @@ mod test {
    )
    .await;

-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    assert!(network
      .handle_radarr_event(RadarrEvent::EditAllIndexerSettings(
@@ -3639,7 +3715,7 @@ mod test {
      app.data.radarr_data.quality_profile_map =
        BiMap::from_iter([(1111, "Any".to_owned()), (2222, "HD - 1080p".to_owned())]);
    }
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    assert!(network
      .handle_radarr_event(RadarrEvent::EditCollection(None))
@@ -3724,7 +3800,7 @@ mod test {
      root_folder_path: Some("/nfs/Test Path".to_owned()),
      search_on_add: Some(false),
    };
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    assert!(network
      .handle_radarr_event(RadarrEvent::EditCollection(Some(edit_collection_params)))
@@ -3803,7 +3879,7 @@ mod test {
      collection_id: 123,
      ..EditCollectionParams::default()
    };
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    assert!(network
      .handle_radarr_event(RadarrEvent::EditCollection(Some(edit_collection_params)))
@@ -3899,7 +3975,7 @@ mod test {
      app.data.radarr_data.edit_indexer_modal = Some(edit_indexer_modal);
      app.data.radarr_data.indexers.set_items(vec![indexer()]);
    }
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    assert!(network
      .handle_radarr_event(RadarrEvent::EditIndexer(None))
@@ -4000,7 +4076,7 @@ mod test {
      );
      app.data.radarr_data.indexers.set_items(vec![indexer]);
    }
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    assert!(network
      .handle_radarr_event(RadarrEvent::EditIndexer(None))
@@ -4115,7 +4191,7 @@ mod test {
      );
      app.data.radarr_data.indexers.set_items(vec![indexer]);
    }
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    assert!(network
      .handle_radarr_event(RadarrEvent::EditIndexer(None))
@@ -4210,7 +4286,7 @@ mod test {
      .match_body(Matcher::Json(expected_indexer_edit_body_json))
      .create_async()
      .await;
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    assert!(network
      .handle_radarr_event(RadarrEvent::EditIndexer(Some(edit_indexer_params)))
@@ -4270,7 +4346,7 @@ mod test {
      .match_body(Matcher::Json(indexer_details_json))
      .create_async()
      .await;
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    assert!(network
      .handle_radarr_event(RadarrEvent::EditIndexer(Some(edit_indexer_params)))
@@ -4355,7 +4431,7 @@ mod test {
      .match_body(Matcher::Json(expected_edit_indexer_body))
      .create_async()
      .await;
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    assert!(network
      .handle_radarr_event(RadarrEvent::EditIndexer(Some(edit_indexer_params)))
@@ -4418,7 +4494,7 @@ mod test {
      app.data.radarr_data.quality_profile_map =
        BiMap::from_iter([(1111, "Any".to_owned()), (2222, "HD - 1080p".to_owned())]);
    }
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    assert!(network
      .handle_radarr_event(RadarrEvent::EditMovie(None))
@@ -4469,7 +4545,7 @@ mod test {
      tags: Some(vec![1, 2]),
      ..EditMovieParams::default()
    };
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    assert!(network
      .handle_radarr_event(RadarrEvent::EditMovie(Some(edit_movie_params)))
@@ -4506,7 +4582,7 @@ mod test {
      movie_id: 1,
      ..EditMovieParams::default()
    };
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    assert!(network
      .handle_radarr_event(RadarrEvent::EditMovie(Some(edit_movie_params)))
@@ -4547,7 +4623,7 @@ mod test {
      clear_tags: true,
      ..EditMovieParams::default()
    };
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    assert!(network
      .handle_radarr_event(RadarrEvent::EditMovie(Some(edit_movie_params)))
@@ -4584,7 +4660,7 @@ mod test {
      .radarr_data
      .movies
      .set_items(vec![movie()]);
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    assert!(network
      .handle_radarr_event(RadarrEvent::DownloadRelease(None))
@@ -4608,7 +4684,7 @@ mod test {
      RadarrEvent::DownloadRelease(None).resource(),
    )
    .await;
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
    let params = ReleaseDownloadBody {
      guid: "1234".to_owned(),
      indexer_id: 2,
@@ -4635,7 +4711,7 @@ mod test {
        (3, "hi".to_owned()),
      ]);
    }
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    assert_eq!(
      network.extract_and_add_tag_ids_vec(tags).await,
@@ -4663,7 +4739,7 @@ mod test {
      app.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());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    let tag_ids_vec = network.extract_and_add_tag_ids_vec(tags).await;

@@ -4692,7 +4768,7 @@ mod test {
        id: 1,
        ..Movie::default()
      }]);
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    assert_eq!(network.extract_movie_id().await, 1);
  }
@@ -4706,7 +4782,7 @@ mod test {
      ..Movie::default()
    }]);
    app_arc.lock().await.data.radarr_data.movies = filtered_movies;
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    assert_eq!(network.extract_movie_id().await, 1);
  }
@@ -4724,7 +4800,7 @@ mod test {
        id: 1,
        ..Collection::default()
      }]);
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    assert_eq!(network.extract_collection_id().await, 1);
  }
@@ -4738,7 +4814,7 @@ mod test {
      ..Collection::default()
    }]);
    app_arc.lock().await.data.radarr_data.collections = filtered_collections;
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    assert_eq!(network.extract_collection_id().await, 1);
  }
@@ -4756,7 +4832,7 @@ mod test {
        id: 1,
        ..Movie::default()
      }]);
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    assert_str_eq!(
      network.append_movie_id_param("/test", None).await,
@@ -4777,7 +4853,7 @@ mod test {
        id: 1,
        ..Movie::default()
      }]);
-    let mut network = Network::new(&app_arc, CancellationToken::new());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    assert_str_eq!(
      network.append_movie_id_param("/test", Some(11)).await,
@@ -4788,7 +4864,7 @@ mod test {
  #[tokio::test]
  async fn test_radarr_request_props_from_default_radarr_config() {
    let app_arc = Arc::new(Mutex::new(App::default()));
-    let network = Network::new(&app_arc, CancellationToken::new());
+    let network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    let request_props = network
      .radarr_request_props_from("/test", RequestMethod::Get, None::<()>)
@@ -4803,6 +4879,8 @@ mod test {
      host: "192.168.0.123".to_owned(),
      port: Some(8080),
      api_token: "testToken1234".to_owned(),
+      use_ssl: false,
+      ssl_cert_path: None,
    };
  }

@@ -4814,14 +4892,16 @@ mod test {
      host: "192.168.0.123".to_owned(),
      port: Some(8080),
      api_token: api_token.clone(),
+      use_ssl: true,
+      ssl_cert_path: None,
    };
-    let network = Network::new(&app_arc, CancellationToken::new());
+    let network = Network::new(&app_arc, CancellationToken::new(), Client::new());

    let request_props = network
      .radarr_request_props_from("/test", RequestMethod::Get, None::<()>)
      .await;

-    assert_str_eq!(request_props.uri, "http://192.168.0.123:8080/api/v3/test");
+    assert_str_eq!(request_props.uri, "https://192.168.0.123:8080/api/v3/test");
    assert_eq!(request_props.method, RequestMethod::Get);
    assert_eq!(request_props.body, None);
    assert_str_eq!(request_props.api_token, api_token);
@@ -4917,6 +4997,8 @@ mod test {
      host,
      port,
      api_token: "test1234".to_owned(),
+      use_ssl: false,
+      ssl_cert_path: None,
    };
    app.config.radarr = radarr_config;
    let app_arc = Arc::new(Mutex::new(app));
Author	SHA1	Message	Date
github-actions[bot]	aa43219c29	chore: release v0.1.5	2024-11-03 00:33:11 +00:00
Alex Clarke	f6f477b124	Added HTTPS support for all Servarrs	2024-11-02 18:32:44 -06:00
Alex Clarke	76f22e7434	Merge pull request #5 from Dark-Alex-17/release-plz-2024-11-01T19-06-52Z chore: release v0.1.4	2024-11-01 13:13:03 -06:00
github-actions[bot]	28aad8cd14	chore: release v0.1.4	2024-11-01 19:06:53 +00:00
Alex Clarke	97c8f8fc49	Added the ability to fetch host configs and security configs to the CLI	2024-11-01 13:02:39 -06:00
Alex Clarke	9da4ebfe11	Updated README to be more clear about what features are supported [skip ci]	2024-10-31 15:53:08 -06:00