fix(sonarr): Pass the indexer ID directly alongside all TestIndexer events when publishing to the networking channel

src/app/radarr/mod.rs

@@ -77,7 +77,9 @@ impl<'a> App<'a> {
       }
       ActiveRadarrBlock::TestIndexer => {
         self
-          .dispatch_network_event(RadarrEvent::TestIndexer(self.extract_indexer_id().await).into())
+          .dispatch_network_event(
+            RadarrEvent::TestIndexer(self.extract_radarr_indexer_id().await).into(),
+          )
           .await;
       }
       ActiveRadarrBlock::TestAllIndexers => {
@@ -243,7 +245,7 @@ impl<'a> App<'a> {
       .clone()
   }
 
-  async fn extract_indexer_id(&self) -> i64 {
+  async fn extract_radarr_indexer_id(&self) -> i64 {
     self
       .data
       .radarr_data

src/app/radarr/radarr_tests.rs

@@ -769,14 +769,14 @@ mod tests {
   }
 
   #[tokio::test]
-  async fn test_extract_indexer_id() {
+  async fn test_extract_radarr_indexer_id() {
     let mut app = App::default();
     app.data.radarr_data.indexers.set_items(vec![Indexer {
       id: 1,
       ..Indexer::default()
     }]);
 
-    assert_eq!(app.extract_indexer_id().await, 1);
+    assert_eq!(app.extract_radarr_indexer_id().await, 1);
   }
 
   fn construct_app_unit<'a>() -> (App<'a>, mpsc::Receiver<NetworkEvent>) {

src/app/sonarr/mod.rs

@@ -144,7 +144,9 @@ impl<'a> App<'a> {
       }
       ActiveSonarrBlock::TestIndexer => {
         self
-          .dispatch_network_event(SonarrEvent::TestIndexer(None).into())
+          .dispatch_network_event(
+            SonarrEvent::TestIndexer(self.extract_sonarr_indexer_id().await).into(),
+          )
           .await;
       }
       ActiveSonarrBlock::TestAllIndexers => {
@@ -300,4 +302,8 @@ impl<'a> App<'a> {
       .text
       .clone()
   }
+
+  async fn extract_sonarr_indexer_id(&self) -> i64 {
+    self.data.sonarr_data.indexers.current_selection().id
+  }
 }

src/app/sonarr/sonarr_tests.rs

@@ -5,6 +5,7 @@ mod tests {
     use tokio::sync::mpsc;
 
     use crate::models::servarr_data::sonarr::sonarr_data::sonarr_test_utils::utils::create_test_sonarr_data;
+    use crate::models::servarr_models::Indexer;
     use crate::models::sonarr_models::Episode;
     use crate::{
       app::App,
@@ -458,6 +459,10 @@ mod tests {
     #[tokio::test]
     async fn test_dispatch_by_test_indexer_block() {
       let (mut app, mut sync_network_rx) = construct_app_unit();
+      app.data.sonarr_data.indexers.set_items(vec![Indexer {
+        id: 1,
+        ..Indexer::default()
+      }]);
 
       app
         .dispatch_by_sonarr_block(&ActiveSonarrBlock::TestIndexer)
@@ -466,7 +471,7 @@ mod tests {
       assert!(app.is_loading);
       assert_eq!(
         sync_network_rx.recv().await.unwrap(),
-        SonarrEvent::TestIndexer(None).into()
+        SonarrEvent::TestIndexer(1).into()
       );
       assert_eq!(app.tick_count, 0);
     }
@@ -849,6 +854,17 @@ mod tests {
       app.extract_add_new_series_search_query().await;
     }
 
+    #[tokio::test]
+    async fn test_extract_sonarr_indexer_id() {
+      let mut app = App::default();
+      app.data.sonarr_data.indexers.set_items(vec![Indexer {
+        id: 1,
+        ..Indexer::default()
+      }]);
+
+      assert_eq!(app.extract_sonarr_indexer_id().await, 1);
+    }
+
     fn construct_app_unit<'a>() -> (App<'a>, mpsc::Receiver<NetworkEvent>) {
       let (sync_network_tx, sync_network_rx) = mpsc::channel::<NetworkEvent>(500);
       let mut app = App {

src/cli/sonarr/mod.rs

@@ -259,7 +259,7 @@ impl<'a, 'b> CliCommandHandler<'a, 'b, SonarrCommand> for SonarrCliHandler<'a, '
       SonarrCommand::TestIndexer { indexer_id } => {
         let resp = self
           .network
-          .handle_network_event(SonarrEvent::TestIndexer(Some(indexer_id)).into())
+          .handle_network_event(SonarrEvent::TestIndexer(indexer_id).into())
           .await?;
         serde_json::to_string_pretty(&resp)?
       }

src/cli/sonarr/sonarr_command_tests.rs

@@ -651,7 +651,7 @@ mod tests {
       mock_network
         .expect_handle_network_event()
         .with(eq::<NetworkEvent>(
-          SonarrEvent::TestIndexer(Some(expected_indexer_id)).into(),
+          SonarrEvent::TestIndexer(expected_indexer_id).into(),
         ))
         .times(1)
         .returning(|_| {

src/network/sonarr_network.rs

@@ -84,7 +84,7 @@ pub enum SonarrEvent {
   MarkHistoryItemAsFailed(i64),
   SearchNewSeries(String),
   StartTask(SonarrTaskName),
-  TestIndexer(Option<i64>),
+  TestIndexer(i64),
   TestAllIndexers,
   ToggleSeasonMonitoring(Option<(i64, i64)>),
   ToggleEpisodeMonitoring(Option<i64>),
@@ -2041,32 +2041,19 @@ impl<'a, 'b> Network<'a, 'b> {
       .await
   }
 
-  async fn test_sonarr_indexer(&mut self, indexer_id: Option<i64>) -> Result<Value> {
+  async fn test_sonarr_indexer(&mut self, indexer_id: i64) -> Result<Value> {
     let detail_event = SonarrEvent::GetIndexers;
-    let event = SonarrEvent::TestIndexer(None);
+    let event = SonarrEvent::TestIndexer(indexer_id);
-    let id = if let Some(i_id) = indexer_id {
+    info!("Testing Sonarr indexer with ID: {indexer_id}");
-      i_id
-    } else {
-      self
-        .app
-        .lock()
-        .await
-        .data
-        .sonarr_data
-        .indexers
-        .current_selection()
-        .id
-    };
-    info!("Testing Sonarr indexer with ID: {id}");
 
-    info!("Fetching indexer details for indexer with ID: {id}");
+    info!("Fetching indexer details for indexer with ID: {indexer_id}");
 
     let request_props = self
       .request_props_from(
         detail_event,
         RequestMethod::Get,
         None::<()>,
-        Some(format!("/{id}")),
+        Some(format!("/{indexer_id}")),
         None,
       )
       .await;

src/network/sonarr_network_tests.rs

@@ -287,7 +287,7 @@ mod test {
   #[case(SonarrEvent::GetUpdates, "/update")]
   #[case(SonarrEvent::MarkHistoryItemAsFailed(0), "/history/failed")]
   #[case(SonarrEvent::SearchNewSeries(String::new()), "/series/lookup")]
-  #[case(SonarrEvent::TestIndexer(None), "/indexer/test")]
+  #[case(SonarrEvent::TestIndexer(0), "/indexer/test")]
   #[case(SonarrEvent::TestAllIndexers, "/indexer/testall")]
   #[case(SonarrEvent::ToggleEpisodeMonitoring(None), "/episode/monitor")]
   fn test_resource(#[case] event: SonarrEvent, #[case] expected_uri: String) {
@@ -4836,7 +4836,7 @@ mod test {
     let async_test_server = server
       .mock(
         "POST",
-        format!("/api/v3{}", SonarrEvent::TestIndexer(None).resource()).as_str(),
+        format!("/api/v3{}", SonarrEvent::TestIndexer(1).resource()).as_str(),
       )
       .with_status(400)
       .match_header("X-Api-Key", "test1234")
@@ -4854,7 +4854,7 @@ mod test {
     let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
 
     if let SonarrSerdeable::Value(value) = network
-      .handle_sonarr_event(SonarrEvent::TestIndexer(None))
+      .handle_sonarr_event(SonarrEvent::TestIndexer(1))
       .await
       .unwrap()
     {
@@ -4905,7 +4905,7 @@ mod test {
     let async_test_server = server
       .mock(
         "POST",
-        format!("/api/v3{}", SonarrEvent::TestIndexer(None).resource()).as_str(),
+        format!("/api/v3{}", SonarrEvent::TestIndexer(1).resource()).as_str(),
       )
       .with_status(200)
       .match_header("X-Api-Key", "test1234")
@@ -4923,7 +4923,7 @@ mod test {
     let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
 
     if let SonarrSerdeable::Value(value) = network
-      .handle_sonarr_event(SonarrEvent::TestIndexer(None))
+      .handle_sonarr_event(SonarrEvent::TestIndexer(1))
       .await
       .unwrap()
     {
@@ -4937,64 +4937,6 @@ mod test {
     }
   }
 
-  #[tokio::test]
-  async fn test_handle_test_sonarr_indexer_event_success_uses_provided_id() {
-    let indexer_details_json = json!({
-        "enableRss": true,
-        "enableAutomaticSearch": true,
-        "enableInteractiveSearch": true,
-        "name": "Test Indexer",
-        "fields": [
-            {
-                "name": "baseUrl",
-                "value": "https://test.com",
-            },
-            {
-                "name": "apiKey",
-                "value": "",
-            },
-            {
-                "name": "seedCriteria.seedRatio",
-                "value": "1.2",
-            },
-        ],
-        "tags": [1],
-        "id": 1
-    });
-    let (async_details_server, app_arc, mut server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(indexer_details_json.clone()),
-      None,
-      SonarrEvent::GetIndexers,
-      Some("/1"),
-      None,
-    )
-    .await;
-    let async_test_server = server
-      .mock(
-        "POST",
-        format!("/api/v3{}", SonarrEvent::TestIndexer(None).resource()).as_str(),
-      )
-      .with_status(200)
-      .match_header("X-Api-Key", "test1234")
-      .match_body(Matcher::Json(indexer_details_json.clone()))
-      .with_body("{}")
-      .create_async()
-      .await;
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
-
-    if let SonarrSerdeable::Value(value) = network
-      .handle_sonarr_event(SonarrEvent::TestIndexer(Some(1)))
-      .await
-      .unwrap()
-    {
-      async_details_server.assert_async().await;
-      async_test_server.assert_async().await;
-      assert_eq!(value, json!({}));
-    }
-  }
-
   #[tokio::test]
   async fn test_handle_test_all_sonarr_indexers_event() {
     let indexers = vec![