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

src/cli/radarr/edit_command_handler.rs

@@ -484,12 +484,13 @@ impl<'a, 'b> CliCommandHandler<'a, 'b, RadarrEditCommand> for RadarrEditCommandH
           quality_profile_id,
           root_folder_path,
           tags: tag,
+          tag_input_string: None,
           clear_tags,
         };
 
         self
           .network
-          .handle_network_event(RadarrEvent::EditMovie(Some(edit_movie_params)).into())
+          .handle_network_event(RadarrEvent::EditMovie(edit_movie_params).into())
           .await?;
         "Movie Updated".to_owned()
       }

src/cli/radarr/edit_command_handler_tests.rs

@@ -1330,13 +1330,14 @@ mod tests {
         quality_profile_id: Some(1),
         root_folder_path: Some("/nfs/test".to_owned()),
         tags: Some(vec![1, 2]),
+        tag_input_string: None,
         clear_tags: false,
       };
       let mut mock_network = MockNetworkTrait::new();
       mock_network
         .expect_handle_network_event()
         .with(eq::<NetworkEvent>(
-          RadarrEvent::EditMovie(Some(expected_edit_movie_params)).into(),
+          RadarrEvent::EditMovie(expected_edit_movie_params).into(),
         ))
         .times(1)
         .returning(|_| {
@@ -1372,13 +1373,14 @@ mod tests {
         quality_profile_id: Some(1),
         root_folder_path: Some("/nfs/test".to_owned()),
         tags: Some(vec![1, 2]),
+        tag_input_string: None,
         clear_tags: false,
       };
       let mut mock_network = MockNetworkTrait::new();
       mock_network
         .expect_handle_network_event()
         .with(eq::<NetworkEvent>(
-          RadarrEvent::EditMovie(Some(expected_edit_movie_params)).into(),
+          RadarrEvent::EditMovie(expected_edit_movie_params).into(),
         ))
         .times(1)
         .returning(|_| {
@@ -1414,13 +1416,14 @@ mod tests {
         quality_profile_id: Some(1),
         root_folder_path: Some("/nfs/test".to_owned()),
         tags: Some(vec![1, 2]),
+        tag_input_string: None,
         clear_tags: false,
       };
       let mut mock_network = MockNetworkTrait::new();
       mock_network
         .expect_handle_network_event()
         .with(eq::<NetworkEvent>(
-          RadarrEvent::EditMovie(Some(expected_edit_movie_params)).into(),
+          RadarrEvent::EditMovie(expected_edit_movie_params).into(),
         ))
         .times(1)
         .returning(|_| {

src/handlers/radarr_handlers/library/edit_movie_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::EditMovieParams;
+use crate::models::servarr_data::radarr::modals::EditMovieModal;
 use crate::models::servarr_data::radarr::radarr_data::{ActiveRadarrBlock, EDIT_MOVIE_BLOCKS};
 use crate::models::Scrollable;
 use crate::network::radarr_network::RadarrEvent;
@@ -18,6 +20,47 @@ pub(super) struct EditMovieHandler<'a, 'b> {
   context: Option<ActiveRadarrBlock>,
 }
 
+impl<'a, 'b> EditMovieHandler<'a, 'b> {
+  fn build_edit_movie_params(&mut self) -> EditMovieParams {
+    let movie_id = self.app.data.radarr_data.movies.current_selection().id;
+    let tags = self.app.data.radarr_data.edit_movie_modal.as_ref().unwrap().tags.text.clone();
+    let params = {
+      let EditMovieModal {
+        monitored,
+        path,
+        minimum_availability_list,
+        quality_profile_list,
+        ..
+      } = self.app.data.radarr_data.edit_movie_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();
+
+      EditMovieParams {
+        movie_id,
+        monitored: *monitored,
+        minimum_availability: Some(*minimum_availability_list.current_selection()),
+        quality_profile_id: Some(quality_profile_id),
+        root_folder_path: Some(path.text.clone()),
+        tags: None,
+        tag_input_string: Some(tags),
+        clear_tags: false,
+      }
+    };
+
+    self.app.data.radarr_data.edit_movie_modal = None;
+
+    params
+  }
+}
+
 impl<'a, 'b> KeyEventHandler<'a, 'b, ActiveRadarrBlock> for EditMovieHandler<'a, 'b> {
   fn accepts(active_block: ActiveRadarrBlock) -> bool {
     EDIT_MOVIE_BLOCKS.contains(&active_block)
@@ -222,7 +265,7 @@ impl<'a, 'b> KeyEventHandler<'a, 'b, ActiveRadarrBlock> for EditMovieHandler<'a,
         match self.app.data.radarr_data.selected_block.get_active_block() {
           ActiveRadarrBlock::EditMovieConfirmPrompt => {
             if self.app.data.radarr_data.prompt_confirm {
-              self.app.data.radarr_data.prompt_confirm_action = Some(RadarrEvent::EditMovie(None));
+              self.app.data.radarr_data.prompt_confirm_action = Some(RadarrEvent::EditMovie(self.build_edit_movie_params()));
               self.app.should_refresh = true;
             }
 
@@ -333,7 +376,7 @@ impl<'a, 'b> KeyEventHandler<'a, 'b, ActiveRadarrBlock> for EditMovieHandler<'a,
           && key == DEFAULT_KEYBINDINGS.confirm.key
         {
           self.app.data.radarr_data.prompt_confirm = true;
-          self.app.data.radarr_data.prompt_confirm_action = Some(RadarrEvent::EditMovie(None));
+          self.app.data.radarr_data.prompt_confirm_action = Some(RadarrEvent::EditMovie(self.build_edit_movie_params()));
           self.app.should_refresh = true;
 
           self.app.pop_navigation_stack();

src/handlers/radarr_handlers/library/edit_movie_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::library::edit_movie_handler::EditMovieHandler;
+  use crate::handlers::radarr_handlers::radarr_handler_test_utils::utils::movie;
   use crate::handlers::KeyEventHandler;
-  use crate::models::radarr_models::MinimumAvailability;
+  use crate::models::radarr_models::{EditMovieParams, MinimumAvailability, Movie};
   use crate::models::servarr_data::radarr::modals::EditMovieModal;
   use crate::models::servarr_data::radarr::radarr_data::{ActiveRadarrBlock, EDIT_MOVIE_BLOCKS};
 
@@ -641,7 +643,34 @@ mod tests {
     #[test]
     fn test_edit_movie_confirm_prompt_prompt_confirmation_submit() {
       let mut app = App::default();
-      app.data.radarr_data.edit_movie_modal = Some(EditMovieModal::default());
+      let mut edit_movie = EditMovieModal {
+        tags: "usenet, testing".to_owned().into(),
+        path: "/nfs/Test Path".to_owned().into(),
+        monitored: Some(false),
+        ..EditMovieModal::default()
+      };
+      edit_movie
+        .quality_profile_list
+        .set_items(vec!["Any".to_owned(), "HD - 1080p".to_owned()]);
+      edit_movie
+        .minimum_availability_list
+        .set_items(Vec::from_iter(MinimumAvailability::iter()));
+      app.data.radarr_data.edit_movie_modal = Some(edit_movie);
+      app.data.radarr_data.movies.set_items(vec![Movie {
+        monitored: false,
+        ..movie()
+      }]);
+      app.data.radarr_data.quality_profile_map =
+        BiMap::from_iter([(1111, "Any".to_owned()), (2222, "HD - 1080p".to_owned())]);
+      let expected_edit_movie_params = EditMovieParams {
+        movie_id: 1,
+        monitored: Some(false),
+        minimum_availability: Some(MinimumAvailability::Announced),
+        quality_profile_id: Some(1111),
+        root_folder_path: Some("/nfs/Test Path".to_owned()),
+        tag_input_string: Some("usenet, testing".into()),
+        ..EditMovieParams::default()
+      };
       app.push_navigation_stack(ActiveRadarrBlock::Movies.into());
       app.push_navigation_stack(ActiveRadarrBlock::EditMoviePrompt.into());
       app.data.radarr_data.prompt_confirm = true;
@@ -663,9 +692,9 @@ mod tests {
       assert_eq!(app.get_current_route(), ActiveRadarrBlock::Movies.into());
       assert_eq!(
         app.data.radarr_data.prompt_confirm_action,
-        Some(RadarrEvent::EditMovie(None))
+        Some(RadarrEvent::EditMovie(expected_edit_movie_params))
       );
-      assert!(app.data.radarr_data.edit_movie_modal.is_some());
+      assert!(app.data.radarr_data.edit_movie_modal.is_none());
       assert!(app.should_refresh);
     }
 
@@ -1053,7 +1082,34 @@ mod tests {
     #[test]
     fn test_edit_movie_confirm_prompt_prompt_confirm() {
       let mut app = App::default();
-      app.data.radarr_data.edit_movie_modal = Some(EditMovieModal::default());
+      let mut edit_movie = EditMovieModal {
+        tags: "usenet, testing".to_owned().into(),
+        path: "/nfs/Test Path".to_owned().into(),
+        monitored: Some(false),
+        ..EditMovieModal::default()
+      };
+      edit_movie
+        .quality_profile_list
+        .set_items(vec!["Any".to_owned(), "HD - 1080p".to_owned()]);
+      edit_movie
+        .minimum_availability_list
+        .set_items(Vec::from_iter(MinimumAvailability::iter()));
+      app.data.radarr_data.edit_movie_modal = Some(edit_movie);
+      app.data.radarr_data.movies.set_items(vec![Movie {
+        monitored: false,
+        ..movie()
+      }]);
+      app.data.radarr_data.quality_profile_map =
+        BiMap::from_iter([(1111, "Any".to_owned()), (2222, "HD - 1080p".to_owned())]);
+      let expected_edit_movie_params = EditMovieParams {
+        movie_id: 1,
+        monitored: Some(false),
+        minimum_availability: Some(MinimumAvailability::Announced),
+        quality_profile_id: Some(1111),
+        root_folder_path: Some("/nfs/Test Path".to_owned()),
+        tag_input_string: Some("usenet, testing".into()),
+        ..EditMovieParams::default()
+      };
       app.push_navigation_stack(ActiveRadarrBlock::Movies.into());
       app.push_navigation_stack(ActiveRadarrBlock::EditMoviePrompt.into());
       app.data.radarr_data.selected_block = BlockSelectionState::new(EDIT_MOVIE_SELECTION_BLOCKS);
@@ -1074,9 +1130,9 @@ mod tests {
       assert_eq!(app.get_current_route(), ActiveRadarrBlock::Movies.into());
       assert_eq!(
         app.data.radarr_data.prompt_confirm_action,
-        Some(RadarrEvent::EditMovie(None))
+        Some(RadarrEvent::EditMovie(expected_edit_movie_params))
       );
-      assert!(app.data.radarr_data.edit_movie_modal.is_some());
+      assert!(app.data.radarr_data.edit_movie_modal.is_none());
       assert!(app.should_refresh);
     }
   }
@@ -1092,6 +1148,49 @@ mod tests {
     });
   }
 
+  #[test]
+  fn test_build_edit_movie_params() {
+    let mut app = App::default();
+    let mut edit_movie = EditMovieModal {
+      tags: "usenet, testing".to_owned().into(),
+      path: "/nfs/Test Path".to_owned().into(),
+      monitored: Some(false),
+      ..EditMovieModal::default()
+    };
+    edit_movie
+      .quality_profile_list
+      .set_items(vec!["Any".to_owned(), "HD - 1080p".to_owned()]);
+    edit_movie
+      .minimum_availability_list
+      .set_items(Vec::from_iter(MinimumAvailability::iter()));
+    app.data.radarr_data.edit_movie_modal = Some(edit_movie);
+    app.data.radarr_data.movies.set_items(vec![Movie {
+      monitored: false,
+      ..movie()
+    }]);
+    app.data.radarr_data.quality_profile_map =
+      BiMap::from_iter([(1111, "Any".to_owned()), (2222, "HD - 1080p".to_owned())]);
+    let expected_edit_movie_params = EditMovieParams {
+      movie_id: 1,
+      monitored: Some(false),
+      minimum_availability: Some(MinimumAvailability::Announced),
+      quality_profile_id: Some(1111),
+      root_folder_path: Some("/nfs/Test Path".to_owned()),
+      tag_input_string: Some("usenet, testing".into()),
+      ..EditMovieParams::default()
+    };
+
+    let edit_movie_params = EditMovieHandler::with(
+      DEFAULT_KEYBINDINGS.esc.key,
+      &mut app,
+      ActiveRadarrBlock::EditMoviePrompt,
+      None,
+    ).build_edit_movie_params();
+
+    assert_eq!(edit_movie_params, expected_edit_movie_params);
+    assert!(app.data.radarr_data.edit_movie_modal.is_none());
+  }
+
   #[test]
   fn test_edit_movie_handler_is_not_ready_when_loading() {
     let mut app = App::default();

src/models/radarr_models.rs

@@ -190,6 +190,8 @@ pub struct EditMovieParams {
   pub quality_profile_id: Option<i64>,
   pub root_folder_path: Option<String>,
   pub tags: Option<Vec<i64>>,
+  #[serde(skip_serializing, skip_deserializing)]
+  pub tag_input_string: Option<String>,
   pub clear_tags: bool,
 }
 

src/network/radarr_network.rs

@@ -14,7 +14,7 @@ use crate::models::radarr_models::{
   RadarrTask, RadarrTaskName, SystemStatus,
 };
 use crate::models::servarr_data::modals::IndexerTestResultModalItem;
-use crate::models::servarr_data::radarr::modals::{EditMovieModal, MovieDetailsModal};
+use crate::models::servarr_data::radarr::modals::MovieDetailsModal;
 use crate::models::servarr_data::radarr::radarr_data::ActiveRadarrBlock;
 use crate::models::servarr_models::{
   AddRootFolderBody, CommandBody, DiskSpace, EditIndexerParams, HostConfig, Indexer, LogResponse,
@@ -47,7 +47,7 @@ pub enum RadarrEvent {
   EditAllIndexerSettings(IndexerSettings),
   EditCollection(EditCollectionParams),
   EditIndexer(EditIndexerParams),
-  EditMovie(Option<EditMovieParams>),
+  EditMovie(EditMovieParams),
   GetBlocklist,
   GetCollections,
   GetDownloads,
@@ -822,16 +822,18 @@ impl<'a, 'b> Network<'a, 'b> {
       .await
   }
 
-  async fn edit_movie(&mut self, edit_movie_params: Option<EditMovieParams>) -> Result<()> {
+  async fn edit_movie(&mut self, mut edit_movie_params: EditMovieParams) -> Result<()> {
     info!("Editing Radarr movie");
     let detail_event = RadarrEvent::GetMovieDetails(None);
-    let event = RadarrEvent::EditMovie(None);
+    let event = RadarrEvent::EditMovie(edit_movie_params.clone());
+    let movie_id = edit_movie_params.movie_id;
+    if let Some(tag_input_string) = edit_movie_params.tag_input_string.as_ref() {
+      let tag_ids_vec = self
+        .extract_and_add_radarr_tag_ids_vec(tag_input_string.clone())
+        .await;
+      edit_movie_params.tags = Some(tag_ids_vec);
+    }
 
-    let (movie_id, _) = if let Some(ref params) = edit_movie_params {
-      self.extract_movie_id(Some(params.movie_id)).await
-    } else {
-      self.extract_movie_id(None).await
-    };
     info!("Fetching movie details for movie with ID: {movie_id}");
 
     let request_props = self
@@ -856,34 +858,34 @@ impl<'a, 'b> Network<'a, 'b> {
 
     let mut detailed_movie_body: Value = serde_json::from_str(&response)?;
     let (monitored, minimum_availability, quality_profile_id, root_folder_path, tags) =
-      if let Some(params) = edit_movie_params {
+      {
-        let monitored = params.monitored.unwrap_or(
+        let monitored = edit_movie_params.monitored.unwrap_or(
           detailed_movie_body["monitored"]
             .as_bool()
             .expect("Unable to deserialize 'monitored'"),
         );
-        let minimum_availability = params
+        let minimum_availability = edit_movie_params
           .minimum_availability
           .unwrap_or_else(|| {
             serde_json::from_value(detailed_movie_body["minimumAvailability"].clone())
               .expect("Unable to deserialize 'minimumAvailability'")
           })
           .to_string();
-        let quality_profile_id = params.quality_profile_id.unwrap_or_else(|| {
+        let quality_profile_id = edit_movie_params.quality_profile_id.unwrap_or_else(|| {
           detailed_movie_body["qualityProfileId"]
             .as_i64()
             .expect("Unable to deserialize 'qualityProfileId'")
         });
-        let root_folder_path = params.root_folder_path.unwrap_or_else(|| {
+        let root_folder_path = edit_movie_params.root_folder_path.unwrap_or_else(|| {
           detailed_movie_body["path"]
             .as_str()
             .expect("Unable to deserialize 'path'")
             .to_owned()
         });
-        let tags = if params.clear_tags {
+        let tags = if edit_movie_params.clear_tags {
           vec![]
         } else {
-          params.tags.unwrap_or(
+          edit_movie_params.tags.unwrap_or(
             detailed_movie_body["tags"]
               .as_array()
               .expect("Unable to deserialize 'tags'")
@@ -900,53 +902,6 @@ impl<'a, 'b> Network<'a, 'b> {
           root_folder_path,
           tags,
         )
-      } else {
-        let tags = self
-          .app
-          .lock()
-          .await
-          .data
-          .radarr_data
-          .edit_movie_modal
-          .as_ref()
-          .unwrap()
-          .tags
-          .text
-          .clone();
-        let tag_ids_vec = self.extract_and_add_radarr_tag_ids_vec(tags).await;
-        let mut app = self.app.lock().await;
-
-        let params = {
-          let EditMovieModal {
-            monitored,
-            path,
-            minimum_availability_list,
-            quality_profile_list,
-            ..
-          } = app.data.radarr_data.edit_movie_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();
-
-          (
-            monitored.unwrap_or_default(),
-            minimum_availability_list.current_selection().to_string(),
-            quality_profile_id,
-            path.text.clone(),
-            tag_ids_vec,
-          )
-        };
-
-        app.data.radarr_data.edit_movie_modal = None;
-
-        params
       };
 
     *detailed_movie_body.get_mut("monitored").unwrap() = json!(monitored);

src/network/radarr_network_tests.rs

@@ -9,14 +9,13 @@ mod test {
   use reqwest::Client;
   use rstest::rstest;
   use serde_json::{json, Number, Value};
-  use strum::IntoEnumIterator;
   use tokio::sync::Mutex;
   use tokio_util::sync::CancellationToken;
 
   use crate::app::ServarrConfig;
   use crate::models::radarr_models::{
     AddMovieOptions, BlocklistItem, BlocklistItemMovie, CollectionMovie, EditCollectionParams,
-    IndexerSettings, MediaInfo, MinimumAvailability, MovieCollection, MovieFile, Rating, RatingsList
+    EditMovieParams, IndexerSettings, MediaInfo, MinimumAvailability, MovieCollection, MovieFile, Rating, RatingsList
   };
   use crate::models::servarr_data::radarr::radarr_data::ActiveRadarrBlock;
   use crate::models::servarr_models::{
@@ -119,7 +118,7 @@ mod test {
   fn test_resource_movie(
     #[values(
       RadarrEvent::AddMovie(AddMovieBody::default()),
-      RadarrEvent::EditMovie(None),
+      RadarrEvent::EditMovie(EditMovieParams::default()),
       RadarrEvent::GetMovies,
       RadarrEvent::GetMovieDetails(None),
       RadarrEvent::DeleteMovie(DeleteMovieParams::default())
@@ -4099,6 +4098,15 @@ mod test {
     *expected_body.get_mut("qualityProfileId").unwrap() = json!(1111);
     *expected_body.get_mut("path").unwrap() = json!("/nfs/Test Path");
     *expected_body.get_mut("tags").unwrap() = json!([1, 2]);
+    let edit_movie_params = EditMovieParams {
+      movie_id: 1,
+      monitored: Some(false),
+      minimum_availability: Some(MinimumAvailability::Announced),
+      quality_profile_id: Some(1111),
+      root_folder_path: Some("/nfs/Test Path".to_owned()),
+      tag_input_string: Some("usenet, testing".into()),
+      ..EditMovieParams::default()
+    };
 
     let (async_details_server, app_arc, mut server) = mock_servarr_api(
       RequestMethod::Get,
@@ -4113,80 +4121,34 @@ mod test {
     let async_edit_server = server
       .mock(
         "PUT",
-        format!("/api/v3{}/1", RadarrEvent::EditMovie(None).resource()).as_str(),
+        format!("/api/v3{}/1", RadarrEvent::EditMovie(edit_movie_params.clone()).resource()).as_str(),
       )
       .with_status(202)
       .match_header("X-Api-Key", "test1234")
       .match_body(Matcher::Json(expected_body))
       .create_async()
       .await;
-    {
+    app_arc.lock().await.data.radarr_data.tags_map =
-      let mut app = app_arc.lock().await;
+      BiMap::from_iter([(1, "usenet".to_owned()), (2, "testing".to_owned())]);
-      app.data.radarr_data.tags_map =
-        BiMap::from_iter([(1, "usenet".to_owned()), (2, "testing".to_owned())]);
-      let mut edit_movie = EditMovieModal {
-        tags: "usenet, testing".to_owned().into(),
-        path: "/nfs/Test Path".to_owned().into(),
-        monitored: Some(false),
-        ..EditMovieModal::default()
-      };
-      edit_movie
-        .quality_profile_list
-        .set_items(vec!["Any".to_owned(), "HD - 1080p".to_owned()]);
-      edit_movie
-        .minimum_availability_list
-        .set_items(Vec::from_iter(MinimumAvailability::iter()));
-      app.data.radarr_data.edit_movie_modal = Some(edit_movie);
-      app.data.radarr_data.movies.set_items(vec![Movie {
-        monitored: false,
-        ..movie()
-      }]);
-      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::EditMovie(None))
+      .handle_radarr_event(RadarrEvent::EditMovie(edit_movie_params))
       .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_movie_modal.is_none());
   }
 
   #[tokio::test]
-  async fn test_handle_edit_movie_event_uses_provided_parameters() {
+  async fn test_handle_edit_movie_event_does_not_overwrite_tags_vec_if_tag_input_string_is_none() {
     let mut expected_body: Value = serde_json::from_str(MOVIE_JSON).unwrap();
     *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("path").unwrap() = json!("/nfs/Test Path");
     *expected_body.get_mut("tags").unwrap() = json!([1, 2]);
-
-    let (async_details_server, app_arc, mut server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(serde_json::from_str(MOVIE_JSON).unwrap()),
-      None,
-      RadarrEvent::GetMovieDetails(None),
-      Some("/1"),
-      None,
-    )
-    .await;
-    let async_edit_server = server
-      .mock(
-        "PUT",
-        format!("/api/v3{}/1", RadarrEvent::EditMovie(None).resource()).as_str(),
-      )
-      .with_status(202)
-      .match_header("X-Api-Key", "test1234")
-      .match_body(Matcher::Json(expected_body))
-      .create_async()
-      .await;
     let edit_movie_params = EditMovieParams {
       movie_id: 1,
       monitored: Some(false),
@@ -4196,10 +4158,32 @@ mod test {
       tags: Some(vec![1, 2]),
       ..EditMovieParams::default()
     };
+    let (async_details_server, app_arc, mut server) = mock_servarr_api(
+      RequestMethod::Get,
+      None,
+      Some(serde_json::from_str(MOVIE_JSON).unwrap()),
+      None,
+      RadarrEvent::GetMovieDetails(None),
+      Some("/1"),
+      None,
+    )
+      .await;
+    let async_edit_server = server
+      .mock(
+        "PUT",
+        format!("/api/v3{}/1", RadarrEvent::EditMovie(edit_movie_params.clone()).resource()).as_str(),
+      )
+      .with_status(202)
+      .match_header("X-Api-Key", "test1234")
+      .match_body(Matcher::Json(expected_body))
+      .create_async()
+      .await;
+    app_arc.lock().await.data.radarr_data.tags_map =
+      BiMap::from_iter([(1, "usenet".to_owned()), (2, "testing".to_owned())]);
     let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
 
     assert!(network
-      .handle_radarr_event(RadarrEvent::EditMovie(Some(edit_movie_params)))
+      .handle_radarr_event(RadarrEvent::EditMovie(edit_movie_params))
       .await
       .is_ok());
 
@@ -4208,7 +4192,7 @@ mod test {
   }
 
   #[tokio::test]
-  async fn test_handle_edit_movie_event_uses_provided_parameters_defaults_to_previous_values() {
+  async fn test_handle_edit_movie_event_defaults_to_previous_values() {
     let expected_body: Value = serde_json::from_str(MOVIE_JSON).unwrap();
     let (async_details_server, app_arc, mut server) = mock_servarr_api(
       RequestMethod::Get,
@@ -4220,24 +4204,24 @@ mod test {
       None,
     )
     .await;
+    let edit_movie_params = EditMovieParams {
+      movie_id: 1,
+      ..EditMovieParams::default()
+    };
     let async_edit_server = server
       .mock(
         "PUT",
-        format!("/api/v3{}/1", RadarrEvent::EditMovie(None).resource()).as_str(),
+        format!("/api/v3{}/1", RadarrEvent::EditMovie(edit_movie_params.clone()).resource()).as_str(),
       )
       .with_status(202)
       .match_header("X-Api-Key", "test1234")
       .match_body(Matcher::Json(expected_body))
       .create_async()
       .await;
-    let edit_movie_params = EditMovieParams {
-      movie_id: 1,
-      ..EditMovieParams::default()
-    };
     let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
 
     assert!(network
-      .handle_radarr_event(RadarrEvent::EditMovie(Some(edit_movie_params)))
+      .handle_radarr_event(RadarrEvent::EditMovie(edit_movie_params))
       .await
       .is_ok());
 
@@ -4250,7 +4234,6 @@ mod test {
   ) {
     let mut expected_body: Value = serde_json::from_str(MOVIE_JSON).unwrap();
     *expected_body.get_mut("tags").unwrap() = json!([]);
-
     let (async_details_server, app_arc, mut server) = mock_servarr_api(
       RequestMethod::Get,
       None,
@@ -4261,25 +4244,25 @@ mod test {
       None,
     )
     .await;
+    let edit_movie_params = EditMovieParams {
+      movie_id: 1,
+      clear_tags: true,
+      ..EditMovieParams::default()
+    };
     let async_edit_server = server
       .mock(
         "PUT",
-        format!("/api/v3{}/1", RadarrEvent::EditMovie(None).resource()).as_str(),
+        format!("/api/v3{}/1", RadarrEvent::EditMovie(edit_movie_params.clone()).resource()).as_str(),
       )
       .with_status(202)
       .match_header("X-Api-Key", "test1234")
       .match_body(Matcher::Json(expected_body))
       .create_async()
       .await;
-    let edit_movie_params = EditMovieParams {
-      movie_id: 1,
-      clear_tags: true,
-      ..EditMovieParams::default()
-    };
     let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
 
     assert!(network
-      .handle_radarr_event(RadarrEvent::EditMovie(Some(edit_movie_params)))
+      .handle_radarr_event(RadarrEvent::EditMovie(edit_movie_params))
       .await
       .is_ok());