Refactored the Edit/Add modals into their own structs so that adding similar modals in the future is more consistent, uses less RAM (since it's wrapped in an Option now), and is easier to implement. This comes with an initial example of the IndexerSettings UI that needs its own modal now. The modal has been created but it is still not used just yet so that's the next step.

src/models/servarr_data/mod.rs

@@ -1 +1 @@
-pub mod radarr_data;
+pub mod radarr;

src/models/servarr_data/radarr/mod.rs

@@ -0,0 +1,2 @@
+pub mod modals;
+pub mod radarr_data;

src/models/servarr_data/radarr/modals.rs

@@ -0,0 +1,193 @@
+use crate::models::radarr_models::{Collection, MinimumAvailability, Monitor, Movie, RootFolder};
+use crate::models::servarr_data::radarr::radarr_data::RadarrData;
+use crate::models::{HorizontallyScrollableText, StatefulList};
+use strum::IntoEnumIterator;
+
+#[cfg(test)]
+#[path = "modals_tests.rs"]
+mod modals_tests;
+
+#[derive(Default)]
+pub struct EditMovieModal {
+  pub minimum_availability_list: StatefulList<MinimumAvailability>,
+  pub quality_profile_list: StatefulList<String>,
+  pub monitored: Option<bool>,
+  pub path: HorizontallyScrollableText,
+  pub tags: HorizontallyScrollableText,
+}
+
+impl From<&RadarrData<'_>> for EditMovieModal {
+  fn from(radarr_data: &RadarrData<'_>) -> EditMovieModal {
+    let mut edit_movie_modal = EditMovieModal::default();
+    let Movie {
+      path,
+      tags,
+      monitored,
+      minimum_availability,
+      quality_profile_id,
+      ..
+    } = if radarr_data.filtered_movies.items.is_empty() {
+      radarr_data.movies.current_selection()
+    } else {
+      radarr_data.filtered_movies.current_selection()
+    };
+
+    edit_movie_modal
+      .minimum_availability_list
+      .set_items(Vec::from_iter(MinimumAvailability::iter()));
+    edit_movie_modal.path = path.clone().into();
+    edit_movie_modal.tags = tags
+      .iter()
+      .map(|tag_id| {
+        radarr_data
+          .tags_map
+          .get_by_left(&tag_id.as_u64().unwrap())
+          .unwrap()
+          .clone()
+      })
+      .collect::<Vec<String>>()
+      .join(", ")
+      .into();
+
+    edit_movie_modal.monitored = Some(*monitored);
+
+    let minimum_availability_index = edit_movie_modal
+      .minimum_availability_list
+      .items
+      .iter()
+      .position(|ma| ma == minimum_availability);
+    edit_movie_modal
+      .minimum_availability_list
+      .state
+      .select(minimum_availability_index);
+
+    let mut quality_profile_names: Vec<String> = radarr_data
+      .quality_profile_map
+      .right_values()
+      .cloned()
+      .collect();
+    quality_profile_names.sort();
+    edit_movie_modal
+      .quality_profile_list
+      .set_items(quality_profile_names);
+    let quality_profile_name = radarr_data
+      .quality_profile_map
+      .get_by_left(&quality_profile_id.as_u64().unwrap())
+      .unwrap();
+    let quality_profile_index = edit_movie_modal
+      .quality_profile_list
+      .items
+      .iter()
+      .position(|profile| profile == quality_profile_name);
+    edit_movie_modal
+      .quality_profile_list
+      .state
+      .select(quality_profile_index);
+
+    edit_movie_modal
+  }
+}
+
+#[derive(Default)]
+pub struct AddMovieModal {
+  pub root_folder_list: StatefulList<RootFolder>,
+  pub monitor_list: StatefulList<Monitor>,
+  pub minimum_availability_list: StatefulList<MinimumAvailability>,
+  pub quality_profile_list: StatefulList<String>,
+  pub tags: HorizontallyScrollableText,
+}
+
+impl From<&RadarrData<'_>> for AddMovieModal {
+  fn from(radarr_data: &RadarrData<'_>) -> AddMovieModal {
+    let mut add_movie_modal = AddMovieModal::default();
+    add_movie_modal
+      .monitor_list
+      .set_items(Vec::from_iter(Monitor::iter()));
+    add_movie_modal
+      .minimum_availability_list
+      .set_items(Vec::from_iter(MinimumAvailability::iter()));
+    let mut quality_profile_names: Vec<String> = radarr_data
+      .quality_profile_map
+      .right_values()
+      .cloned()
+      .collect();
+    quality_profile_names.sort();
+    add_movie_modal
+      .quality_profile_list
+      .set_items(quality_profile_names);
+    add_movie_modal
+      .root_folder_list
+      .set_items(radarr_data.root_folders.items.to_vec());
+
+    add_movie_modal
+  }
+}
+
+#[derive(Default)]
+pub struct EditCollectionModal {
+  pub monitored: Option<bool>,
+  pub minimum_availability_list: StatefulList<MinimumAvailability>,
+  pub quality_profile_list: StatefulList<String>,
+  pub path: HorizontallyScrollableText,
+  pub search_on_add: Option<bool>,
+}
+
+impl From<&RadarrData<'_>> for EditCollectionModal {
+  fn from(radarr_data: &RadarrData<'_>) -> EditCollectionModal {
+    let mut edit_collection_modal = EditCollectionModal::default();
+    let Collection {
+      root_folder_path,
+      monitored,
+      search_on_add,
+      minimum_availability,
+      quality_profile_id,
+      ..
+    } = if radarr_data.filtered_collections.items.is_empty() {
+      radarr_data.collections.current_selection()
+    } else {
+      radarr_data.filtered_collections.current_selection()
+    };
+
+    edit_collection_modal.path = root_folder_path.clone().unwrap_or_default().into();
+    edit_collection_modal.monitored = Some(*monitored);
+    edit_collection_modal.search_on_add = Some(*search_on_add);
+    edit_collection_modal
+      .minimum_availability_list
+      .set_items(Vec::from_iter(MinimumAvailability::iter()));
+    let mut quality_profile_names: Vec<String> = radarr_data
+      .quality_profile_map
+      .right_values()
+      .cloned()
+      .collect();
+    quality_profile_names.sort();
+    edit_collection_modal
+      .quality_profile_list
+      .set_items(quality_profile_names);
+
+    let minimum_availability_index = edit_collection_modal
+      .minimum_availability_list
+      .items
+      .iter()
+      .position(|ma| ma == minimum_availability);
+    edit_collection_modal
+      .minimum_availability_list
+      .state
+      .select(minimum_availability_index);
+
+    let quality_profile_name = radarr_data
+      .quality_profile_map
+      .get_by_left(&quality_profile_id.as_u64().unwrap())
+      .unwrap();
+    let quality_profile_index = edit_collection_modal
+      .quality_profile_list
+      .items
+      .iter()
+      .position(|profile| profile == quality_profile_name);
+    edit_collection_modal
+      .quality_profile_list
+      .state
+      .select(quality_profile_index);
+
+    edit_collection_modal
+  }
+}

