feat(sonarr): Added blocklist commands (List, Clear, Delete)

src/network/sonarr_network_tests.rs

@@ -9,7 +9,9 @@ mod test {
   use tokio_util::sync::CancellationToken;
 
   use crate::models::servarr_data::sonarr::sonarr_data::ActiveSonarrBlock;
-  use crate::models::sonarr_models::SystemStatus;
+  use crate::models::sonarr_models::{BlocklistItem, Language};
+  use crate::models::sonarr_models::{BlocklistResponse, Quality};
+  use crate::models::sonarr_models::{QualityWrapper, SystemStatus};
   use crate::models::{sonarr_models::SonarrSerdeable, stateful_table::SortOption};
 
   use crate::{
@@ -73,8 +75,11 @@ mod test {
   }
 
   #[rstest]
+  #[case(SonarrEvent::ClearBlocklist, "/blocklist/bulk")]
+  #[case(SonarrEvent::DeleteBlocklistItem(None), "/blocklist")]
   #[case(SonarrEvent::HealthCheck, "/health")]
   #[case(SonarrEvent::GetStatus, "/system/status")]
+  #[case(SonarrEvent::GetBlocklist, "/blocklist?page=1&pageSize=10000")]
   fn test_resource(#[case] event: SonarrEvent, #[case] expected_uri: String) {
     assert_str_eq!(event.resource(), expected_uri);
   }
@@ -87,6 +92,171 @@ mod test {
     );
   }
 
+  #[tokio::test]
+  async fn test_handle_clear_radarr_blocklist_event() {
+    let blocklist_items = vec![
+      BlocklistItem {
+        id: 1,
+        ..blocklist_item()
+      },
+      BlocklistItem {
+        id: 2,
+        ..blocklist_item()
+      },
+      BlocklistItem {
+        id: 3,
+        ..blocklist_item()
+      },
+    ];
+    let expected_request_json = json!({ "ids": [1, 2, 3]});
+    let (async_server, app_arc, _server) = mock_servarr_api(
+      RequestMethod::Delete,
+      Some(expected_request_json),
+      None,
+      None,
+      SonarrEvent::ClearBlocklist,
+      None,
+      None,
+    )
+    .await;
+    app_arc
+      .lock()
+      .await
+      .data
+      .sonarr_data
+      .blocklist
+      .set_items(blocklist_items);
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+
+    assert!(network
+      .handle_sonarr_event(SonarrEvent::ClearBlocklist)
+      .await
+      .is_ok());
+
+    async_server.assert_async().await;
+  }
+
+  #[tokio::test]
+  async fn test_handle_delete_sonarr_blocklist_item_event() {
+    let (async_server, app_arc, _server) = mock_servarr_api(
+      RequestMethod::Delete,
+      None,
+      None,
+      None,
+      SonarrEvent::DeleteBlocklistItem(None),
+      Some("/1"),
+      None,
+    )
+    .await;
+    app_arc
+      .lock()
+      .await
+      .data
+      .sonarr_data
+      .blocklist
+      .set_items(vec![blocklist_item()]);
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+
+    assert!(network
+      .handle_sonarr_event(SonarrEvent::DeleteBlocklistItem(None))
+      .await
+      .is_ok());
+
+    async_server.assert_async().await;
+  }
+
+  #[rstest]
+  #[tokio::test]
+  async fn test_handle_get_sonarr_blocklist_event(#[values(true, false)] use_custom_sorting: bool) {
+    let blocklist_json = json!({"records": [{
+        "seriesId": 1007,
+        "episodeIds": [42020],
+        "sourceTitle": "z series",
+        "language": { "id": 1, "name": "English" },
+        "quality": { "quality": { "name": "Bluray-1080p" }},
+        "date": "2024-02-10T07:28:45Z",
+        "protocol": "usenet",
+        "indexer": "NZBgeek (Prowlarr)",
+        "message": "test message",
+        "id": 123
+    },
+    {
+        "seriesId": 2001,
+        "episodeIds": [42018],
+        "sourceTitle": "A Series",
+        "language": { "id": 1, "name": "English" },
+        "quality": { "quality": { "name": "Bluray-1080p" }},
+        "date": "2024-02-10T07:28:45Z",
+        "protocol": "usenet",
+        "indexer": "NZBgeek (Prowlarr)",
+        "message": "test message",
+        "id": 456
+    }]});
+    let response: BlocklistResponse = serde_json::from_value(blocklist_json.clone()).unwrap();
+    let mut expected_blocklist = vec![
+      BlocklistItem {
+        id: 123,
+        series_id: 1007,
+        source_title: "z series".into(),
+        episode_ids: vec![Number::from(42020)],
+        ..blocklist_item()
+      },
+      BlocklistItem {
+        id: 456,
+        series_id: 2001,
+        source_title: "A Series".into(),
+        episode_ids: vec![Number::from(42018)],
+        ..blocklist_item()
+      },
+    ];
+    let (async_server, app_arc, _server) = mock_servarr_api(
+      RequestMethod::Get,
+      None,
+      Some(blocklist_json),
+      None,
+      SonarrEvent::GetBlocklist,
+      None,
+      None,
+    )
+    .await;
+    app_arc.lock().await.data.sonarr_data.blocklist.sort_asc = true;
+    if use_custom_sorting {
+      let cmp_fn = |a: &BlocklistItem, b: &BlocklistItem| {
+        a.source_title
+          .to_lowercase()
+          .cmp(&b.source_title.to_lowercase())
+      };
+      expected_blocklist.sort_by(cmp_fn);
+
+      let blocklist_sort_option = SortOption {
+        name: "Source Title",
+        cmp_fn: Some(cmp_fn),
+      };
+      app_arc
+        .lock()
+        .await
+        .data
+        .sonarr_data
+        .blocklist
+        .sorting(vec![blocklist_sort_option]);
+    }
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+
+    if let SonarrSerdeable::BlocklistResponse(blocklist) = network
+      .handle_sonarr_event(SonarrEvent::GetBlocklist)
+      .await
+      .unwrap()
+    {
+      async_server.assert_async().await;
+      assert_eq!(
+        app_arc.lock().await.data.sonarr_data.blocklist.items,
+        expected_blocklist
+      );
+      assert!(app_arc.lock().await.data.sonarr_data.blocklist.sort_asc);
+      assert_eq!(blocklist, response);
+    }
+  }
+
   #[tokio::test]
   async fn test_handle_get_sonarr_healthcheck_event() {
     let (async_server, app_arc, _server) = mock_servarr_api(
@@ -283,6 +453,37 @@ mod test {
     }
   }
 
+  fn blocklist_item() -> BlocklistItem {
+    BlocklistItem {
+      id: 1,
+      series_id: 1,
+      episode_ids: vec![Number::from(1)],
+      source_title: "Test Source Title".to_owned(),
+      language: language(),
+      quality: quality_wrapper(),
+      date: DateTime::from(DateTime::parse_from_rfc3339("2024-02-10T07:28:45Z").unwrap()),
+      protocol: "usenet".to_owned(),
+      indexer: "NZBgeek (Prowlarr)".to_owned(),
+      message: "test message".to_owned(),
+    }
+  }
+
+  fn language() -> Language {
+    Language {
+      name: "English".to_owned(),
+    }
+  }
+
+  fn quality() -> Quality {
+    Quality {
+      name: "Bluray-1080p".to_owned(),
+    }
+  }
+
+  fn quality_wrapper() -> QualityWrapper {
+    QualityWrapper { quality: quality() }
+  }
+
   fn rating() -> Rating {
     Rating {
       votes: 406744,