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

test: Updated Rust edition to 2024 and refactored network module tests to be more idiomatic

Browse Source
This commit is contained in:
Alex Clarke
2025-12-03 14:49:27 -07:00
parent c4e8d64710
commit ad58912baf
257 changed files with 4033 additions and 4380 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/network/radarr_network/blocklist/mod.rs
+2 -2
View File
@@ -1,11 +1,11 @@
use crate::models::Route;
use crate::models::radarr_models::BlocklistResponse;
use crate::models::servarr_data::radarr::radarr_data::ActiveRadarrBlock;
use crate::models::Route;
use crate::network::radarr_network::RadarrEvent;
use crate::network::{Network, RequestMethod};
use anyhow::Result;
use log::info;
use serde_json::{json, Value};
use serde_json::{Value, json};
#[cfg(test)]
#[path = "radarr_blocklist_network_tests.rs"]
src/network/radarr_network/blocklist/radarr_blocklist_network_tests.rs
+54 -82
View File
@@ -5,16 +5,13 @@ mod tests {
use crate::models::radarr_models::BlocklistResponse;
use crate::models::servarr_data::radarr::radarr_data::ActiveRadarrBlock;
use crate::models::stateful_table::SortOption;
use crate::network::network_tests::test_utils::mock_servarr_api;
use crate::network::radarr_network::radarr_network_test_utils::test_utils::blocklist_item;
use crate::network::network_tests::test_utils::{MockServarrApi, test_network};
use crate::network::radarr_network::RadarrEvent;
use crate::network::radarr_network::RadarrSerdeable;
use crate::network::{Network, RequestMethod};
use crate::network::radarr_network::radarr_network_test_utils::test_utils::blocklist_item;
use pretty_assertions::assert_eq;
use reqwest::Client;
use rstest::rstest;
use serde_json::json;
use tokio_util::sync::CancellationToken;
#[tokio::test]
async fn test_handle_clear_radarr_blocklist_event() {
@@ -33,53 +30,45 @@ mod tests {
},
];
let expected_request_json = json!({ "ids": [1, 2, 3]});
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Delete,
Some(expected_request_json),
None,
None,
RadarrEvent::ClearBlocklist,
None,
None,
)
.await;
app_arc
let (mock, app, _server) = MockServarrApi::delete()
.with_request_body(expected_request_json)
.build_for(RadarrEvent::ClearBlocklist)
.await;
app
.lock()
.await
.data
.radarr_data
.blocklist
.set_items(blocklist_items);
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let mut network = test_network(&app);
assert!(network
.handle_radarr_event(RadarrEvent::ClearBlocklist)
.await
.is_ok());
assert!(
network
.handle_radarr_event(RadarrEvent::ClearBlocklist)
.await
.is_ok()
);
async_server.assert_async().await;
mock.assert_async().await;
}
#[tokio::test]
async fn test_handle_delete_radarr_blocklist_item_event() {
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Delete,
None,
None,
None,
RadarrEvent::DeleteBlocklistItem(1),
Some("/1"),
None,
)
.await;
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let (mock, app, _server) = MockServarrApi::delete()
.path("/1")
.build_for(RadarrEvent::DeleteBlocklistItem(1))
.await;
let mut network = test_network(&app);
assert!(network
.handle_radarr_event(RadarrEvent::DeleteBlocklistItem(1))
.await
.is_ok());
assert!(
network
.handle_radarr_event(RadarrEvent::DeleteBlocklistItem(1))
.await
.is_ok()
);
async_server.assert_async().await;
mock.assert_async().await;
}
#[rstest]
@@ -179,17 +168,11 @@ mod tests {
..blocklist_item()
},
];
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(blocklist_json),
None,
RadarrEvent::GetBlocklist,
None,
None,
)
.await;
app_arc.lock().await.data.radarr_data.blocklist.sort_asc = true;
let (mock, app, _server) = MockServarrApi::get()
.returns(blocklist_json)
.build_for(RadarrEvent::GetBlocklist)
.await;
app.lock().await.data.radarr_data.blocklist.sort_asc = true;
if use_custom_sorting {
let cmp_fn = |a: &BlocklistItem, b: &BlocklistItem| {
a.source_title
@@ -202,7 +185,7 @@ mod tests {
name: "Source Title",
cmp_fn: Some(cmp_fn),
};
app_arc
app
.lock()
.await
.data
@@ -210,19 +193,19 @@ mod tests {
.blocklist
.sorting(vec![blocklist_sort_option]);
}
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let mut network = test_network(&app);
if let RadarrSerdeable::BlocklistResponse(blocklist) = network
.handle_radarr_event(RadarrEvent::GetBlocklist)
.await
.unwrap()
{
async_server.assert_async().await;
mock.assert_async().await;
assert_eq!(
app_arc.lock().await.data.radarr_data.blocklist.items,
app.lock().await.data.radarr_data.blocklist.items,
expected_blocklist
);
assert!(app_arc.lock().await.data.radarr_data.blocklist.sort_asc);
assert!(app.lock().await.data.radarr_data.blocklist.sort_asc);
assert_eq!(blocklist, response);
}
}
@@ -302,18 +285,12 @@ mod tests {
},
},
}]});
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(blocklist_json),
None,
RadarrEvent::GetBlocklist,
None,
None,
)
.await;
app_arc.lock().await.data.radarr_data.blocklist.sort_asc = true;
app_arc
let (mock, app, _server) = MockServarrApi::get()
.returns(blocklist_json)
.build_for(RadarrEvent::GetBlocklist)
.await;
app.lock().await.data.radarr_data.blocklist.sort_asc = true;
app
.lock()
.await
.push_navigation_stack(ActiveRadarrBlock::BlocklistSortPrompt.into());
@@ -326,29 +303,24 @@ mod tests {
name: "Source Title",
cmp_fn: Some(cmp_fn),
};
app_arc
app
.lock()
.await
.data
.radarr_data
.blocklist
.sorting(vec![blocklist_sort_option]);
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let mut network = test_network(&app);
assert!(network
.handle_radarr_event(RadarrEvent::GetBlocklist)
.await
.is_ok());
assert!(
network
.handle_radarr_event(RadarrEvent::GetBlocklist)
.await
.is_ok()
);
async_server.assert_async().await;
assert!(app_arc
.lock()
.await
.data
.radarr_data
.blocklist
.items
.is_empty());
assert!(app_arc.lock().await.data.radarr_data.blocklist.sort_asc);
mock.assert_async().await;
assert!(app.lock().await.data.radarr_data.blocklist.items.is_empty());
assert!(app.lock().await.data.radarr_data.blocklist.sort_asc);
}
}
src/network/radarr_network/collections/mod.rs
+2 -2
View File
@@ -1,12 +1,12 @@
use crate::models::Route;
use crate::models::radarr_models::{Collection, EditCollectionParams};
use crate::models::servarr_data::radarr::radarr_data::ActiveRadarrBlock;
use crate::models::servarr_models::CommandBody;
use crate::models::Route;
use crate::network::radarr_network::RadarrEvent;
use crate::network::{Network, RequestMethod};
use anyhow::Result;
use log::{debug, info};
use serde_json::{json, Value};
use serde_json::{Value, json};
#[cfg(test)]
#[path = "radarr_collections_network_tests.rs"]
src/network/radarr_network/collections/radarr_collections_network_tests.rs
+85 -104
View File
@@ -5,16 +5,14 @@ mod tests {
};
use crate::models::servarr_data::radarr::radarr_data::ActiveRadarrBlock;
use crate::models::stateful_table::SortOption;
use crate::network::network_tests::test_utils::mock_servarr_api;
use crate::network::radarr_network::radarr_network_test_utils::test_utils::collection;
use crate::network::NetworkResource;
use crate::network::network_tests::test_utils::{MockServarrApi, test_network};
use crate::network::radarr_network::RadarrEvent;
use crate::network::{Network, NetworkResource, RequestMethod};
use crate::network::radarr_network::radarr_network_test_utils::test_utils::collection;
use mockito::Matcher;
use pretty_assertions::assert_eq;
use reqwest::Client;
use rstest::rstest;
use serde_json::json;
use tokio_util::sync::CancellationToken;
#[tokio::test]
async fn test_handle_edit_collection_event() {
@@ -64,17 +62,12 @@ mod tests {
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
let (mock_details, app, mut server) = MockServarrApi::get()
.returns(detailed_collection_body)
.path("/123")
.build_for(RadarrEvent::GetCollections)
.await;
let mock_edit = server
.mock(
"PUT",
format!(
@@ -88,20 +81,22 @@ mod tests {
.match_body(Matcher::Json(expected_body))
.create_async()
.await;
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let mut network = test_network(&app);
assert!(network
.handle_radarr_event(RadarrEvent::EditCollection(edit_collection_params))
.await
.is_ok());
assert!(
network
.handle_radarr_event(RadarrEvent::EditCollection(edit_collection_params))
.await
.is_ok()
);
async_details_server.assert_async().await;
async_edit_server.assert_async().await;
mock_details.assert_async().await;
mock_edit.assert_async().await;
}
#[tokio::test]
async fn test_handle_edit_collection_event_defaults_to_previous_values_when_no_params_are_provided(
) {
async fn test_handle_edit_collection_event_defaults_to_previous_values_when_no_params_are_provided()
{
let detailed_collection_body = json!({
"id": 123,
"title": "Test Collection",
@@ -140,21 +135,16 @@ mod tests {
*expected_body.get_mut("rootFolderPath").unwrap() = json!("/nfs/movies");
*expected_body.get_mut("searchOnAdd").unwrap() = json!(true);
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 (mock_details, app, mut server) = MockServarrApi::get()
.returns(detailed_collection_body)
.path("/123")
.build_for(RadarrEvent::GetCollections)
.await;
let edit_collection_params = EditCollectionParams {
collection_id: 123,
..EditCollectionParams::default()
};
let async_edit_server = server
let mock_edit = server
.mock(
"PUT",
format!(
@@ -172,15 +162,17 @@ mod tests {
collection_id: 123,
..EditCollectionParams::default()
};
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let mut network = test_network(&app);
assert!(network
.handle_radarr_event(RadarrEvent::EditCollection(edit_collection_params))
.await
.is_ok());
assert!(
network
.handle_radarr_event(RadarrEvent::EditCollection(edit_collection_params))
.await
.is_ok()
);
async_details_server.assert_async().await;
async_edit_server.assert_async().await;
mock_details.assert_async().await;
mock_edit.assert_async().await;
}
#[rstest]
@@ -257,17 +249,11 @@ mod tests {
..collection()
},
];
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(collections_json),
None,
RadarrEvent::GetCollections,
None,
None,
)
.await;
app_arc.lock().await.data.radarr_data.collections.sort_asc = true;
let (mock, app, _server) = MockServarrApi::get()
.returns(collections_json)
.build_for(RadarrEvent::GetCollections)
.await;
app.lock().await.data.radarr_data.collections.sort_asc = true;
if use_custom_sorting {
let cmp_fn = |a: &Collection, b: &Collection| {
a.title
@@ -281,7 +267,7 @@ mod tests {
name: "Collection",
cmp_fn: Some(cmp_fn),
};
app_arc
app
.lock()
.await
.data
@@ -289,19 +275,19 @@ mod tests {
.collections
.sorting(vec![collection_sort_option]);
}
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let mut network = test_network(&app);
if let RadarrSerdeable::Collections(collections) = network
.handle_radarr_event(RadarrEvent::GetCollections)
.await
.unwrap()
{
async_server.assert_async().await;
mock.assert_async().await;
assert_eq!(
app_arc.lock().await.data.radarr_data.collections.items,
app.lock().await.data.radarr_data.collections.items,
expected_collections
);
assert!(app_arc.lock().await.data.radarr_data.collections.sort_asc);
assert!(app.lock().await.data.radarr_data.collections.sort_asc);
assert_eq!(collections, response);
}
}
@@ -366,18 +352,12 @@ mod tests {
}
}],
}]);
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(collections_json),
None,
RadarrEvent::GetCollections,
None,
None,
)
.await;
app_arc.lock().await.data.radarr_data.collections.sort_asc = true;
app_arc
let (mock, app, _server) = MockServarrApi::get()
.returns(collections_json)
.build_for(RadarrEvent::GetCollections)
.await;
app.lock().await.data.radarr_data.collections.sort_asc = true;
app
.lock()
.await
.push_navigation_stack(ActiveRadarrBlock::CollectionsSortPrompt.into());
@@ -391,53 +371,54 @@ mod tests {
name: "Collection",
cmp_fn: Some(cmp_fn),
};
app_arc
app
.lock()
.await
.data
.radarr_data
.collections
.sorting(vec![collection_sort_option]);
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let mut network = test_network(&app);
assert!(network
.handle_radarr_event(RadarrEvent::GetCollections)
.await
.is_ok());
assert!(
network
.handle_radarr_event(RadarrEvent::GetCollections)
.await
.is_ok()
);
async_server.assert_async().await;
assert!(app_arc
.lock()
.await
.data
.radarr_data
.collections
.items
.is_empty());
assert!(app_arc.lock().await.data.radarr_data.collections.sort_asc);
mock.assert_async().await;
assert!(
app
.lock()
.await
.data
.radarr_data
.collections
.items
.is_empty()
);
assert!(app.lock().await.data.radarr_data.collections.sort_asc);
}
#[tokio::test]
async fn test_handle_update_collections_event() {
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Post,
Some(json!({
let (mock, app, _server) = MockServarrApi::post()
.with_request_body(json!({
"name": "RefreshCollections"
})),
Some(json!({})),
None,
RadarrEvent::UpdateCollections,
None,
None,
)
.await;
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
}))
.returns(json!({}))
.build_for(RadarrEvent::UpdateCollections)
.await;
let mut network = test_network(&app);
assert!(network
.handle_radarr_event(RadarrEvent::UpdateCollections)
.await
.is_ok());
assert!(
network
.handle_radarr_event(RadarrEvent::UpdateCollections)
.await
.is_ok()
);
async_server.assert_async().await;
mock.assert_async().await;
}
}
src/network/radarr_network/downloads/radarr_downloads_network_tests.rs
+36 -51
View File
@@ -1,34 +1,27 @@
#[cfg(test)]
mod tests {
use crate::models::radarr_models::{DownloadsResponse, RadarrSerdeable};
use crate::network::network_tests::test_utils::mock_servarr_api;
use crate::network::radarr_network::radarr_network_test_utils::test_utils::downloads_response;
use crate::network::network_tests::test_utils::{MockServarrApi, test_network};
use crate::network::radarr_network::RadarrEvent;
use crate::network::{Network, RequestMethod};
use reqwest::Client;
use crate::network::radarr_network::radarr_network_test_utils::test_utils::downloads_response;
use serde_json::json;
use tokio_util::sync::CancellationToken;
#[tokio::test]
async fn test_handle_delete_radarr_download_event() {
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Delete,
None,
None,
None,
RadarrEvent::DeleteDownload(1),
Some("/1"),
None,
)
.await;
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let (mock, app, _server) = MockServarrApi::delete()
.path("/1")
.build_for(RadarrEvent::DeleteDownload(1))
.await;
let mut network = test_network(&app);
assert!(network
.handle_radarr_event(RadarrEvent::DeleteDownload(1))
.await
.is_ok());
assert!(
network
.handle_radarr_event(RadarrEvent::DeleteDownload(1))
.await
.is_ok()
);
async_server.assert_async().await;
mock.assert_async().await;
}
#[tokio::test]
@@ -48,26 +41,21 @@ mod tests {
});
let response: DownloadsResponse =
serde_json::from_value(downloads_response_json.clone()).unwrap();
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(downloads_response_json),
None,
RadarrEvent::GetDownloads(500),
None,
Some("pageSize=500"),
)
.await;
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let (mock, app, _server) = MockServarrApi::get()
.returns(downloads_response_json)
.path("?pageSize=500")
.build_for(RadarrEvent::GetDownloads(500))
.await;
let mut network = test_network(&app);
if let RadarrSerdeable::DownloadsResponse(downloads) = network
.handle_radarr_event(RadarrEvent::GetDownloads(500))
.await
.unwrap()
{
async_server.assert_async().await;
mock.assert_async().await;
pretty_assertions::assert_eq!(
app_arc.lock().await.data.radarr_data.downloads.items,
app.lock().await.data.radarr_data.downloads.items,
downloads_response().records
);
pretty_assertions::assert_eq!(downloads, response);
@@ -76,25 +64,22 @@ mod tests {
#[tokio::test]
async fn test_handle_update_radarr_downloads_event() {
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Post,
Some(json!({
let (mock, app, _server) = MockServarrApi::post()
.with_request_body(json!({
"name": "RefreshMonitoredDownloads"
})),
Some(json!({})),
None,
RadarrEvent::UpdateDownloads,
None,
None,
)
.await;
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
}))
.returns(json!({}))
.build_for(RadarrEvent::UpdateDownloads)
.await;
let mut network = test_network(&app);
assert!(network
.handle_radarr_event(RadarrEvent::UpdateDownloads)
.await
.is_ok());
assert!(
network
.handle_radarr_event(RadarrEvent::UpdateDownloads)
.await
.is_ok()
);
async_server.assert_async().await;
mock.assert_async().await;
}
}
src/network/radarr_network/indexers/mod.rs
+1 -1
View File
@@ -6,7 +6,7 @@ use crate::network::radarr_network::RadarrEvent;
use crate::network::{Network, RequestMethod};
use anyhow::Result;
use log::{debug, info};
use serde_json::{json, Value};
use serde_json::{Value, json};
#[cfg(test)]
#[path = "radarr_indexers_network_tests.rs"]
src/network/radarr_network/indexers/radarr_indexers_network_tests.rs
+164 -221
View File
@@ -1,40 +1,34 @@
#[cfg(test)]
mod tests {
use crate::models::HorizontallyScrollableText;
use crate::models::radarr_models::{IndexerSettings, RadarrSerdeable};
use crate::models::servarr_data::modals::IndexerTestResultModalItem;
use crate::models::servarr_models::{EditIndexerParams, Indexer, IndexerTestResult};
use crate::models::HorizontallyScrollableText;
use crate::network::network_tests::test_utils::mock_servarr_api;
use crate::network::NetworkResource;
use crate::network::network_tests::test_utils::{MockServarrApi, test_network};
use crate::network::radarr_network::RadarrEvent;
use crate::network::radarr_network::radarr_network_test_utils::test_utils::{
indexer, indexer_settings,
};
use crate::network::radarr_network::RadarrEvent;
use crate::network::{Network, NetworkResource, RequestMethod};
use bimap::BiMap;
use mockito::Matcher;
use pretty_assertions::assert_eq;
use reqwest::Client;
use serde_json::json;
use tokio_util::sync::CancellationToken;
#[tokio::test]
async fn test_handle_delete_radarr_indexer_event() {
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Delete,
None,
None,
None,
RadarrEvent::DeleteIndexer(1),
Some("/1"),
None,
)
.await;
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let (async_server, app, _server) = MockServarrApi::delete()
.path("/1")
.build_for(RadarrEvent::DeleteIndexer(1))
.await;
let mut network = test_network(&app);
assert!(network
.handle_radarr_event(RadarrEvent::DeleteIndexer(1))
.await
.is_ok());
assert!(
network
.handle_radarr_event(RadarrEvent::DeleteIndexer(1))
.await
.is_ok()
);
async_server.assert_async().await;
}
@@ -52,22 +46,18 @@ mod tests {
"whitelistedHardcodedSubs": "",
"id": 1
});
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Put,
Some(indexer_settings_json),
None,
None,
RadarrEvent::EditAllIndexerSettings(indexer_settings()),
None,
None,
)
.await;
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let (async_server, app, _server) = MockServarrApi::put()
.with_request_body(indexer_settings_json)
.build_for(RadarrEvent::EditAllIndexerSettings(indexer_settings()))
.await;
let mut network = test_network(&app);
assert!(network
.handle_radarr_event(RadarrEvent::EditAllIndexerSettings(indexer_settings()))
.await
.is_ok());
assert!(
network
.handle_radarr_event(RadarrEvent::EditAllIndexerSettings(indexer_settings()))
.await
.is_ok()
);
async_server.assert_async().await;
}
@@ -133,16 +123,11 @@ mod tests {
priority: Some(0),
..EditIndexerParams::default()
};
let (async_details_server, app_arc, mut server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(indexer_details_json),
None,
RadarrEvent::GetIndexers,
Some("/1"),
None,
)
.await;
let (async_details_server, app, mut server) = MockServarrApi::get()
.returns(indexer_details_json)
.path("/1")
.build_for(RadarrEvent::GetIndexers)
.await;
let async_edit_server = server
.mock(
"PUT",
@@ -157,22 +142,24 @@ mod tests {
.match_body(Matcher::Json(expected_indexer_edit_body_json))
.create_async()
.await;
app_arc.lock().await.data.radarr_data.tags_map =
app.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());
let mut network = test_network(&app);
assert!(network
.handle_radarr_event(RadarrEvent::EditIndexer(edit_indexer_params))
.await
.is_ok());
assert!(
network
.handle_radarr_event(RadarrEvent::EditIndexer(edit_indexer_params))
.await
.is_ok()
);
async_details_server.assert_async().await;
async_edit_server.assert_async().await;
}
#[tokio::test]
async fn test_handle_edit_radarr_indexer_event_does_not_overwrite_tags_vec_if_tag_input_string_is_none(
) {
async fn test_handle_edit_radarr_indexer_event_does_not_overwrite_tags_vec_if_tag_input_string_is_none()
{
let indexer_details_json = json!({
"enableRss": true,
"enableAutomaticSearch": true,
@@ -232,16 +219,11 @@ mod tests {
priority: Some(0),
..EditIndexerParams::default()
};
let (async_details_server, app_arc, mut server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(indexer_details_json),
None,
RadarrEvent::GetIndexers,
Some("/1"),
None,
)
.await;
let (async_details_server, app, mut server) = MockServarrApi::get()
.returns(indexer_details_json)
.path("/1")
.build_for(RadarrEvent::GetIndexers)
.await;
let async_edit_server = server
.mock(
"PUT",
@@ -256,22 +238,24 @@ mod tests {
.match_body(Matcher::Json(expected_indexer_edit_body_json))
.create_async()
.await;
app_arc.lock().await.data.radarr_data.tags_map =
app.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());
let mut network = test_network(&app);
assert!(network
.handle_radarr_event(RadarrEvent::EditIndexer(edit_indexer_params))
.await
.is_ok());
assert!(
network
.handle_radarr_event(RadarrEvent::EditIndexer(edit_indexer_params))
.await
.is_ok()
);
async_details_server.assert_async().await;
async_edit_server.assert_async().await;
}
#[tokio::test]
async fn test_handle_edit_radarr_indexer_event_does_not_add_seed_ratio_when_seed_ratio_field_is_none_in_details(
) {
async fn test_handle_edit_radarr_indexer_event_does_not_add_seed_ratio_when_seed_ratio_field_is_none_in_details()
{
let indexer_details_json = json!({
"enableRss": true,
"enableAutomaticSearch": true,
@@ -323,16 +307,11 @@ mod tests {
priority: Some(0),
..EditIndexerParams::default()
};
let (async_details_server, app_arc, mut server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(indexer_details_json),
None,
RadarrEvent::GetIndexers,
Some("/1"),
None,
)
.await;
let (async_details_server, app, mut server) = MockServarrApi::get()
.returns(indexer_details_json)
.path("/1")
.build_for(RadarrEvent::GetIndexers)
.await;
let async_edit_server = server
.mock(
"PUT",
@@ -347,22 +326,24 @@ mod tests {
.match_body(Matcher::Json(expected_indexer_edit_body_json))
.create_async()
.await;
app_arc.lock().await.data.radarr_data.tags_map =
app.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());
let mut network = test_network(&app);
assert!(network
.handle_radarr_event(RadarrEvent::EditIndexer(edit_indexer_params))
.await
.is_ok());
assert!(
network
.handle_radarr_event(RadarrEvent::EditIndexer(edit_indexer_params))
.await
.is_ok()
);
async_details_server.assert_async().await;
async_edit_server.assert_async().await;
}
#[tokio::test]
async fn test_handle_edit_radarr_indexer_event_populates_the_seed_ratio_value_when_seed_ratio_field_is_present_in_details(
) {
async fn test_handle_edit_radarr_indexer_event_populates_the_seed_ratio_value_when_seed_ratio_field_is_present_in_details()
{
let indexer_details_json = json!({
"enableRss": true,
"enableAutomaticSearch": true,
@@ -421,16 +402,11 @@ mod tests {
priority: Some(0),
..EditIndexerParams::default()
};
let (async_details_server, app_arc, mut server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(indexer_details_json),
None,
RadarrEvent::GetIndexers,
Some("/1"),
None,
)
.await;
let (async_details_server, app, mut server) = MockServarrApi::get()
.returns(indexer_details_json)
.path("/1")
.build_for(RadarrEvent::GetIndexers)
.await;
let async_edit_server = server
.mock(
"PUT",
@@ -445,14 +421,16 @@ mod tests {
.match_body(Matcher::Json(expected_indexer_edit_body_json))
.create_async()
.await;
app_arc.lock().await.data.radarr_data.tags_map =
app.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());
let mut network = test_network(&app);
assert!(network
.handle_radarr_event(RadarrEvent::EditIndexer(edit_indexer_params))
.await
.is_ok());
assert!(
network
.handle_radarr_event(RadarrEvent::EditIndexer(edit_indexer_params))
.await
.is_ok()
);
async_details_server.assert_async().await;
async_edit_server.assert_async().await;
@@ -488,16 +466,11 @@ mod tests {
..EditIndexerParams::default()
};
let (async_details_server, app_arc, mut server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(indexer_details_json.clone()),
None,
RadarrEvent::GetIndexers,
Some("/1"),
None,
)
.await;
let (async_details_server, app, mut server) = MockServarrApi::get()
.returns(indexer_details_json.clone())
.path("/1")
.build_for(RadarrEvent::GetIndexers)
.await;
let async_edit_server = server
.mock(
"PUT",
@@ -512,12 +485,14 @@ mod tests {
.match_body(Matcher::Json(indexer_details_json))
.create_async()
.await;
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let mut network = test_network(&app);
assert!(network
.handle_radarr_event(RadarrEvent::EditIndexer(edit_indexer_params))
.await
.is_ok());
assert!(
network
.handle_radarr_event(RadarrEvent::EditIndexer(edit_indexer_params))
.await
.is_ok()
);
async_details_server.assert_async().await;
async_edit_server.assert_async().await;
@@ -577,16 +552,11 @@ mod tests {
..EditIndexerParams::default()
};
let (async_details_server, app_arc, mut server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(indexer_details_json),
None,
RadarrEvent::GetIndexers,
Some("/1"),
None,
)
.await;
let (async_details_server, app, mut server) = MockServarrApi::get()
.returns(indexer_details_json)
.path("/1")
.build_for(RadarrEvent::GetIndexers)
.await;
let async_edit_server = server
.mock(
"PUT",
@@ -601,12 +571,14 @@ mod tests {
.match_body(Matcher::Json(expected_edit_indexer_body))
.create_async()
.await;
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let mut network = test_network(&app);
assert!(network
.handle_radarr_event(RadarrEvent::EditIndexer(edit_indexer_params))
.await
.is_ok());
assert!(
network
.handle_radarr_event(RadarrEvent::EditIndexer(edit_indexer_params))
.await
.is_ok()
);
async_details_server.assert_async().await;
async_edit_server.assert_async().await;
@@ -645,17 +617,11 @@ mod tests {
"id": 1
}]);
let response: Vec<Indexer> = serde_json::from_value(indexers_response_json.clone()).unwrap();
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(indexers_response_json),
None,
RadarrEvent::GetIndexers,
None,
None,
)
.await;
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let (async_server, app, _server) = MockServarrApi::get()
.returns(indexers_response_json)
.build_for(RadarrEvent::GetIndexers)
.await;
let mut network = test_network(&app);
if let RadarrSerdeable::Indexers(indexers) = network
.handle_radarr_event(RadarrEvent::GetIndexers)
@@ -664,7 +630,7 @@ mod tests {
{
async_server.assert_async().await;
assert_eq!(
app_arc.lock().await.data.radarr_data.indexers.items,
app.lock().await.data.radarr_data.indexers.items,
vec![indexer()]
);
assert_eq!(indexers, response);
@@ -686,17 +652,11 @@ mod tests {
});
let response: IndexerSettings =
serde_json::from_value(indexer_settings_response_json.clone()).unwrap();
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(indexer_settings_response_json),
None,
RadarrEvent::GetAllIndexerSettings,
None,
None,
)
.await;
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let (async_server, app, _server) = MockServarrApi::get()
.returns(indexer_settings_response_json)
.build_for(RadarrEvent::GetAllIndexerSettings)
.await;
let mut network = test_network(&app);
if let RadarrSerdeable::IndexerSettings(settings) = network
.handle_radarr_event(RadarrEvent::GetAllIndexerSettings)
@@ -705,7 +665,7 @@ mod tests {
{
async_server.assert_async().await;
assert_eq!(
app_arc.lock().await.data.radarr_data.indexer_settings,
app.lock().await.data.radarr_data.indexer_settings,
Some(indexer_settings())
);
assert_eq!(settings, response);
@@ -725,27 +685,23 @@ mod tests {
"whitelistedHardcodedSubs": "",
"id": 1
});
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(indexer_settings_response_json),
None,
RadarrEvent::GetAllIndexerSettings,
None,
None,
)
.await;
app_arc.lock().await.data.radarr_data.indexer_settings = Some(IndexerSettings::default());
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let (async_server, app, _server) = MockServarrApi::get()
.returns(indexer_settings_response_json)
.build_for(RadarrEvent::GetAllIndexerSettings)
.await;
app.lock().await.data.radarr_data.indexer_settings = Some(IndexerSettings::default());
let mut network = test_network(&app);
assert!(network
.handle_radarr_event(RadarrEvent::GetAllIndexerSettings)
.await
.is_ok());
assert!(
network
.handle_radarr_event(RadarrEvent::GetAllIndexerSettings)
.await
.is_ok()
);
async_server.assert_async().await;
assert_eq!(
app_arc.lock().await.data.radarr_data.indexer_settings,
app.lock().await.data.radarr_data.indexer_settings,
Some(IndexerSettings::default())
);
}
@@ -781,16 +737,11 @@ mod tests {
"errorMessage": "test failure",
"severity": "error"
}]);
let (async_details_server, app_arc, mut server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(indexer_details_json.clone()),
None,
RadarrEvent::GetIndexers,
Some("/1"),
None,
)
.await;
let (async_details_server, app, mut server) = MockServarrApi::get()
.returns(indexer_details_json.clone())
.path("/1")
.build_for(RadarrEvent::GetIndexers)
.await;
let async_test_server = server
.mock(
"POST",
@@ -802,7 +753,7 @@ mod tests {
.with_body(response_json.to_string())
.create_async()
.await;
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let mut network = test_network(&app);
if let RadarrSerdeable::Value(value) = network
.handle_radarr_event(RadarrEvent::TestIndexer(1))
@@ -812,7 +763,7 @@ mod tests {
async_details_server.assert_async().await;
async_test_server.assert_async().await;
assert_eq!(
app_arc.lock().await.data.radarr_data.indexer_test_errors,
app.lock().await.data.radarr_data.indexer_test_errors,
Some("\"test failure\"".to_owned())
);
assert_eq!(value, response_json)
@@ -843,16 +794,11 @@ mod tests {
"tags": [1],
"id": 1
});
let (async_details_server, app_arc, mut server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(indexer_details_json.clone()),
None,
RadarrEvent::GetIndexers,
Some("/1"),
None,
)
.await;
let (async_details_server, app, mut server) = MockServarrApi::get()
.returns(indexer_details_json.clone())
.path("/1")
.build_for(RadarrEvent::GetIndexers)
.await;
let async_test_server = server
.mock(
"POST",
@@ -864,7 +810,7 @@ mod tests {
.with_body("{}")
.create_async()
.await;
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let mut network = test_network(&app);
if let RadarrSerdeable::Value(value) = network
.handle_radarr_event(RadarrEvent::TestIndexer(1))
@@ -874,7 +820,7 @@ mod tests {
async_details_server.assert_async().await;
async_test_server.assert_async().await;
assert_eq!(
app_arc.lock().await.data.radarr_data.indexer_test_errors,
app.lock().await.data.radarr_data.indexer_test_errors,
Some(String::new())
);
assert_eq!(value, json!({}));
@@ -930,24 +876,19 @@ mod tests {
]
}]);
let response: Vec<IndexerTestResult> = serde_json::from_value(response_json.clone()).unwrap();
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Post,
None,
Some(response_json),
Some(400),
RadarrEvent::TestAllIndexers,
None,
None,
)
.await;
app_arc
let (async_server, app, _server) = MockServarrApi::post()
.returns(response_json)
.status(400)
.build_for(RadarrEvent::TestAllIndexers)
.await;
app
.lock()
.await
.data
.radarr_data
.indexers
.set_items(indexers);
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let mut network = test_network(&app);
if let RadarrSerdeable::IndexerTestResults(results) = network
.handle_radarr_event(RadarrEvent::TestAllIndexers)
@@ -955,15 +896,17 @@ mod tests {
.unwrap()
{
async_server.assert_async().await;
assert!(app_arc
.lock()
.await
.data
.radarr_data
.indexer_test_all_results
.is_some());
assert!(
app
.lock()
.await
.data
.radarr_data
.indexer_test_all_results
.is_some()
);
assert_eq!(
app_arc
app
.lock()
.await
.data
src/network/radarr_network/library/mod.rs
+4 -2
View File
@@ -13,7 +13,7 @@ use crate::utils::{convert_runtime, convert_to_gb};
use anyhow::Result;
use indoc::formatdoc;
use log::{debug, info, warn};
use serde_json::{json, Value};
use serde_json::{Value, json};
use urlencoding::encode;
#[cfg(test)]
@@ -53,7 +53,9 @@ impl Network<'_, '_> {
delete_movie_files,
add_list_exclusion,
} = delete_movie_params;
info!("Deleting Radarr movie with ID: {id} with deleteFiles={delete_movie_files} and addImportExclusion={add_list_exclusion}");
info!(
"Deleting Radarr movie with ID: {id} with deleteFiles={delete_movie_files} and addImportExclusion={add_list_exclusion}"
);
let request_props = self
.request_props_from(
src/network/radarr_network/library/radarr_library_network_tests.rs
+366 -446
View File
File diff suppressed because it is too large Load Diff
src/network/radarr_network/mod.rs
+1 -1
View File
@@ -2,7 +2,7 @@ use anyhow::Result;
use std::fmt::Debug;
use log::info;
use serde_json::{json, Value};
use serde_json::{Value, json};
use crate::models::radarr_models::{
AddMovieBody, DeleteMovieParams, EditCollectionParams, EditMovieParams, IndexerSettings,
src/network/radarr_network/radarr_network_test_utils.rs
+16 -2
View File
@@ -1,5 +1,6 @@
#[cfg(test)]
pub(in crate::network::radarr_network) mod test_utils {
use crate::models::HorizontallyScrollableText;
use crate::models::radarr_models::{
AddMovieSearchResult, BlocklistItem, BlocklistItemMovie, Collection, CollectionMovie, Credit,
CreditType, DownloadRecord, DownloadsResponse, IndexerSettings, MediaInfo, MinimumAvailability,
@@ -8,9 +9,8 @@ pub(in crate::network::radarr_network) mod test_utils {
use crate::models::servarr_models::{
Indexer, IndexerField, Language, Quality, QualityWrapper, RootFolder,
};
use crate::models::HorizontallyScrollableText;
use chrono::DateTime;
use serde_json::{json, Number};
use serde_json::{Number, Value, json};
pub const MOVIE_JSON: &str = r#"{
"id": 1,
@@ -378,4 +378,18 @@ pub(in crate::network::radarr_network) mod test_utils {
..IndexerSettings::default()
}
}
pub fn tag() -> Value {
json!({
"id": 3,
"label": "testing"
})
}
pub fn quality_profile() -> Value {
json!({
"id": 2222,
"name": "HD - 1080p"
})
}
}
src/network/radarr_network/radarr_network_tests.rs
+113 -134
View File
@@ -1,21 +1,22 @@
#[cfg(test)]
mod test {
use super::super::*;
use crate::App;
use crate::models::radarr_models::{
EditCollectionParams, EditMovieParams, IndexerSettings, RadarrTaskName,
};
use crate::models::servarr_data::radarr::modals::EditMovieModal;
use crate::models::servarr_models::EditIndexerParams;
use crate::network::network_tests::test_utils::mock_servarr_api;
use crate::App;
use crate::network::network_tests::test_utils::{MockServarrApi, test_network};
use crate::network::radarr_network::radarr_network_test_utils::test_utils::{
quality_profile, tag,
};
use bimap::BiMap;
use pretty_assertions::{assert_eq, assert_str_eq};
use reqwest::Client;
use rstest::rstest;
use serde_json::json;
use std::sync::Arc;
use tokio::sync::Mutex;
use tokio_util::sync::CancellationToken;
#[rstest]
fn test_resource_movie(
@@ -161,146 +162,129 @@ mod test {
#[tokio::test]
async fn test_handle_get_radarr_healthcheck_event() {
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
None,
None,
RadarrEvent::HealthCheck,
None,
None,
)
.await;
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let (mock, app, _server) = MockServarrApi::get()
.build_for(RadarrEvent::HealthCheck)
.await;
let mut network = test_network(&app);
let _ = network.handle_radarr_event(RadarrEvent::HealthCheck).await;
async_server.assert_async().await;
mock.assert_async().await;
}
#[tokio::test]
async fn test_handle_get_radarr_quality_profiles_event() {
let quality_profile_json = json!([{
"id": 2222,
"name": "HD - 1080p"
}]);
let response: Vec<QualityProfile> =
serde_json::from_value(quality_profile_json.clone()).unwrap();
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(quality_profile_json),
None,
RadarrEvent::GetQualityProfiles,
None,
None,
)
.await;
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let expected: Vec<QualityProfile> = vec![QualityProfile {
id: 2222,
name: "HD - 1080p".to_owned(),
}];
if let RadarrSerdeable::QualityProfiles(quality_profiles) = network
let (mock, app, _server) = MockServarrApi::get()
.returns(json!([quality_profile()]))
.build_for(RadarrEvent::GetQualityProfiles)
.await;
let mut network = test_network(&app);
let result = network
.handle_radarr_event(RadarrEvent::GetQualityProfiles)
.await
.unwrap()
{
async_server.assert_async().await;
assert_eq!(
app_arc.lock().await.data.radarr_data.quality_profile_map,
BiMap::from_iter([(2222i64, "HD - 1080p".to_owned())])
);
assert_eq!(quality_profiles, response);
}
.await;
mock.assert_async().await;
let RadarrSerdeable::QualityProfiles(quality_profiles) = result.unwrap() else {
panic!("Expected QualityProfiles variant");
};
assert_eq!(quality_profiles, expected);
assert_eq!(
app.lock().await.data.radarr_data.quality_profile_map,
BiMap::from_iter([(2222i64, "HD - 1080p".to_owned())])
);
}
#[tokio::test]
async fn test_handle_get_radarr_tags_event() {
let tags_json = json!([{
"id": 2222,
"label": "usenet"
}]);
let response: Vec<Tag> = serde_json::from_value(tags_json.clone()).unwrap();
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(tags_json),
None,
RadarrEvent::GetTags,
None,
None,
)
.await;
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let expected: Vec<Tag> = vec![Tag {
id: 2222,
label: "usenet".to_owned(),
}];
if let RadarrSerdeable::Tags(tags) = network
.handle_radarr_event(RadarrEvent::GetTags)
.await
.unwrap()
{
async_server.assert_async().await;
assert_eq!(
app_arc.lock().await.data.radarr_data.tags_map,
BiMap::from_iter([(2222i64, "usenet".to_owned())])
);
assert_eq!(tags, response);
}
let (mock, app, _server) = MockServarrApi::get()
.returns(json!([{
"id": 2222,
"label": "usenet"
}]))
.build_for(RadarrEvent::GetTags)
.await;
let mut network = test_network(&app);
let result = network.handle_radarr_event(RadarrEvent::GetTags).await;
mock.assert_async().await;
let RadarrSerdeable::Tags(tags) = result.unwrap() else {
panic!("Expected Tags variant");
};
assert_eq!(tags, expected);
assert_eq!(
app.lock().await.data.radarr_data.tags_map,
BiMap::from_iter([(2222i64, "usenet".to_owned())])
);
}
#[tokio::test]
async fn test_handle_add_radarr_tag() {
let tag_json = json!({ "id": 3, "label": "testing" });
let response: Tag = serde_json::from_value(tag_json.clone()).unwrap();
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Post,
Some(json!({ "label": "testing" })),
Some(tag_json),
None,
RadarrEvent::AddTag(String::new()),
None,
None,
)
.await;
app_arc.lock().await.data.radarr_data.tags_map =
BiMap::from_iter([(1, "usenet".to_owned()), (2, "test".to_owned())]);
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let expected = Tag {
id: 3,
label: "testing".to_owned(),
};
if let RadarrSerdeable::Tag(tag) = network
let (mock, app, _server) = MockServarrApi::post()
.with_request_body(json!({ "label": "testing" }))
.returns(tag())
.build_for(RadarrEvent::AddTag(String::new()))
.await;
app.lock().await.data.radarr_data.tags_map =
BiMap::from_iter([(1, "usenet".to_owned()), (2, "test".to_owned())]);
let mut network = test_network(&app);
let result = network
.handle_radarr_event(RadarrEvent::AddTag("testing".to_owned()))
.await
.unwrap()
{
async_server.assert_async().await;
assert_eq!(
app_arc.lock().await.data.radarr_data.tags_map,
BiMap::from_iter([
(1, "usenet".to_owned()),
(2, "test".to_owned()),
(3, "testing".to_owned())
])
);
assert_eq!(tag, response);
}
.await;
mock.assert_async().await;
let RadarrSerdeable::Tag(tag) = result.unwrap() else {
panic!("Expected Tag variant");
};
assert_eq!(tag, expected);
assert_eq!(
app.lock().await.data.radarr_data.tags_map,
BiMap::from_iter([
(1, "usenet".to_owned()),
(2, "test".to_owned()),
(3, "testing".to_owned())
])
);
}
#[tokio::test]
async fn test_handle_delete_radarr_tag_event() {
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Delete,
None,
None,
None,
RadarrEvent::DeleteTag(1),
Some("/1"),
None,
)
.await;
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let (mock, app, _server) = MockServarrApi::delete()
.path("/1")
.build_for(RadarrEvent::DeleteTag(1))
.await;
assert!(network
.handle_radarr_event(RadarrEvent::DeleteTag(1))
.await
.is_ok());
let mut network = test_network(&app);
async_server.assert_async().await;
let result = network.handle_radarr_event(RadarrEvent::DeleteTag(1)).await;
mock.assert_async().await;
assert!(result.is_ok());
}
#[tokio::test]
@@ -315,7 +299,7 @@ mod test {
(3, "hi".to_owned()),
]);
}
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let mut network = test_network(&app_arc);
assert_eq!(
network.extract_and_add_radarr_tag_ids_vec(tags).await,
@@ -325,34 +309,29 @@ mod test {
#[tokio::test]
async fn test_extract_and_add_radarr_tag_ids_vec_add_missing_tags_first() {
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Post,
Some(json!({ "label": "TESTING" })),
Some(json!({ "id": 3, "label": "testing" })),
None,
RadarrEvent::GetTags,
None,
None,
)
.await;
let (async_server, app, _server) = MockServarrApi::post()
.with_request_body(json!({ "label": "TESTING" }))
.returns(json!({ "id": 3, "label": "testing" }))
.build_for(RadarrEvent::GetTags)
.await;
let tags = "usenet, test, TESTING";
{
let mut app = app_arc.lock().await;
app.data.radarr_data.edit_movie_modal = Some(EditMovieModal {
let mut app_guard = app.lock().await;
app_guard.data.radarr_data.edit_movie_modal = Some(EditMovieModal {
tags: tags.into(),
..EditMovieModal::default()
});
app.data.radarr_data.tags_map =
app_guard.data.radarr_data.tags_map =
BiMap::from_iter([(1, "usenet".to_owned()), (2, "test".to_owned())]);
}
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let mut network = test_network(&app);
let tag_ids_vec = network.extract_and_add_radarr_tag_ids_vec(tags).await;
async_server.assert_async().await;
assert_eq!(tag_ids_vec, vec![1, 2, 3]);
assert_eq!(
app_arc.lock().await.data.radarr_data.tags_map,
app.lock().await.data.radarr_data.tags_map,
BiMap::from_iter([
(1, "usenet".to_owned()),
(2, "test".to_owned()),
src/network/radarr_network/root_folders/radarr_root_folders_network_tests.rs
+35 -51
View File
@@ -2,62 +2,52 @@
mod tests {
use crate::models::radarr_models::RadarrSerdeable;
use crate::models::servarr_models::{AddRootFolderBody, RootFolder};
use crate::network::network_tests::test_utils::mock_servarr_api;
use crate::network::radarr_network::radarr_network_test_utils::test_utils::root_folder;
use crate::network::network_tests::test_utils::{MockServarrApi, test_network};
use crate::network::radarr_network::RadarrEvent;
use crate::network::{Network, RequestMethod};
use crate::network::radarr_network::radarr_network_test_utils::test_utils::root_folder;
use pretty_assertions::assert_eq;
use reqwest::Client;
use serde_json::json;
use tokio_util::sync::CancellationToken;
#[tokio::test]
async fn test_handle_add_radarr_root_folder_event() {
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Post,
Some(json!({
let (mock, app, _server) = MockServarrApi::post()
.with_request_body(json!({
"path": "/nfs/test"
})),
Some(json!({})),
None,
RadarrEvent::AddRootFolder(AddRootFolderBody::default()),
None,
None,
)
.await;
}))
.returns(json!({}))
.build_for(RadarrEvent::AddRootFolder(AddRootFolderBody::default()))
.await;
let add_root_folder_body = AddRootFolderBody {
path: "/nfs/test".to_owned(),
};
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let mut network = test_network(&app);
assert!(network
.handle_radarr_event(RadarrEvent::AddRootFolder(add_root_folder_body))
.await
.is_ok());
assert!(
network
.handle_radarr_event(RadarrEvent::AddRootFolder(add_root_folder_body))
.await
.is_ok()
);
async_server.assert_async().await;
mock.assert_async().await;
}
#[tokio::test]
async fn test_handle_delete_radarr_root_folder_event() {
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Delete,
None,
None,
None,
RadarrEvent::DeleteRootFolder(1),
Some("/1"),
None,
)
.await;
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let (mock, app, _server) = MockServarrApi::delete()
.path("/1")
.build_for(RadarrEvent::DeleteRootFolder(1))
.await;
let mut network = test_network(&app);
assert!(network
.handle_radarr_event(RadarrEvent::DeleteRootFolder(1))
.await
.is_ok());
assert!(
network
.handle_radarr_event(RadarrEvent::DeleteRootFolder(1))
.await
.is_ok()
);
async_server.assert_async().await;
mock.assert_async().await;
}
#[tokio::test]
@@ -69,26 +59,20 @@ mod tests {
"freeSpace": 219902325555200u64,
}]);
let response: Vec<RootFolder> = serde_json::from_value(root_folder_json.clone()).unwrap();
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(root_folder_json),
None,
RadarrEvent::GetRootFolders,
None,
None,
)
.await;
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let (mock, app, _server) = MockServarrApi::get()
.returns(root_folder_json)
.build_for(RadarrEvent::GetRootFolders)
.await;
let mut network = test_network(&app);
if let RadarrSerdeable::RootFolders(root_folders) = network
.handle_radarr_event(RadarrEvent::GetRootFolders)
.await
.unwrap()
{
async_server.assert_async().await;
mock.assert_async().await;
assert_eq!(
app_arc.lock().await.data.radarr_data.root_folders.items,
app.lock().await.data.radarr_data.root_folders.items,
vec![root_folder()]
);
assert_eq!(root_folders, response);
src/network/radarr_network/system/radarr_system_network_tests.rs
+75 -129
View File
@@ -5,22 +5,17 @@ mod tests {
DiskSpace, HostConfig, LogResponse, QueueEvent, SecurityConfig, Update,
};
use crate::models::{HorizontallyScrollableText, ScrollableText};
use crate::network::network_tests::test_utils::mock_servarr_api;
use crate::network::network_tests::test_utils::{MockServarrApi, test_network};
use crate::network::radarr_network::RadarrEvent;
use crate::network::{Network, RequestMethod};
use chrono::DateTime;
use indoc::formatdoc;
use pretty_assertions::{assert_eq, assert_str_eq};
use reqwest::Client;
use serde_json::json;
use tokio_util::sync::CancellationToken;
#[tokio::test]
async fn test_handle_get_radarr_diskspace_event() {
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(json!([
let (mock, app, _server) = MockServarrApi::get()
.returns(json!([
{
"freeSpace": 1111,
"totalSpace": 2222,
@@ -29,14 +24,10 @@ mod tests {
"freeSpace": 3333,
"totalSpace": 4444
}
])),
None,
RadarrEvent::GetDiskSpace,
None,
None,
)
.await;
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
]))
.build_for(RadarrEvent::GetDiskSpace)
.await;
let mut network = test_network(&app);
let disk_space_vec = vec![
DiskSpace {
free_space: 1111,
@@ -53,9 +44,9 @@ mod tests {
.await
.unwrap()
{
async_server.assert_async().await;
mock.assert_async().await;
assert_eq!(
app_arc.lock().await.data.radarr_data.disk_space_vec,
app.lock().await.data.radarr_data.disk_space_vec,
disk_space_vec
);
assert_eq!(disk_space, disk_space_vec);
@@ -76,24 +67,18 @@ mod tests {
"sslCertPassword": "test"
});
let response: HostConfig = serde_json::from_value(host_config_response.clone()).unwrap();
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(host_config_response),
None,
RadarrEvent::GetHostConfig,
None,
None,
)
.await;
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let (mock, app, _server) = MockServarrApi::get()
.returns(host_config_response)
.build_for(RadarrEvent::GetHostConfig)
.await;
let mut network = test_network(&app);
if let RadarrSerdeable::HostConfig(host_config) = network
.handle_radarr_event(RadarrEvent::GetHostConfig)
.await
.unwrap()
{
async_server.assert_async().await;
mock.assert_async().await;
assert_eq!(host_config, response);
}
}
@@ -131,37 +116,31 @@ mod tests {
]
});
let response: LogResponse = serde_json::from_value(logs_response_json.clone()).unwrap();
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(logs_response_json),
None,
RadarrEvent::GetLogs(500),
None,
Some("pageSize=500&sortDirection=descending&sortKey=time"),
)
.await;
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let (mock, app, _server) = MockServarrApi::get()
.returns(logs_response_json)
.query("pageSize=500&sortDirection=descending&sortKey=time")
.build_for(RadarrEvent::GetLogs(500))
.await;
let mut network = test_network(&app);
if let RadarrSerdeable::LogResponse(logs) = network
.handle_radarr_event(RadarrEvent::GetLogs(500))
.await
.unwrap()
{
async_server.assert_async().await;
assert_eq!(
app_arc.lock().await.data.radarr_data.logs.items,
expected_logs
mock.assert_async().await;
assert_eq!(app.lock().await.data.radarr_data.logs.items, expected_logs);
assert!(
app
.lock()
.await
.data
.radarr_data
.logs
.current_selection()
.text
.contains("INFO")
);
assert!(app_arc
.lock()
.await
.data
.radarr_data
.logs
.current_selection()
.text
.contains("INFO"));
assert_eq!(logs, response);
}
}
@@ -191,26 +170,20 @@ mod tests {
trigger: "scheduled".to_owned(),
};
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(queued_events_json),
None,
RadarrEvent::GetQueuedEvents,
None,
None,
)
.await;
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let (mock, app, _server) = MockServarrApi::get()
.returns(queued_events_json)
.build_for(RadarrEvent::GetQueuedEvents)
.await;
let mut network = test_network(&app);
if let RadarrSerdeable::QueueEvents(events) = network
.handle_radarr_event(RadarrEvent::GetQueuedEvents)
.await
.unwrap()
{
async_server.assert_async().await;
mock.assert_async().await;
assert_eq!(
app_arc.lock().await.data.radarr_data.queued_events.items,
app.lock().await.data.radarr_data.queued_events.items,
vec![expected_event]
);
assert_eq!(events, response);
@@ -229,44 +202,32 @@ mod tests {
});
let response: SecurityConfig =
serde_json::from_value(security_config_response.clone()).unwrap();
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(security_config_response),
None,
RadarrEvent::GetSecurityConfig,
None,
None,
)
.await;
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let (mock, app, _server) = MockServarrApi::get()
.returns(security_config_response)
.build_for(RadarrEvent::GetSecurityConfig)
.await;
let mut network = test_network(&app);
if let RadarrSerdeable::SecurityConfig(security_config) = network
.handle_radarr_event(RadarrEvent::GetSecurityConfig)
.await
.unwrap()
{
async_server.assert_async().await;
mock.assert_async().await;
assert_eq!(security_config, response);
}
}
#[tokio::test]
async fn test_handle_get_radarr_status_event() {
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(json!({
let (async_server, app, _server) = MockServarrApi::get()
.returns(json!({
"version": "v1",
"startTime": "2023-02-25T20:16:43Z"
})),
None,
RadarrEvent::GetStatus,
None,
None,
)
.await;
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
}))
.build_for(RadarrEvent::GetStatus)
.await;
let mut network = test_network(&app);
let date_time = DateTime::from(DateTime::parse_from_rfc3339("2023-02-25T20:16:43Z").unwrap());
if let RadarrSerdeable::SystemStatus(status) = network
@@ -275,8 +236,8 @@ mod tests {
.unwrap()
{
async_server.assert_async().await;
assert_str_eq!(app_arc.lock().await.data.radarr_data.version, "v1");
assert_eq!(app_arc.lock().await.data.radarr_data.start_time, date_time);
assert_str_eq!(app.lock().await.data.radarr_data.version, "v1");
assert_eq!(app.lock().await.data.radarr_data.start_time, date_time);
assert_eq!(
status,
SystemStatus {
@@ -356,17 +317,11 @@ mod tests {
* Killed bug 1
* Fixed bug 2"
));
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(updates_json),
None,
RadarrEvent::GetUpdates,
None,
None,
)
.await;
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let (async_server, app, _server) = MockServarrApi::get()
.returns(updates_json)
.build_for(RadarrEvent::GetUpdates)
.await;
let mut network = test_network(&app);
if let RadarrSerdeable::Updates(updates) = network
.handle_radarr_event(RadarrEvent::GetUpdates)
@@ -375,7 +330,7 @@ mod tests {
{
async_server.assert_async().await;
assert_str_eq!(
app_arc.lock().await.data.radarr_data.updates.get_text(),
app.lock().await.data.radarr_data.updates.get_text(),
expected_text.get_text()
);
assert_eq!(updates, response);
@@ -420,17 +375,11 @@ mod tests {
last_duration: "00:00:00.5111547".to_owned(),
},
];
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(tasks_json),
None,
RadarrEvent::GetTasks,
None,
None,
)
.await;
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let (async_server, app, _server) = MockServarrApi::get()
.returns(tasks_json)
.build_for(RadarrEvent::GetTasks)
.await;
let mut network = test_network(&app);
if let RadarrSerdeable::Tasks(tasks) = network
.handle_radarr_event(RadarrEvent::GetTasks)
@@ -439,7 +388,7 @@ mod tests {
{
async_server.assert_async().await;
assert_eq!(
app_arc.lock().await.data.radarr_data.tasks.items,
app.lock().await.data.radarr_data.tasks.items,
expected_tasks
);
assert_eq!(tasks, response);
@@ -449,19 +398,16 @@ mod tests {
#[tokio::test]
async fn test_handle_start_radarr_task_event() {
let response = json!({ "test": "test"});
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Post,
Some(json!({
let (async_server, app, _server) = MockServarrApi::post()
.with_request_body(json!({
"name": "ApplicationCheckUpdate"
})),
Some(response.clone()),
None,
RadarrEvent::StartTask(RadarrTaskName::ApplicationCheckUpdate),
None,
None,
)
.await;
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
}))
.returns(response.clone())
.build_for(RadarrEvent::StartTask(
RadarrTaskName::ApplicationCheckUpdate,
))
.await;
let mut network = test_network(&app);
if let RadarrSerdeable::Value(value) = network
.handle_radarr_event(RadarrEvent::StartTask(