src/models/servarr_data/radarr/modals_tests.rs

@@ -0,0 +1,161 @@
+#[cfg(test)]
+mod test {
+  use crate::models::radarr_models::{Collection, MinimumAvailability, Monitor, Movie, RootFolder};
+  use crate::models::servarr_data::radarr::modals::{
+    AddMovieModal, EditCollectionModal, EditMovieModal,
+  };
+  use crate::models::servarr_data::radarr::radarr_data::radarr_test_utils::utils::create_test_radarr_data;
+  use crate::models::servarr_data::radarr::radarr_data::RadarrData;
+  use crate::models::{HorizontallyScrollableText, StatefulTable};
+  use bimap::BiMap;
+  use pretty_assertions::{assert_eq, assert_str_eq};
+  use rstest::rstest;
+  use serde_json::Number;
+  use strum::IntoEnumIterator;
+
+  #[rstest]
+  fn test_edit_movie_modal_from_radarr_data(#[values(true, false)] test_filtered_movies: bool) {
+    let mut radarr_data = RadarrData {
+      edit_path: HorizontallyScrollableText::default(),
+      edit_tags: HorizontallyScrollableText::default(),
+      edit_monitored: None,
+      quality_profile_map: BiMap::from_iter([
+        (2222, "HD - 1080p".to_owned()),
+        (1111, "Any".to_owned()),
+      ]),
+      tags_map: BiMap::from_iter([(1, "usenet".to_owned()), (2, "test".to_owned())]),
+      filtered_movies: StatefulTable::default(),
+      ..create_test_radarr_data()
+    };
+    let movie = Movie {
+      path: "/nfs/movies/Test".to_owned(),
+      monitored: true,
+      quality_profile_id: Number::from(2222),
+      minimum_availability: MinimumAvailability::Released,
+      tags: vec![Number::from(1), Number::from(2)],
+      ..Movie::default()
+    };
+
+    if test_filtered_movies {
+      radarr_data.filtered_movies.set_items(vec![movie]);
+    } else {
+      radarr_data.movies.set_items(vec![movie]);
+    }
+
+    let edit_movie_modal = EditMovieModal::from(&radarr_data);
+
+    assert_eq!(
+      edit_movie_modal.minimum_availability_list.items,
+      Vec::from_iter(MinimumAvailability::iter())
+    );
+    assert_eq!(
+      edit_movie_modal
+        .minimum_availability_list
+        .current_selection(),
+      &MinimumAvailability::Released
+    );
+    assert_eq!(
+      edit_movie_modal.quality_profile_list.items,
+      vec!["Any".to_owned(), "HD - 1080p".to_owned()]
+    );
+    assert_str_eq!(
+      edit_movie_modal.quality_profile_list.current_selection(),
+      "HD - 1080p"
+    );
+    assert_str_eq!(edit_movie_modal.path.text, "/nfs/movies/Test");
+    assert_str_eq!(edit_movie_modal.tags.text, "usenet, test");
+    assert_eq!(edit_movie_modal.monitored, Some(true));
+  }
+
+  #[test]
+  fn test_add_movie_modal_from_radarr_data() {
+    let root_folder = RootFolder {
+      id: Number::from(1),
+      path: "/nfs".to_owned(),
+      accessible: true,
+      free_space: Number::from(219902325555200u64),
+      unmapped_folders: None,
+    };
+    let mut radarr_data = RadarrData {
+      quality_profile_map: BiMap::from_iter([
+        (2222, "HD - 1080p".to_owned()),
+        (1111, "Any".to_owned()),
+      ]),
+      ..RadarrData::default()
+    };
+    radarr_data
+      .root_folders
+      .set_items(vec![root_folder.clone()]);
+
+    let add_movie_modal = AddMovieModal::from(&radarr_data);
+
+    assert_eq!(
+      add_movie_modal.monitor_list.items,
+      Vec::from_iter(Monitor::iter())
+    );
+    assert_eq!(
+      add_movie_modal.minimum_availability_list.items,
+      Vec::from_iter(MinimumAvailability::iter())
+    );
+    assert_eq!(
+      add_movie_modal.quality_profile_list.items,
+      vec!["Any".to_owned(), "HD - 1080p".to_owned()]
+    );
+    assert_eq!(add_movie_modal.root_folder_list.items, vec![root_folder]);
+    assert!(add_movie_modal.tags.text.is_empty());
+  }
+
+  #[rstest]
+  fn test_edit_collection_modal_from_radarr_data(
+    #[values(true, false)] test_filtered_collections: bool,
+  ) {
+    let mut radarr_data = RadarrData {
+      quality_profile_map: BiMap::from_iter([
+        (2222, "HD - 1080p".to_owned()),
+        (1111, "Any".to_owned()),
+      ]),
+      filtered_collections: StatefulTable::default(),
+      ..create_test_radarr_data()
+    };
+    let collection = Collection {
+      root_folder_path: Some("/nfs/movies/Test".to_owned()),
+      monitored: true,
+      search_on_add: true,
+      quality_profile_id: Number::from(2222),
+      minimum_availability: MinimumAvailability::Released,
+      ..Collection::default()
+    };
+
+    if test_filtered_collections {
+      radarr_data.filtered_collections.set_items(vec![collection]);
+    } else {
+      radarr_data.collections.set_items(vec![collection]);
+    }
+
+    let edit_collection_modal = EditCollectionModal::from(&radarr_data);
+
+    assert_eq!(
+      edit_collection_modal.minimum_availability_list.items,
+      Vec::from_iter(MinimumAvailability::iter())
+    );
+    assert_eq!(
+      edit_collection_modal
+        .minimum_availability_list
+        .current_selection(),
+      &MinimumAvailability::Released
+    );
+    assert_eq!(
+      edit_collection_modal.quality_profile_list.items,
+      vec!["Any".to_owned(), "HD - 1080p".to_owned()]
+    );
+    assert_str_eq!(
+      edit_collection_modal
+        .quality_profile_list
+        .current_selection(),
+      "HD - 1080p"
+    );
+    assert_str_eq!(edit_collection_modal.path.text, "/nfs/movies/Test");
+    assert_eq!(edit_collection_modal.monitored, Some(true));
+    assert_eq!(edit_collection_modal.search_on_add, Some(true));
+  }
+}

