feat: Blocklist support in Lidarr in both the CLI and TUI

src/cli/cli_tests.rs

@@ -8,12 +8,18 @@ mod tests {
   use serde_json::json;
   use tokio::sync::Mutex;
 
+  use crate::cli::lidarr::LidarrCommand;
+  use crate::network::lidarr_network::LidarrEvent;
   use crate::{
     Cli,
     app::App,
     cli::{handle_command, mutex_flags_or_option, radarr::RadarrCommand, sonarr::SonarrCommand},
     models::{
       Serdeable,
+      lidarr_models::{
+        BlocklistItem as LidarrBlocklistItem, BlocklistResponse as LidarrBlocklistResponse,
+        LidarrSerdeable,
+      },
       radarr_models::{
         BlocklistItem as RadarrBlocklistItem, BlocklistResponse as RadarrBlocklistResponse,
         RadarrSerdeable,
@@ -182,5 +188,34 @@ mod tests {
     assert_ok!(&result);
   }
 
-  // TODO: Implement test_cli_handler_delegates_lidarr_commands_to_the_lidarr_cli_handler
+  #[tokio::test]
+  async fn test_cli_handler_delegates_lidarr_commands_to_the_lidarr_cli_handler() {
+    let mut mock_network = MockNetworkTrait::new();
+    mock_network
+      .expect_handle_network_event()
+      .with(eq::<NetworkEvent>(LidarrEvent::GetBlocklist.into()))
+      .times(1)
+      .returning(|_| {
+        Ok(Serdeable::Lidarr(LidarrSerdeable::BlocklistResponse(
+          LidarrBlocklistResponse {
+            records: vec![LidarrBlocklistItem::default()],
+          },
+        )))
+      });
+    mock_network
+      .expect_handle_network_event()
+      .with(eq::<NetworkEvent>(LidarrEvent::ClearBlocklist.into()))
+      .times(1)
+      .returning(|_| {
+        Ok(Serdeable::Lidarr(LidarrSerdeable::Value(
+          json!({"testResponse": "response"}),
+        )))
+      });
+    let app_arc = Arc::new(Mutex::new(App::test_default()));
+    let clear_blocklist_command = LidarrCommand::ClearBlocklist.into();
+
+    let result = handle_command(&app_arc, clear_blocklist_command, &mut mock_network).await;
+
+    assert_ok!(&result);
+  }
 }

src/cli/lidarr/delete_command_handler.rs

@@ -28,6 +28,15 @@ pub enum LidarrDeleteCommand {
     #[arg(long, help = "Add a list exclusion for this album")]
     add_list_exclusion: bool,
   },
+  #[command(about = "Delete the specified item from the Lidarr blocklist")]
+  BlocklistItem {
+    #[arg(
+      long,
+      help = "The ID of the blocklist item to remove from the blocklist",
+      required = true
+    )]
+    blocklist_item_id: i64,
+  },
   #[command(about = "Delete the specified track file from disk")]
   TrackFile {
     #[arg(long, help = "The ID of the track file to delete", required = true)]
@@ -107,6 +116,13 @@ impl<'a, 'b> CliCommandHandler<'a, 'b, LidarrDeleteCommand> for LidarrDeleteComm
           .await?;
         serde_json::to_string_pretty(&resp)?
       }
+      LidarrDeleteCommand::BlocklistItem { blocklist_item_id } => {
+        let resp = self
+          .network
+          .handle_network_event(LidarrEvent::DeleteBlocklistItem(blocklist_item_id).into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
       LidarrDeleteCommand::TrackFile { track_file_id } => {
         let resp = self
           .network

src/cli/lidarr/delete_command_handler_tests.rs

@@ -86,6 +86,42 @@ mod tests {
       assert_eq!(delete_command, expected_args);
     }
 
+    #[test]
+    fn test_delete_blocklist_item_requires_arguments() {
+      let result =
+        Cli::command().try_get_matches_from(["managarr", "lidarr", "delete", "blocklist-item"]);
+
+      assert_err!(&result);
+      assert_eq!(
+        result.unwrap_err().kind(),
+        ErrorKind::MissingRequiredArgument
+      );
+    }
+
+    #[test]
+    fn test_delete_blocklist_item_success() {
+      let expected_args = LidarrDeleteCommand::BlocklistItem {
+        blocklist_item_id: 1,
+      };
+
+      let result = Cli::try_parse_from([
+        "managarr",
+        "lidarr",
+        "delete",
+        "blocklist-item",
+        "--blocklist-item-id",
+        "1",
+      ]);
+
+      assert_ok!(&result);
+
+      let Some(Command::Lidarr(LidarrCommand::Delete(delete_command))) = result.unwrap().command
+      else {
+        panic!("Unexpected command type");
+      };
+      assert_eq!(delete_command, expected_args);
+    }
+
     #[test]
     fn test_delete_track_file_requires_arguments() {
       let result =
@@ -361,6 +397,37 @@ mod tests {
       assert_ok!(&result);
     }
 
+    #[tokio::test]
+    async fn test_handle_delete_blocklist_item_command() {
+      let expected_blocklist_item_id = 1;
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(
+          LidarrEvent::DeleteBlocklistItem(expected_blocklist_item_id).into(),
+        ))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let delete_blocklist_item_command = LidarrDeleteCommand::BlocklistItem {
+        blocklist_item_id: 1,
+      };
+
+      let result = LidarrDeleteCommandHandler::with(
+        &app_arc,
+        delete_blocklist_item_command,
+        &mut mock_network,
+      )
+      .handle()
+      .await;
+
+      assert_ok!(&result);
+    }
+
     #[tokio::test]
     async fn test_handle_delete_track_file_command() {
       let expected_track_file_id = 1;

src/cli/lidarr/lidarr_command_tests.rs

@@ -25,7 +25,7 @@ mod tests {
 
     #[rstest]
     fn test_commands_that_have_no_arg_requirements(
-      #[values("test-all-indexers")] subcommand: &str,
+      #[values("clear-blocklist", "test-all-indexers")] subcommand: &str,
     ) {
       let result = Cli::command().try_get_matches_from(["managarr", "lidarr", subcommand]);
 
@@ -284,7 +284,9 @@ mod tests {
     use crate::cli::lidarr::manual_search_command_handler::LidarrManualSearchCommand;
     use crate::cli::lidarr::refresh_command_handler::LidarrRefreshCommand;
     use crate::cli::lidarr::trigger_automatic_search_command_handler::LidarrTriggerAutomaticSearchCommand;
-    use crate::models::lidarr_models::{LidarrReleaseDownloadBody, LidarrTaskName};
+    use crate::models::lidarr_models::{
+      BlocklistItem, BlocklistResponse, LidarrReleaseDownloadBody, LidarrTaskName,
+    };
     use crate::models::servarr_models::IndexerSettings;
     use crate::{
       app::App,
@@ -546,6 +548,39 @@ mod tests {
       assert_ok!(&result);
     }
 
+    #[tokio::test]
+    async fn test_handle_clear_blocklist_command() {
+      let mut mock_network = MockNetworkTrait::new();
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(LidarrEvent::GetBlocklist.into()))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::BlocklistResponse(
+            BlocklistResponse {
+              records: vec![BlocklistItem::default()],
+            },
+          )))
+        });
+      mock_network
+        .expect_handle_network_event()
+        .with(eq::<NetworkEvent>(LidarrEvent::ClearBlocklist.into()))
+        .times(1)
+        .returning(|_| {
+          Ok(Serdeable::Lidarr(LidarrSerdeable::Value(
+            json!({"testResponse": "response"}),
+          )))
+        });
+      let app_arc = Arc::new(Mutex::new(App::test_default()));
+      let claer_blocklist_command = LidarrCommand::ClearBlocklist;
+
+      let result = LidarrCliHandler::with(&app_arc, claer_blocklist_command, &mut mock_network)
+        .handle()
+        .await;
+
+      assert_ok!(&result);
+    }
+
     #[tokio::test]
     async fn test_download_release_command() {
       let expected_release_download_body = LidarrReleaseDownloadBody {

src/cli/lidarr/list_command_handler.rs

@@ -57,6 +57,8 @@ pub enum LidarrListCommand {
   },
   #[command(about = "List all artists in your Lidarr library")]
   Artists,
+  #[command(about = "List all items in the Lidarr blocklist")]
+  Blocklist,
   #[command(about = "List all active downloads in Lidarr")]
   Downloads {
     #[arg(long, help = "How many downloads to fetch", default_value_t = 500)]
@@ -200,6 +202,13 @@ impl<'a, 'b> CliCommandHandler<'a, 'b, LidarrListCommand> for LidarrListCommandH
           .await?;
         serde_json::to_string_pretty(&resp)?
       }
+      LidarrListCommand::Blocklist => {
+        let resp = self
+          .network
+          .handle_network_event(LidarrEvent::GetBlocklist.into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
       LidarrListCommand::Downloads { count } => {
         let resp = self
           .network

src/cli/lidarr/list_command_handler_tests.rs

@@ -27,6 +27,7 @@ mod tests {
     fn test_list_commands_have_no_arg_requirements(
       #[values(
         "artists",
+        "blocklist",
         "indexers",
         "metadata-profiles",
         "quality-profiles",
@@ -433,6 +434,7 @@ mod tests {
 
     #[rstest]
     #[case(LidarrListCommand::Artists, LidarrEvent::ListArtists)]
+    #[case(LidarrListCommand::Blocklist, LidarrEvent::GetBlocklist)]
     #[case(LidarrListCommand::Indexers, LidarrEvent::GetIndexers)]
     #[case(LidarrListCommand::MetadataProfiles, LidarrEvent::GetMetadataProfiles)]
     #[case(LidarrListCommand::QualityProfiles, LidarrEvent::GetQualityProfiles)]

src/cli/lidarr/mod.rs

@@ -74,6 +74,8 @@ pub enum LidarrCommand {
     about = "Commands to trigger automatic searches for releases of different resources in your Lidarr instance"
   )]
   TriggerAutomaticSearch(LidarrTriggerAutomaticSearchCommand),
+  #[command(about = "Clear the Lidarr blocklist")]
+  ClearBlocklist,
   #[command(about = "Manually download the given release")]
   DownloadRelease {
     #[arg(long, help = "The GUID of the release to download", required = true)]
@@ -217,6 +219,17 @@ impl<'a, 'b> CliCommandHandler<'a, 'b, LidarrCommand> for LidarrCliHandler<'a, '
         .handle()
         .await?
       }
+      LidarrCommand::ClearBlocklist => {
+        self
+          .network
+          .handle_network_event(LidarrEvent::GetBlocklist.into())
+          .await?;
+        let resp = self
+          .network
+          .handle_network_event(LidarrEvent::ClearBlocklist.into())
+          .await?;
+        serde_json::to_string_pretty(&resp)?
+      }
       LidarrCommand::DownloadRelease { guid, indexer_id } => {
         let params = LidarrReleaseDownloadBody { guid, indexer_id };
         let resp = self