fix(radarr): Pass in the indexer id with all TestIndexer events when publishing to the networking channel

src/app/radarr/mod.rs

@@ -77,7 +77,7 @@ impl<'a> App<'a> {
       }
       ActiveRadarrBlock::TestIndexer => {
         self
-          .dispatch_network_event(RadarrEvent::TestIndexer(None).into())
+          .dispatch_network_event(RadarrEvent::TestIndexer(self.extract_indexer_id().await).into())
           .await;
       }
       ActiveRadarrBlock::TestAllIndexers => {
@@ -233,4 +233,14 @@ impl<'a> App<'a> {
   async fn extract_movie_search_query(&self) -> String {
     self.data.radarr_data.add_movie_search.as_ref().expect("Add movie search is empty").text.clone()
   }
+  
+  async fn extract_indexer_id(&self) -> i64 {
+    self
+      .data
+      .radarr_data
+      .indexers
+      .current_selection()
+      .clone()
+      .id
+  }
 }

src/cli/radarr/mod.rs

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

src/cli/radarr/radarr_command_tests.rs

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

src/handlers/radarr_handlers/system/system_details_handler.rs

@@ -21,7 +21,7 @@ pub(super) struct SystemDetailsHandler<'a, 'b> {
 
 impl<'a, 'b> SystemDetailsHandler<'a, 'b> {
   fn extract_task_name(&self) -> RadarrTaskName {
-    self.app.data.radarr_data.tasks.current_selection().task_name.clone()
+    self.app.data.radarr_data.tasks.current_selection().task_name
   }
 }
 

src/network/radarr_network.rs

@@ -71,7 +71,7 @@ pub enum RadarrEvent {
   HealthCheck,
   SearchNewMovie(String),
   StartTask(RadarrTaskName),
-  TestIndexer(Option<i64>),
+  TestIndexer(i64),
   TestAllIndexers,
   TriggerAutomaticSearch(Option<i64>),
   UpdateAllMovies,
@@ -1632,7 +1632,7 @@ impl<'a, 'b> Network<'a, 'b> {
   }
 
   async fn start_radarr_task(&mut self, task_name: RadarrTaskName) -> Result<Value> {
-    let event = RadarrEvent::StartTask(task_name.clone());
+    let event = RadarrEvent::StartTask(task_name);
 
     info!("Starting Radarr task: {task_name}");
 
@@ -1647,32 +1647,19 @@ impl<'a, 'b> Network<'a, 'b> {
       .await
   }
 
-  async fn test_radarr_indexer(&mut self, indexer_id: Option<i64>) -> Result<Value> {
+  async fn test_radarr_indexer(&mut self, indexer_id: i64) -> Result<Value> {
     let detail_event = RadarrEvent::GetIndexers;
-    let event = RadarrEvent::TestIndexer(None);
-    let id = if let Some(i_id) = indexer_id {
-      i_id
-    } else {
-      self
-        .app
-        .lock()
-        .await
-        .data
-        .radarr_data
-        .indexers
-        .current_selection()
-        .id
-    };
-    info!("Testing Radarr indexer with ID: {id}");
+    let event = RadarrEvent::TestIndexer(indexer_id);
+    info!("Testing Radarr indexer with ID: {indexer_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/radarr_network_tests.rs

@@ -228,7 +228,7 @@ mod test {
   #[case(RadarrEvent::GetStatus, "/system/status")]
   #[case(RadarrEvent::GetTasks, "/system/task")]
   #[case(RadarrEvent::GetUpdates, "/update")]
-  #[case(RadarrEvent::TestIndexer(None), "/indexer/test")]
+  #[case(RadarrEvent::TestIndexer(0), "/indexer/test")]
   #[case(RadarrEvent::TestAllIndexers, "/indexer/testall")]
   #[case(RadarrEvent::HealthCheck, "/health")]
   fn test_resource(#[case] event: RadarrEvent, #[case] expected_uri: String) {
@@ -756,7 +756,7 @@ mod test {
     let async_test_server = server
       .mock(
         "POST",
-        format!("/api/v3{}", RadarrEvent::TestIndexer(None).resource()).as_str(),
+        format!("/api/v3{}", RadarrEvent::TestIndexer(1).resource()).as_str(),
       )
       .with_status(400)
       .match_header("X-Api-Key", "test1234")
@@ -764,17 +764,10 @@ mod test {
       .with_body(response_json.to_string())
       .create_async()
       .await;
-    app_arc
-      .lock()
-      .await
-      .data
-      .radarr_data
-      .indexers
-      .set_items(vec![indexer()]);
     let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
 
     if let RadarrSerdeable::Value(value) = network
-      .handle_radarr_event(RadarrEvent::TestIndexer(None))
+      .handle_radarr_event(RadarrEvent::TestIndexer(1))
       .await
       .unwrap()
     {
@@ -825,7 +818,7 @@ mod test {
     let async_test_server = server
       .mock(
         "POST",
-        format!("/api/v3{}", RadarrEvent::TestIndexer(None).resource()).as_str(),
+        format!("/api/v3{}", RadarrEvent::TestIndexer(1).resource()).as_str(),
       )
       .with_status(200)
       .match_header("X-Api-Key", "test1234")
@@ -833,17 +826,10 @@ mod test {
       .with_body("{}")
       .create_async()
       .await;
-    app_arc
-      .lock()
-      .await
-      .data
-      .radarr_data
-      .indexers
-      .set_items(vec![indexer()]);
     let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
 
     if let RadarrSerdeable::Value(value) = network
-      .handle_radarr_event(RadarrEvent::TestIndexer(None))
+      .handle_radarr_event(RadarrEvent::TestIndexer(1))
       .await
       .unwrap()
     {
@@ -857,64 +843,6 @@ mod test {
     }
   }
 
-  #[tokio::test]
-  async fn test_handle_test_radarr_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,
-      RadarrEvent::GetIndexers,
-      Some("/1"),
-      None,
-    )
-    .await;
-    let async_test_server = server
-      .mock(
-        "POST",
-        format!("/api/v3{}", RadarrEvent::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 RadarrSerdeable::Value(value) = network
-      .handle_radarr_event(RadarrEvent::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_radarr_indexers_event() {
     let indexers = vec![