src/models/servarr_data/radarr/radarr_data.rs

@@ -10,6 +10,9 @@ use crate::models::radarr_models::{
   IndexerSettings, MinimumAvailability, Monitor, Movie, MovieHistoryItem, QueueEvent, Release,
   ReleaseField, RootFolder, Task,
 };
+use crate::models::servarr_data::radarr::modals::{
+  AddMovieModal, EditCollectionModal, EditMovieModal,
+};
 use crate::models::{
   BlockSelectionState, HorizontallyScrollableText, Route, ScrollableText, StatefulList,
   StatefulTable, TabRoute, TabState,
@@ -17,7 +20,7 @@ use crate::models::{
 use crate::network::radarr_network::RadarrEvent;
 use bimap::BiMap;
 use chrono::{DateTime, Utc};
-use strum::{EnumIter, IntoEnumIterator};
+use strum::EnumIter;
 
 #[cfg(test)]
 #[path = "radarr_data_tests.rs"]
@@ -67,6 +70,9 @@ pub struct RadarrData<'a> {
   pub movie_info_tabs: TabState,
   pub search: HorizontallyScrollableText,
   pub filter: HorizontallyScrollableText,
+  pub add_movie_modal: Option<AddMovieModal>,
+  pub edit_movie_modal: Option<EditMovieModal>,
+  pub edit_collection_modal: Option<EditCollectionModal>,
   pub edit_path: HorizontallyScrollableText,
   pub edit_tags: HorizontallyScrollableText,
   pub edit_monitored: Option<bool>,
@@ -80,14 +86,6 @@ pub struct RadarrData<'a> {
 }
 
 impl<'a> RadarrData<'a> {
-  pub fn reset_movie_collection_table(&mut self) {
-    self.collection_movies = StatefulTable::default();
-  }
-
-  pub fn reset_log_details_list(&mut self) {
-    self.log_details = StatefulList::default();
-  }
-
   pub fn reset_delete_movie_preferences(&mut self) {
     self.delete_movie_files = false;
     self.add_list_exclusion = false;
@@ -109,14 +107,6 @@ impl<'a> RadarrData<'a> {
     self.filtered_collections = StatefulTable::default();
   }
 
-  pub fn reset_add_edit_media_fields(&mut self) {
-    self.edit_monitored = None;
-    self.edit_search_on_add = None;
-    self.edit_path = HorizontallyScrollableText::default();
-    self.edit_tags = HorizontallyScrollableText::default();
-    self.reset_preferences_selections();
-  }
-
   pub fn reset_movie_info_tabs(&mut self) {
     self.file_details = String::default();
     self.audio_details = String::default();
@@ -130,126 +120,6 @@ impl<'a> RadarrData<'a> {
     self.sort_ascending = None;
     self.movie_info_tabs.index = 0;
   }
-
-  pub fn reset_preferences_selections(&mut self) {
-    self.monitor_list = StatefulList::default();
-    self.minimum_availability_list = StatefulList::default();
-    self.quality_profile_list = StatefulList::default();
-    self.root_folder_list = StatefulList::default();
-  }
-
-  pub fn populate_preferences_lists(&mut self) {
-    self.monitor_list.set_items(Vec::from_iter(Monitor::iter()));
-    self
-      .minimum_availability_list
-      .set_items(Vec::from_iter(MinimumAvailability::iter()));
-    let mut quality_profile_names: Vec<String> =
-      self.quality_profile_map.right_values().cloned().collect();
-    quality_profile_names.sort();
-    self.quality_profile_list.set_items(quality_profile_names);
-    self
-      .root_folder_list
-      .set_items(self.root_folders.items.to_vec());
-  }
-
-  pub fn populate_edit_movie_fields(&mut self) {
-    self.populate_preferences_lists();
-    let Movie {
-      path,
-      tags,
-      monitored,
-      minimum_availability,
-      quality_profile_id,
-      ..
-    } = if self.filtered_movies.items.is_empty() {
-      self.movies.current_selection()
-    } else {
-      self.filtered_movies.current_selection()
-    };
-
-    self.edit_path = path.clone().into();
-    self.edit_tags = tags
-      .iter()
-      .map(|tag_id| {
-        self
-          .tags_map
-          .get_by_left(&tag_id.as_u64().unwrap())
-          .unwrap()
-          .clone()
-      })
-      .collect::<Vec<String>>()
-      .join(", ")
-      .into();
-    self.edit_monitored = Some(*monitored);
-
-    let minimum_availability_index = self
-      .minimum_availability_list
-      .items
-      .iter()
-      .position(|ma| ma == minimum_availability);
-    self
-      .minimum_availability_list
-      .state
-      .select(minimum_availability_index);
-
-    let quality_profile_name = self
-      .quality_profile_map
-      .get_by_left(&quality_profile_id.as_u64().unwrap())
-      .unwrap();
-    let quality_profile_index = self
-      .quality_profile_list
-      .items
-      .iter()
-      .position(|profile| profile == quality_profile_name);
-    self
-      .quality_profile_list
-      .state
-      .select(quality_profile_index);
-  }
-
-  pub fn populate_edit_collection_fields(&mut self) {
-    self.populate_preferences_lists();
-    let Collection {
-      root_folder_path,
-      monitored,
-      search_on_add,
-      minimum_availability,
-      quality_profile_id,
-      ..
-    } = if self.filtered_collections.items.is_empty() {
-      self.collections.current_selection()
-    } else {
-      self.filtered_collections.current_selection()
-    };
-
-    self.edit_path = root_folder_path.clone().unwrap_or_default().into();
-    self.edit_monitored = Some(*monitored);
-    self.edit_search_on_add = Some(*search_on_add);
-
-    let minimum_availability_index = self
-      .minimum_availability_list
-      .items
-      .iter()
-      .position(|ma| ma == minimum_availability);
-    self
-      .minimum_availability_list
-      .state
-      .select(minimum_availability_index);
-
-    let quality_profile_name = self
-      .quality_profile_map
-      .get_by_left(&quality_profile_id.as_u64().unwrap())
-      .unwrap();
-    let quality_profile_index = self
-      .quality_profile_list
-      .items
-      .iter()
-      .position(|profile| profile == quality_profile_name);
-    self
-      .quality_profile_list
-      .state
-      .select(quality_profile_index);
-  }
 }
 
 impl<'a> Default for RadarrData<'a> {
@@ -292,6 +162,9 @@ impl<'a> Default for RadarrData<'a> {
       prompt_confirm_action: None,
       search: HorizontallyScrollableText::default(),
       filter: HorizontallyScrollableText::default(),
+      add_movie_modal: None,
+      edit_movie_modal: None,
+      edit_collection_modal: None,
       edit_path: HorizontallyScrollableText::default(),
       edit_tags: HorizontallyScrollableText::default(),
       edit_monitored: None,
@@ -623,3 +496,15 @@ impl From<(ActiveRadarrBlock, Option<ActiveRadarrBlock>)> for Route {
     Route::Radarr(value.0, value.1)
   }
 }
+
+pub struct EditIndexerSettings {
+  pub allow_hardcoded_subs: bool,
+  pub availability_delay: HorizontallyScrollableText,
+  pub id: HorizontallyScrollableText,
+  pub maximum_size: HorizontallyScrollableText,
+  pub minimum_age: HorizontallyScrollableText,
+  pub prefer_indexer_flags: bool,
+  pub retention: HorizontallyScrollableText,
+  pub rss_sync_interval: HorizontallyScrollableText,
+  pub whitelisted_hardcoded_subs: HorizontallyScrollableText,
+}

src/models/servarr_data/radarr/radarr_data_tests.rs

@@ -1,12 +1,9 @@
 #[cfg(test)]
 mod tests {
   mod radarr_data_tests {
-    use bimap::BiMap;
+
     use chrono::{DateTime, Utc};
     use pretty_assertions::{assert_eq, assert_str_eq};
-    use rstest::rstest;
-    use serde_json::Number;
-    use strum::IntoEnumIterator;
 
     use crate::app::context_clues::build_context_clue_string;
     use crate::app::radarr::radarr_context_clues::{
@@ -15,18 +12,13 @@ mod tests {
       MANUAL_MOVIE_SEARCH_CONTEXT_CLUES, MOVIE_DETAILS_CONTEXT_CLUES, ROOT_FOLDERS_CONTEXT_CLUES,
       SYSTEM_CONTEXT_CLUES,
     };
-    use crate::models::radarr_models::{
-      Collection, MinimumAvailability, Monitor, Movie, RootFolder,
-    };
-    use crate::models::servarr_data::radarr_data::radarr_test_utils::utils;
-    use crate::models::servarr_data::radarr_data::{ActiveRadarrBlock, RadarrData};
+
+    use crate::models::servarr_data::radarr::radarr_data::radarr_test_utils::utils;
+    use crate::models::servarr_data::radarr::radarr_data::{ActiveRadarrBlock, RadarrData};
     use crate::models::Route;
-    use crate::models::StatefulTable;
-    use crate::models::{BlockSelectionState, HorizontallyScrollableText};
-    use crate::{
-      assert_edit_media_reset, assert_filter_reset, assert_movie_info_tabs_reset,
-      assert_preferences_selections_reset, assert_search_reset,
-    };
+
+    use crate::models::BlockSelectionState;
+    use crate::{assert_filter_reset, assert_movie_info_tabs_reset, assert_search_reset};
 
     #[test]
     fn test_from_tuple_to_route_with_context() {
@@ -42,24 +34,6 @@ mod tests {
       );
     }
 
-    #[test]
-    fn test_reset_movie_collection_table() {
-      let mut radarr_data = utils::create_test_radarr_data();
-
-      radarr_data.reset_movie_collection_table();
-
-      assert!(radarr_data.collection_movies.items.is_empty());
-    }
-
-    #[test]
-    fn test_reset_log_details_list() {
-      let mut radarr_data = utils::create_test_radarr_data();
-
-      radarr_data.reset_log_details_list();
-
-      assert!(radarr_data.log_details.items.is_empty());
-    }
-
     #[test]
     fn test_reset_delete_movie_preferences() {
       let mut radarr_data = utils::create_test_radarr_data();
@@ -97,172 +71,6 @@ mod tests {
       assert_movie_info_tabs_reset!(radarr_data);
     }
 
-    #[test]
-    fn test_reset_add_edit_media_fields() {
-      let mut radarr_data = RadarrData {
-        edit_monitored: Some(true),
-        edit_search_on_add: Some(true),
-        edit_path: "test path".to_owned().into(),
-        edit_tags: "test tag".to_owned().into(),
-        ..RadarrData::default()
-      };
-
-      radarr_data.reset_add_edit_media_fields();
-
-      assert_edit_media_reset!(radarr_data);
-    }
-
-    #[test]
-    fn test_reset_preferences_selections() {
-      let mut radarr_data = utils::create_test_radarr_data();
-
-      radarr_data.reset_preferences_selections();
-
-      assert_preferences_selections_reset!(radarr_data);
-    }
-
-    #[test]
-    fn test_populate_preferences_lists() {
-      let root_folder = RootFolder {
-        id: Number::from(1),
-        path: "/nfs".to_owned(),
-        accessible: true,
-        free_space: Number::from(219902325555200u64),
-        unmapped_folders: None,
-      };
-      let mut radarr_data = RadarrData {
-        quality_profile_map: BiMap::from_iter([
-          (2222, "HD - 1080p".to_owned()),
-          (1111, "Any".to_owned()),
-        ]),
-        ..RadarrData::default()
-      };
-      radarr_data
-        .root_folders
-        .set_items(vec![root_folder.clone()]);
-
-      radarr_data.populate_preferences_lists();
-
-      assert_eq!(
-        radarr_data.monitor_list.items,
-        Vec::from_iter(Monitor::iter())
-      );
-      assert_eq!(
-        radarr_data.minimum_availability_list.items,
-        Vec::from_iter(MinimumAvailability::iter())
-      );
-      assert_eq!(
-        radarr_data.quality_profile_list.items,
-        vec!["Any".to_owned(), "HD - 1080p".to_owned()]
-      );
-      assert_eq!(radarr_data.root_folder_list.items, vec![root_folder]);
-    }
-
-    #[rstest]
-    fn test_populate_edit_movie_fields(#[values(true, false)] test_filtered_movies: bool) {
-      let mut radarr_data = RadarrData {
-        edit_path: HorizontallyScrollableText::default(),
-        edit_tags: HorizontallyScrollableText::default(),
-        edit_monitored: None,
-        quality_profile_map: BiMap::from_iter([
-          (2222, "HD - 1080p".to_owned()),
-          (1111, "Any".to_owned()),
-        ]),
-        tags_map: BiMap::from_iter([(1, "usenet".to_owned()), (2, "test".to_owned())]),
-        filtered_movies: StatefulTable::default(),
-        ..utils::create_test_radarr_data()
-      };
-      let movie = Movie {
-        path: "/nfs/movies/Test".to_owned(),
-        monitored: true,
-        quality_profile_id: Number::from(2222),
-        minimum_availability: MinimumAvailability::Released,
-        tags: vec![Number::from(1), Number::from(2)],
-        ..Movie::default()
-      };
-
-      if test_filtered_movies {
-        radarr_data.filtered_movies.set_items(vec![movie]);
-      } else {
-        radarr_data.movies.set_items(vec![movie]);
-      }
-
-      radarr_data.populate_edit_movie_fields();
-
-      assert_eq!(
-        radarr_data.minimum_availability_list.items,
-        Vec::from_iter(MinimumAvailability::iter())
-      );
-      assert_eq!(
-        radarr_data.minimum_availability_list.current_selection(),
-        &MinimumAvailability::Released
-      );
-      assert_eq!(
-        radarr_data.quality_profile_list.items,
-        vec!["Any".to_owned(), "HD - 1080p".to_owned()]
-      );
-      assert_str_eq!(
-        radarr_data.quality_profile_list.current_selection(),
-        "HD - 1080p"
-      );
-      assert_str_eq!(radarr_data.edit_path.text, "/nfs/movies/Test");
-      assert_str_eq!(radarr_data.edit_tags.text, "usenet, test");
-      assert_eq!(radarr_data.edit_monitored, Some(true));
-    }
-
-    #[rstest]
-    fn test_populate_edit_collection_fields(
-      #[values(true, false)] test_filtered_collections: bool,
-    ) {
-      let mut radarr_data = RadarrData {
-        edit_path: HorizontallyScrollableText::default(),
-        edit_monitored: None,
-        edit_search_on_add: None,
-        quality_profile_map: BiMap::from_iter([
-          (2222, "HD - 1080p".to_owned()),
-          (1111, "Any".to_owned()),
-        ]),
-        filtered_collections: StatefulTable::default(),
-        ..utils::create_test_radarr_data()
-      };
-      let collection = Collection {
-        root_folder_path: Some("/nfs/movies/Test".to_owned()),
-        monitored: true,
-        search_on_add: true,
-        quality_profile_id: Number::from(2222),
-        minimum_availability: MinimumAvailability::Released,
-        ..Collection::default()
-      };
-
-      if test_filtered_collections {
-        radarr_data.filtered_collections.set_items(vec![collection]);
-      } else {
-        radarr_data.collections.set_items(vec![collection]);
-      }
-
-      radarr_data.populate_edit_collection_fields();
-
-      assert_eq!(
-        radarr_data.minimum_availability_list.items,
-        Vec::from_iter(MinimumAvailability::iter())
-      );
-      assert_eq!(
-        radarr_data.minimum_availability_list.current_selection(),
-        &MinimumAvailability::Released
-      );
-      assert_eq!(
-        radarr_data.quality_profile_list.items,
-        vec!["Any".to_owned(), "HD - 1080p".to_owned()]
-      );
-      assert_str_eq!(
-        radarr_data.quality_profile_list.current_selection(),
-        "HD - 1080p"
-      );
-      assert_str_eq!(radarr_data.edit_path.text, "/nfs/movies/Test");
-      assert_eq!(radarr_data.edit_monitored, Some(true));
-      assert_eq!(radarr_data.edit_search_on_add, Some(true));
-    }
-
     #[test]
     fn test_radarr_data_defaults() {
       let radarr_data = RadarrData::default();
@@ -304,6 +112,9 @@ mod tests {
       assert!(radarr_data.prompt_confirm_action.is_none());
       assert!(radarr_data.search.text.is_empty());
       assert!(radarr_data.filter.text.is_empty());
+      assert!(radarr_data.add_movie_modal.is_none());
+      assert!(radarr_data.edit_movie_modal.is_none());
+      assert!(radarr_data.edit_collection_modal.is_none());
       assert!(radarr_data.edit_path.text.is_empty());
       assert!(radarr_data.edit_tags.text.is_empty());
       assert!(radarr_data.edit_monitored.is_none());
@@ -471,7 +282,7 @@ mod tests {
   mod active_radarr_block_tests {
     use pretty_assertions::assert_eq;
 
-    use crate::models::servarr_data::radarr_data::{
+    use crate::models::servarr_data::radarr::radarr_data::{
       ActiveRadarrBlock, ADD_MOVIE_BLOCKS, ADD_MOVIE_SELECTION_BLOCKS, COLLECTIONS_BLOCKS,
       COLLECTION_DETAILS_BLOCKS, DELETE_MOVIE_BLOCKS, DELETE_MOVIE_SELECTION_BLOCKS,
       DOWNLOADS_BLOCKS, EDIT_COLLECTION_BLOCKS, EDIT_COLLECTION_SELECTION_BLOCKS,

src/models/servarr_data/radarr/radarr_test_utils.rs

@@ -4,7 +4,7 @@ pub mod utils {
     AddMovieSearchResult, Collection, CollectionMovie, Credit, MinimumAvailability, Monitor, Movie,
     MovieHistoryItem, Release, ReleaseField, RootFolder,
   };
-  use crate::models::servarr_data::radarr_data::RadarrData;
+  use crate::models::servarr_data::radarr::radarr_data::RadarrData;
   use crate::models::{HorizontallyScrollableText, ScrollableText};
 
   pub fn create_test_radarr_data<'a>() -> RadarrData<'a> {
@@ -79,16 +79,6 @@ pub mod utils {
     };
   }
 
-  #[macro_export]
-  macro_rules! assert_edit_media_reset {
-    ($radarr_data:expr) => {
-      assert!($radarr_data.edit_monitored.is_none());
-      assert!($radarr_data.edit_search_on_add.is_none());
-      assert!($radarr_data.edit_path.text.is_empty());
-      assert!($radarr_data.edit_tags.text.is_empty());
-    };
-  }
-
   #[macro_export]
   macro_rules! assert_filter_reset {
     ($radarr_data:expr) => {
@@ -115,14 +105,4 @@ pub mod utils {
       assert_eq!($radarr_data.movie_info_tabs.index, 0);
     };
   }
-
-  #[macro_export]
-  macro_rules! assert_preferences_selections_reset {
-    ($radarr_data:expr) => {
-      assert!($radarr_data.monitor_list.items.is_empty());
-      assert!($radarr_data.minimum_availability_list.items.is_empty());
-      assert!($radarr_data.quality_profile_list.items.is_empty());
-      assert!($radarr_data.root_folder_list.items.is_empty());
-    };
-  }
 }