fix(radarr): Construct and pass edit collection parameters alongside the EditCollection event when publishing to the networking channel

src/cli/radarr/edit_command_handler.rs

@@ -420,7 +420,7 @@ impl<'a, 'b> CliCommandHandler<'a, 'b, RadarrEditCommand> for RadarrEditCommandH
         };
         self
           .network
-          .handle_network_event(RadarrEvent::EditCollection(Some(edit_collection_params)).into())
+          .handle_network_event(RadarrEvent::EditCollection(edit_collection_params).into())
           .await?;
         "Collection updated".to_owned()
       }

src/cli/radarr/edit_command_handler_tests.rs

@@ -1047,7 +1047,7 @@ mod tests {
       mock_network
         .expect_handle_network_event()
         .with(eq::<NetworkEvent>(
-          RadarrEvent::EditCollection(Some(expected_edit_collection_params)).into(),
+          RadarrEvent::EditCollection(expected_edit_collection_params).into(),
         ))
         .times(1)
         .returning(|_| {
@@ -1089,7 +1089,7 @@ mod tests {
       mock_network
         .expect_handle_network_event()
         .with(eq::<NetworkEvent>(
-          RadarrEvent::EditCollection(Some(expected_edit_collection_params)).into(),
+          RadarrEvent::EditCollection(expected_edit_collection_params).into(),
         ))
         .times(1)
         .returning(|_| {
@@ -1131,7 +1131,7 @@ mod tests {
       mock_network
         .expect_handle_network_event()
         .with(eq::<NetworkEvent>(
-          RadarrEvent::EditCollection(Some(expected_edit_collection_params)).into(),
+          RadarrEvent::EditCollection(expected_edit_collection_params).into(),
         ))
         .times(1)
         .returning(|_| {

src/handlers/radarr_handlers/collections/edit_collection_handler.rs

@@ -2,6 +2,8 @@ use crate::app::key_binding::DEFAULT_KEYBINDINGS;
 use crate::app::App;
 use crate::event::Key;
 use crate::handlers::{handle_prompt_toggle, KeyEventHandler};
+use crate::models::radarr_models::EditCollectionParams;
+use crate::models::servarr_data::radarr::modals::EditCollectionModal;
 use crate::models::servarr_data::radarr::radarr_data::{ActiveRadarrBlock, EDIT_COLLECTION_BLOCKS};
 use crate::models::Scrollable;
 use crate::network::radarr_network::RadarrEvent;
@@ -18,6 +20,45 @@ pub(super) struct EditCollectionHandler<'a, 'b> {
   context: Option<ActiveRadarrBlock>,
 }
 
+impl<'a, 'b> EditCollectionHandler<'a, 'b> {
+  fn build_edit_collection_params(&mut self) -> EditCollectionParams {
+    let collection_id = self.app.data.radarr_data.collections.current_selection().id;
+    let EditCollectionModal {
+      path,
+      search_on_add,
+      minimum_availability_list,
+      monitored,
+      quality_profile_list,
+    } = self.app.data.radarr_data.edit_collection_modal.as_ref().unwrap();
+    let quality_profile = quality_profile_list.current_selection();
+    let quality_profile_id = *self.app
+      .data
+      .radarr_data
+      .quality_profile_map
+      .iter()
+      .filter(|(_, value)| *value == quality_profile)
+      .map(|(key, _)| key)
+      .next()
+      .unwrap();
+
+    let root_folder_path: String = path.text.clone();
+    let monitored = monitored.unwrap_or_default();
+    let search_on_add = search_on_add.unwrap_or_default();
+    let minimum_availability = *minimum_availability_list.current_selection();
+    self.app.data.radarr_data.edit_collection_modal = None;
+
+
+    EditCollectionParams {
+      collection_id,
+      monitored: Some(monitored),
+      minimum_availability: Some(minimum_availability),
+      quality_profile_id: Some(quality_profile_id),
+      root_folder_path: Some(root_folder_path),
+      search_on_add: Some(search_on_add)
+    }
+  }
+}
+
 impl<'a, 'b> KeyEventHandler<'a, 'b, ActiveRadarrBlock> for EditCollectionHandler<'a, 'b> {
   fn accepts(active_block: ActiveRadarrBlock) -> bool {
     EDIT_COLLECTION_BLOCKS.contains(&active_block)
@@ -191,7 +232,7 @@ impl<'a, 'b> KeyEventHandler<'a, 'b, ActiveRadarrBlock> for EditCollectionHandle
           ActiveRadarrBlock::EditCollectionConfirmPrompt => {
             if self.app.data.radarr_data.prompt_confirm {
               self.app.data.radarr_data.prompt_confirm_action =
-                Some(RadarrEvent::EditCollection(None));
+                Some(RadarrEvent::EditCollection(self.build_edit_collection_params()));
               self.app.should_refresh = true;
             }
 
@@ -310,7 +351,7 @@ impl<'a, 'b> KeyEventHandler<'a, 'b, ActiveRadarrBlock> for EditCollectionHandle
           && key == DEFAULT_KEYBINDINGS.confirm.key
         {
           self.app.data.radarr_data.prompt_confirm = true;
-          self.app.data.radarr_data.prompt_confirm_action = Some(RadarrEvent::EditCollection(None));
+          self.app.data.radarr_data.prompt_confirm_action = Some(RadarrEvent::EditCollection(self.build_edit_collection_params()));
           self.app.should_refresh = true;
 
           self.app.pop_navigation_stack();

src/handlers/radarr_handlers/collections/edit_collection_handler_tests.rs

@@ -1,5 +1,6 @@
 #[cfg(test)]
 mod tests {
+  use bimap::BiMap;
   use pretty_assertions::assert_str_eq;
   use strum::IntoEnumIterator;
 
@@ -7,8 +8,9 @@ mod tests {
   use crate::app::App;
   use crate::event::Key;
   use crate::handlers::radarr_handlers::collections::edit_collection_handler::EditCollectionHandler;
+  use crate::handlers::radarr_handlers::radarr_handler_test_utils::utils::collection;
   use crate::handlers::KeyEventHandler;
-  use crate::models::radarr_models::MinimumAvailability;
+  use crate::models::radarr_models::{Collection, EditCollectionParams, MinimumAvailability};
   use crate::models::servarr_data::radarr::modals::EditCollectionModal;
   use crate::models::servarr_data::radarr::radarr_data::{
     ActiveRadarrBlock, EDIT_COLLECTION_BLOCKS,
@@ -519,7 +521,34 @@ mod tests {
     #[test]
     fn test_edit_collection_confirm_prompt_prompt_confirmation_submit() {
       let mut app = App::default();
-      app.data.radarr_data.edit_collection_modal = Some(EditCollectionModal::default());
+      let mut edit_collection_modal = EditCollectionModal {
+        path: "/nfs/Test Path".into(),
+        monitored: Some(false),
+        search_on_add: Some(false),
+        ..EditCollectionModal::default()
+      };
+      edit_collection_modal
+        .quality_profile_list
+        .set_items(vec!["Any".to_owned(), "HD - 1080p".to_owned()]);
+      edit_collection_modal
+        .minimum_availability_list
+        .set_items(Vec::from_iter(MinimumAvailability::iter()));
+      app.data.radarr_data.edit_collection_modal = Some(edit_collection_modal);
+      app.data.radarr_data.collections.set_items(vec![Collection {
+        monitored: false,
+        search_on_add: false,
+        ..collection()
+      }]);
+      app.data.radarr_data.quality_profile_map =
+        BiMap::from_iter([(1111, "Any".to_owned()), (2222, "HD - 1080p".to_owned())]);
+      let expected_edit_collection_params = EditCollectionParams {
+        collection_id: 123,
+        monitored: Some(false),
+        minimum_availability: Some(MinimumAvailability::Announced),
+        quality_profile_id: Some(1111),
+        root_folder_path: Some("/nfs/Test Path".to_owned()),
+        search_on_add: Some(false),
+      };
       app.push_navigation_stack(ActiveRadarrBlock::Collections.into());
       app.push_navigation_stack(ActiveRadarrBlock::EditCollectionPrompt.into());
       app.data.radarr_data.prompt_confirm = true;
@@ -545,9 +574,10 @@ mod tests {
       );
       assert_eq!(
         app.data.radarr_data.prompt_confirm_action,
-        Some(RadarrEvent::EditCollection(None))
+        Some(RadarrEvent::EditCollection(expected_edit_collection_params))
       );
       assert!(app.should_refresh);
+      assert!(app.data.radarr_data.edit_collection_modal.is_none());
     }
 
     #[test]
@@ -919,7 +949,34 @@ mod tests {
     #[test]
     fn test_edit_collection_confirm_prompt_prompt_confirmation_confirm() {
       let mut app = App::default();
-      app.data.radarr_data.edit_collection_modal = Some(EditCollectionModal::default());
+      let mut edit_collection_modal = EditCollectionModal {
+        path: "/nfs/Test Path".into(),
+        monitored: Some(false),
+        search_on_add: Some(false),
+        ..EditCollectionModal::default()
+      };
+      edit_collection_modal
+        .quality_profile_list
+        .set_items(vec!["Any".to_owned(), "HD - 1080p".to_owned()]);
+      edit_collection_modal
+        .minimum_availability_list
+        .set_items(Vec::from_iter(MinimumAvailability::iter()));
+      app.data.radarr_data.edit_collection_modal = Some(edit_collection_modal);
+      app.data.radarr_data.collections.set_items(vec![Collection {
+        monitored: false,
+        search_on_add: false,
+        ..collection()
+      }]);
+      app.data.radarr_data.quality_profile_map =
+        BiMap::from_iter([(1111, "Any".to_owned()), (2222, "HD - 1080p".to_owned())]);
+      let expected_edit_collection_params = EditCollectionParams {
+        collection_id: 123,
+        monitored: Some(false),
+        minimum_availability: Some(MinimumAvailability::Announced),
+        quality_profile_id: Some(1111),
+        root_folder_path: Some("/nfs/Test Path".to_owned()),
+        search_on_add: Some(false),
+      };
       app.push_navigation_stack(ActiveRadarrBlock::Collections.into());
       app.push_navigation_stack(ActiveRadarrBlock::EditCollectionPrompt.into());
       app.data.radarr_data.selected_block =
@@ -944,9 +1001,10 @@ mod tests {
       );
       assert_eq!(
         app.data.radarr_data.prompt_confirm_action,
-        Some(RadarrEvent::EditCollection(None))
+        Some(RadarrEvent::EditCollection(expected_edit_collection_params))
       );
       assert!(app.should_refresh);
+      assert!(app.data.radarr_data.edit_collection_modal.is_none());
     }
   }
 
@@ -961,6 +1019,49 @@ mod tests {
     });
   }
 
+  #[test]
+  fn test_build_edit_collection_params() {
+    let mut app = App::default();
+    let mut edit_collection_modal = EditCollectionModal {
+      path: "/nfs/Test Path".into(),
+      monitored: Some(false),
+      search_on_add: Some(false),
+      ..EditCollectionModal::default()
+    };
+    edit_collection_modal
+      .quality_profile_list
+      .set_items(vec!["Any".to_owned(), "HD - 1080p".to_owned()]);
+    edit_collection_modal
+      .minimum_availability_list
+      .set_items(Vec::from_iter(MinimumAvailability::iter()));
+    app.data.radarr_data.edit_collection_modal = Some(edit_collection_modal);
+    app.data.radarr_data.collections.set_items(vec![Collection {
+      monitored: false,
+      search_on_add: false,
+      ..collection()
+    }]);
+    app.data.radarr_data.quality_profile_map =
+      BiMap::from_iter([(1111, "Any".to_owned()), (2222, "HD - 1080p".to_owned())]);
+    let expected_edit_collection_params = EditCollectionParams {
+      collection_id: 123,
+      monitored: Some(false),
+      minimum_availability: Some(MinimumAvailability::Announced),
+      quality_profile_id: Some(1111),
+      root_folder_path: Some("/nfs/Test Path".to_owned()),
+      search_on_add: Some(false),
+    };
+
+    let edit_collection_params = EditCollectionHandler::with(
+      DEFAULT_KEYBINDINGS.esc.key,
+      &mut app,
+      ActiveRadarrBlock::EditCollectionPrompt,
+      None,
+    ).build_edit_collection_params();
+
+    assert_eq!(edit_collection_params, expected_edit_collection_params);
+    assert!(app.data.radarr_data.edit_collection_modal.is_none());
+  }
+
   #[test]
   fn test_edit_collection_handler_is_not_ready_when_loading() {
     let mut app = App::default();

src/network/radarr_network.rs

@@ -14,9 +14,7 @@ use crate::models::radarr_models::{
   RadarrTask, RadarrTaskName, SystemStatus,
 };
 use crate::models::servarr_data::modals::{EditIndexerModal, IndexerTestResultModalItem};
-use crate::models::servarr_data::radarr::modals::{
+use crate::models::servarr_data::radarr::modals::{EditMovieModal, MovieDetailsModal};
-  EditCollectionModal, EditMovieModal, MovieDetailsModal,
-};
 use crate::models::servarr_data::radarr::radarr_data::ActiveRadarrBlock;
 use crate::models::servarr_models::{
   AddRootFolderBody, CommandBody, DiskSpace, EditIndexerParams, HostConfig, Indexer, LogResponse,
@@ -47,7 +45,7 @@ pub enum RadarrEvent {
   DeleteTag(i64),
   DownloadRelease(RadarrReleaseDownloadBody),
   EditAllIndexerSettings(IndexerSettings),
-  EditCollection(Option<EditCollectionParams>),
+  EditCollection(EditCollectionParams),
   EditIndexer(Option<EditIndexerParams>),
   EditMovie(Option<EditMovieParams>),
   GetBlocklist,
@@ -462,11 +460,9 @@ impl<'a, 'b> Network<'a, 'b> {
       )
       .await;
 
-    let resp = self
+    self
       .handle_request::<(), ()>(request_props, |_, _| ())
-      .await;
+      .await
-
-    resp
   }
 
   async fn delete_radarr_root_folder(&mut self, root_folder_id: i64) -> Result<()> {
@@ -517,27 +513,21 @@ impl<'a, 'b> Network<'a, 'b> {
       .request_props_from(event, RequestMethod::Put, Some(params), None, None)
       .await;
 
-    let resp = self
+    self
       .handle_request::<IndexerSettings, Value>(request_props, |_, _| {})
-      .await;
+      .await
-
-    resp
   }
 
   async fn edit_collection(
     &mut self,
-    edit_collection_params: Option<EditCollectionParams>,
+    edit_collection_params: EditCollectionParams,
   ) -> Result<()> {
     info!("Editing Radarr collection");
     let detail_event = RadarrEvent::GetCollections;
-    let event = RadarrEvent::EditCollection(None);
+    let event = RadarrEvent::EditCollection(edit_collection_params.clone());
     info!("Fetching collection details");
+    let collection_id = edit_collection_params.collection_id;
 
-    let collection_id = if let Some(ref params) = edit_collection_params {
-      params.collection_id
-    } else {
-      self.extract_collection_id().await
-    };
     let request_props = self
       .request_props_from(
         detail_event,
@@ -559,80 +549,46 @@ impl<'a, 'b> Network<'a, 'b> {
     info!("Constructing edit collection body");
 
     let mut detailed_collection_body: Value = serde_json::from_str(&response)?;
-    let (monitored, minimum_availability, quality_profile_id, root_folder_path, search_on_add) =
+    let (monitored, minimum_availability, quality_profile_id, root_folder_path, search_on_add) = {
-      if let Some(params) = edit_collection_params {
+      let monitored = edit_collection_params.monitored.unwrap_or_else(|| {
-        let monitored = params.monitored.unwrap_or_else(|| {
+        detailed_collection_body["monitored"]
-          detailed_collection_body["monitored"]
+          .as_bool()
-            .as_bool()
+          .expect("Unable to deserialize 'monitored' bool")
-            .expect("Unable to deserialize 'monitored' bool")
+      });
-        });
+      let minimum_availability = edit_collection_params
-        let minimum_availability = params
+        .minimum_availability
-          .minimum_availability
+        .unwrap_or_else(|| {
-          .unwrap_or_else(|| {
+          serde_json::from_value(detailed_collection_body["minimumAvailability"].clone())
-            serde_json::from_value(detailed_collection_body["minimumAvailability"].clone())
+            .expect("Unable to deserialize 'minimumAvailability'")
-              .expect("Unable to deserialize 'minimumAvailability'")
+        })
-          })
+        .to_string();
-          .to_string();
+      let quality_profile_id = edit_collection_params.quality_profile_id.unwrap_or_else(|| {
-        let quality_profile_id = params.quality_profile_id.unwrap_or_else(|| {
+        detailed_collection_body["qualityProfileId"]
-          detailed_collection_body["qualityProfileId"]
+          .as_i64()
-            .as_i64()
+          .expect("Unable to deserialize 'qualityProfileId'")
-            .expect("Unable to deserialize 'qualityProfileId'")
+      });
-        });
+      let root_folder_path = edit_collection_params.root_folder_path.unwrap_or_else(|| {
-        let root_folder_path = params.root_folder_path.unwrap_or_else(|| {
+        detailed_collection_body["rootFolderPath"]
-          detailed_collection_body["rootFolderPath"]
+          .as_str()
-            .as_str()
+          .expect("Unable to deserialize 'rootFolderPath'")
-            .expect("Unable to deserialize 'rootFolderPath'")
+          .to_owned()
-            .to_owned()
+      });
-        });
+      let search_on_add = edit_collection_params.search_on_add.unwrap_or_else(|| {
-        let search_on_add = params.search_on_add.unwrap_or_else(|| {
+        detailed_collection_body["searchOnAdd"]
-          detailed_collection_body["searchOnAdd"]
+          .as_bool()
-            .as_bool()
+          .expect("Unable to deserialize 'searchOnAdd'")
-            .expect("Unable to deserialize 'searchOnAdd'")
+      });
-        });
 
-        (
+      (
-          monitored,
+        monitored,
-          minimum_availability,
+        minimum_availability,
-          quality_profile_id,
+        quality_profile_id,
-          root_folder_path,
+        root_folder_path,
-          search_on_add,
+        search_on_add,
-        )
+      )
-      } else {
+    };
-        let mut app = self.app.lock().await;
-        let EditCollectionModal {
-          path,
-          search_on_add,
-          minimum_availability_list,
-          monitored,
-          quality_profile_list,
-        } = app.data.radarr_data.edit_collection_modal.as_ref().unwrap();
-        let quality_profile = quality_profile_list.current_selection();
-        let quality_profile_id = *app
-          .data
-          .radarr_data
-          .quality_profile_map
-          .iter()
-          .filter(|(_, value)| *value == quality_profile)
-          .map(|(key, _)| key)
-          .next()
-          .unwrap();
 
-        let root_folder_path: String = path.text.clone();
+      * detailed_collection_body.get_mut("monitored").unwrap() = json!(monitored);
-        let monitored = monitored.unwrap_or_default();
-        let search_on_add = search_on_add.unwrap_or_default();
-        let minimum_availability = minimum_availability_list.current_selection().to_string();
-        app.data.radarr_data.edit_collection_modal = None;
-
-        (
-          monitored,
-          minimum_availability,
-          quality_profile_id,
-          root_folder_path,
-          search_on_add,
-        )
-      };
-
-    *detailed_collection_body.get_mut("monitored").unwrap() = json!(monitored);
     *detailed_collection_body
       .get_mut("minimumAvailability")
       .unwrap() = json!(minimum_availability);
@@ -2069,18 +2025,6 @@ impl<'a, 'b> Network<'a, 'b> {
     };
     (movie_id, format!("movieId={movie_id}"))
   }
-
-  async fn extract_collection_id(&mut self) -> i64 {
-    self
-      .app
-      .lock()
-      .await
-      .data
-      .radarr_data
-      .collections
-      .current_selection()
-      .id
-  }
 }
 
 fn get_movie_status(has_file: bool, downloads_vec: &[DownloadRecord], movie_id: i64) -> String {

src/network/radarr_network_tests.rs

@@ -15,8 +15,8 @@ mod test {
 
   use crate::app::ServarrConfig;
   use crate::models::radarr_models::{
-    AddMovieOptions, BlocklistItem, BlocklistItemMovie, CollectionMovie, IndexerSettings,
+    AddMovieOptions, BlocklistItem, BlocklistItemMovie, CollectionMovie, EditCollectionParams,
-    MediaInfo, MinimumAvailability, MovieCollection, MovieFile, Rating, RatingsList
+    IndexerSettings, MediaInfo, MinimumAvailability, MovieCollection, MovieFile, Rating, RatingsList
   };
   use crate::models::servarr_data::radarr::radarr_data::ActiveRadarrBlock;
   use crate::models::servarr_models::{
@@ -130,7 +130,7 @@ mod test {
 
   #[rstest]
   fn test_resource_collection(
-    #[values(RadarrEvent::GetCollections, RadarrEvent::EditCollection(None))] event: RadarrEvent,
+    #[values(RadarrEvent::GetCollections, RadarrEvent::EditCollection(EditCollectionParams::default()))] event: RadarrEvent,
   ) {
     assert_str_eq!(event.resource(), "/collection");
   }
@@ -3395,132 +3395,6 @@ mod test {
     *expected_body.get_mut("qualityProfileId").unwrap() = json!(1111);
     *expected_body.get_mut("rootFolderPath").unwrap() = json!("/nfs/Test Path");
     *expected_body.get_mut("searchOnAdd").unwrap() = json!(false);
-
-    let (async_details_server, app_arc, mut server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(detailed_collection_body),
-      None,
-      RadarrEvent::GetCollections,
-      Some("/123"),
-      None,
-    )
-    .await;
-    let async_edit_server = server
-      .mock(
-        "PUT",
-        format!(
-          "/api/v3{}/123",
-          RadarrEvent::EditCollection(None).resource()
-        )
-        .as_str(),
-      )
-      .with_status(202)
-      .match_header("X-Api-Key", "test1234")
-      .match_body(Matcher::Json(expected_body))
-      .create_async()
-      .await;
-    {
-      let mut app = app_arc.lock().await;
-      let mut edit_collection_modal = EditCollectionModal {
-        path: "/nfs/Test Path".into(),
-        monitored: Some(false),
-        search_on_add: Some(false),
-        ..EditCollectionModal::default()
-      };
-      edit_collection_modal
-        .quality_profile_list
-        .set_items(vec!["Any".to_owned(), "HD - 1080p".to_owned()]);
-      edit_collection_modal
-        .minimum_availability_list
-        .set_items(Vec::from_iter(MinimumAvailability::iter()));
-      app.data.radarr_data.edit_collection_modal = Some(edit_collection_modal);
-      app.data.radarr_data.collections.set_items(vec![Collection {
-        monitored: false,
-        search_on_add: false,
-        ..collection()
-      }]);
-      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(), Client::new());
-
-    assert!(network
-      .handle_radarr_event(RadarrEvent::EditCollection(None))
-      .await
-      .is_ok());
-
-    async_details_server.assert_async().await;
-    async_edit_server.assert_async().await;
-
-    let app = app_arc.lock().await;
-    assert!(app.data.radarr_data.edit_collection_modal.is_none());
-  }
-
-  #[tokio::test]
-  async fn test_handle_edit_collection_event_uses_provided_parameters() {
-    let detailed_collection_body = json!({
-      "id": 123,
-      "title": "Test Collection",
-      "rootFolderPath": "/nfs/movies",
-      "searchOnAdd": true,
-      "monitored": true,
-      "minimumAvailability": "released",
-      "overview": "Collection blah blah blah",
-      "qualityProfileId": 2222,
-      "movies": [
-        {
-          "title": "Test",
-          "overview": "Collection blah blah blah",
-          "year": 2023,
-          "runtime": 120,
-          "tmdbId": 1234,
-          "genres": ["cool", "family", "fun"],
-          "ratings": {
-            "imdb": {
-              "value": 9.9
-            },
-            "tmdb": {
-              "value": 9.9
-            },
-            "rottenTomatoes": {
-              "value": 9.9
-            }
-          }
-        }
-      ]
-    });
-    let mut expected_body = detailed_collection_body.clone();
-    *expected_body.get_mut("monitored").unwrap() = json!(false);
-    *expected_body.get_mut("minimumAvailability").unwrap() = json!("announced");
-    *expected_body.get_mut("qualityProfileId").unwrap() = json!(1111);
-    *expected_body.get_mut("rootFolderPath").unwrap() = json!("/nfs/Test Path");
-    *expected_body.get_mut("searchOnAdd").unwrap() = json!(false);
-
-    let (async_details_server, app_arc, mut server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(detailed_collection_body),
-      None,
-      RadarrEvent::GetCollections,
-      Some("/123"),
-      None,
-    )
-    .await;
-    let async_edit_server = server
-      .mock(
-        "PUT",
-        format!(
-          "/api/v3{}/123",
-          RadarrEvent::EditCollection(None).resource()
-        )
-        .as_str(),
-      )
-      .with_status(202)
-      .match_header("X-Api-Key", "test1234")
-      .match_body(Matcher::Json(expected_body))
-      .create_async()
-      .await;
     let edit_collection_params = EditCollectionParams {
       collection_id: 123,
       monitored: Some(false),
@@ -3529,10 +3403,35 @@ mod test {
       root_folder_path: Some("/nfs/Test Path".to_owned()),
       search_on_add: Some(false),
     };
+
+    let (async_details_server, app_arc, mut server) = mock_servarr_api(
+      RequestMethod::Get,
+      None,
+      Some(detailed_collection_body),
+      None,
+      RadarrEvent::GetCollections,
+      Some("/123"),
+      None,
+    )
+    .await;
+    let async_edit_server = server
+      .mock(
+        "PUT",
+        format!(
+          "/api/v3{}/123",
+          RadarrEvent::EditCollection(edit_collection_params.clone()).resource()
+        )
+        .as_str(),
+      )
+      .with_status(202)
+      .match_header("X-Api-Key", "test1234")
+      .match_body(Matcher::Json(expected_body))
+      .create_async()
+      .await;
     let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
 
     assert!(network
-      .handle_radarr_event(RadarrEvent::EditCollection(Some(edit_collection_params)))
+      .handle_radarr_event(RadarrEvent::EditCollection(edit_collection_params))
       .await
       .is_ok());
 
@@ -3541,7 +3440,7 @@ mod test {
   }
 
   #[tokio::test]
-  async fn test_handle_edit_collection_event_uses_provided_parameters_defaults_to_previous_values_when_none(
+  async fn test_handle_edit_collection_event_defaults_to_previous_values_when_no_params_are_provided(
   ) {
     let detailed_collection_body = json!({
       "id": 123,
@@ -3591,12 +3490,16 @@ mod test {
       None,
     )
     .await;
+    let edit_collection_params = EditCollectionParams {
+      collection_id: 123,
+      ..EditCollectionParams::default()
+    };
     let async_edit_server = server
       .mock(
         "PUT",
         format!(
           "/api/v3{}/123",
-          RadarrEvent::EditCollection(None).resource()
+          RadarrEvent::EditCollection(edit_collection_params).resource()
         )
         .as_str(),
       )
@@ -3612,7 +3515,7 @@ mod test {
     let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
 
     assert!(network
-      .handle_radarr_event(RadarrEvent::EditCollection(Some(edit_collection_params)))
+      .handle_radarr_event(RadarrEvent::EditCollection(edit_collection_params))
       .await
       .is_ok());
 
@@ -4526,38 +4429,6 @@ mod test {
     assert_str_eq!(movie_id_param, "movieId=1");
   }
 
-  #[tokio::test]
-  async fn test_extract_collection_id() {
-    let app_arc = Arc::new(Mutex::new(App::default()));
-    app_arc
-      .lock()
-      .await
-      .data
-      .radarr_data
-      .collections
-      .set_items(vec![Collection {
-        id: 1,
-        ..Collection::default()
-      }]);
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
-
-    assert_eq!(network.extract_collection_id().await, 1);
-  }
-
-  #[tokio::test]
-  async fn test_extract_collection_id_filtered_collection() {
-    let app_arc = Arc::new(Mutex::new(App::default()));
-    let mut filtered_collections = StatefulTable::default();
-    filtered_collections.set_filtered_items(vec![Collection {
-      id: 1,
-      ..Collection::default()
-    }]);
-    app_arc.lock().await.data.radarr_data.collections = filtered_collections;
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
-
-    assert_eq!(network.extract_collection_id().await, 1);
-  }
-
   #[test]
   fn test_get_movie_status_downloaded() {
     assert_str_eq!(get_movie_status(true, &[], 0), "Downloaded");