Dark-Alex-17/managarr
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Alex Clarke
2024-12-17 17:50:07 -07:00
parent 77b8b61079
commit 9a9b13d604
7 changed files with 232 additions and 146 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/cli/radarr/edit_command_handler.rs
+2 -1
View File
@@ -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
+6 -3
View File
@@ -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
+45 -2
View File
@@ -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
+106 -7
View File
@@ -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
+2
View File
@@ -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
+18 -63
View File
@@ -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
+53 -70
View File
@@ -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;
{
let mut app = app_arc.lock().await;
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())]);
}
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(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());