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/sonarr_network/blocklist/mod.rs
+2 -2
View File
@@ -1,11 +1,11 @@
use crate::models::Route;
use crate::models::servarr_data::sonarr::sonarr_data::ActiveSonarrBlock;
use crate::models::sonarr_models::{BlocklistItem, BlocklistResponse};
use crate::models::Route;
use crate::network::sonarr_network::SonarrEvent;
use crate::network::{Network, RequestMethod};
use anyhow::Result;
use log::info;
use serde_json::{json, Value};
use serde_json::{Value, json};
#[cfg(test)]
#[path = "sonarr_blocklist_network_tests.rs"]
src/network/sonarr_network/blocklist/sonarr_blocklist_network_tests.rs
+55 -78
View File
@@ -3,17 +3,14 @@ mod tests {
use crate::models::servarr_data::sonarr::sonarr_data::ActiveSonarrBlock;
use crate::models::sonarr_models::{BlocklistItem, BlocklistResponse, Series, SonarrSerdeable};
use crate::models::stateful_table::SortOption;
use crate::network::network_tests::test_utils::mock_servarr_api;
use crate::network::network_tests::test_utils::{MockServarrApi, test_network};
use crate::network::sonarr_network::SonarrEvent;
use crate::network::sonarr_network::sonarr_network_test_utils::test_utils::{
blocklist_item, series,
};
use crate::network::sonarr_network::SonarrEvent;
use crate::network::{Network, RequestMethod};
use pretty_assertions::assert_eq;
use reqwest::Client;
use rstest::rstest;
use serde_json::{json, Number};
use tokio_util::sync::CancellationToken;
use serde_json::{Number, json};
#[tokio::test]
async fn test_handle_clear_sonarr_blocklist_event() {
@@ -32,62 +29,54 @@ 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,
SonarrEvent::ClearBlocklist,
None,
None,
)
.await;
app_arc
let (mock, app, _server) = MockServarrApi::delete()
.with_request_body(expected_request_json)
.build_for(SonarrEvent::ClearBlocklist)
.await;
app
.lock()
.await
.data
.sonarr_data
.blocklist
.set_items(blocklist_items);
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
assert!(network
.handle_sonarr_event(SonarrEvent::ClearBlocklist)
.await
.is_ok());
assert!(
network
.handle_sonarr_event(SonarrEvent::ClearBlocklist)
.await
.is_ok()
);
async_server.assert_async().await;
mock.assert_async().await;
}
#[tokio::test]
async fn test_handle_delete_sonarr_blocklist_item_event() {
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Delete,
None,
None,
None,
SonarrEvent::DeleteBlocklistItem(1),
Some("/1"),
None,
)
.await;
app_arc
let (mock, app, _server) = MockServarrApi::delete()
.path("/1")
.build_for(SonarrEvent::DeleteBlocklistItem(1))
.await;
app
.lock()
.await
.data
.sonarr_data
.blocklist
.set_items(vec![blocklist_item()]);
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
assert!(network
.handle_sonarr_event(SonarrEvent::DeleteBlocklistItem(1))
.await
.is_ok());
assert!(
network
.handle_sonarr_event(SonarrEvent::DeleteBlocklistItem(1))
.await
.is_ok()
);
async_server.assert_async().await;
mock.assert_async().await;
}
#[rstest]
@@ -135,17 +124,11 @@ mod tests {
..blocklist_item()
},
];
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(blocklist_json),
None,
SonarrEvent::GetBlocklist,
None,
None,
)
.await;
app_arc
let (mock, app, _server) = MockServarrApi::get()
.returns(blocklist_json)
.build_for(SonarrEvent::GetBlocklist)
.await;
app
.lock()
.await
.data
@@ -156,7 +139,7 @@ mod tests {
title: "Z Series".into(),
..series()
}]);
app_arc.lock().await.data.sonarr_data.blocklist.sort_asc = true;
app.lock().await.data.sonarr_data.blocklist.sort_asc = true;
if use_custom_sorting {
let cmp_fn = |a: &BlocklistItem, b: &BlocklistItem| {
a.source_title
@@ -169,7 +152,7 @@ mod tests {
name: "Source Title",
cmp_fn: Some(cmp_fn),
};
app_arc
app
.lock()
.await
.data
@@ -177,20 +160,20 @@ mod tests {
.blocklist
.sorting(vec![blocklist_sort_option]);
}
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
if let SonarrSerdeable::BlocklistResponse(blocklist) = network
.handle_sonarr_event(SonarrEvent::GetBlocklist)
.await
.unwrap()
{
async_server.assert_async().await;
mock.assert_async().await;
assert_eq!(
app_arc.lock().await.data.sonarr_data.blocklist.items,
app.lock().await.data.sonarr_data.blocklist.items,
expected_blocklist
);
assert!(app_arc.lock().await.data.sonarr_data.blocklist.sort_asc);
assert!(app.lock().await.data.sonarr_data.blocklist.sort_asc);
assert_eq!(blocklist, response);
}
}
@@ -222,18 +205,12 @@ mod tests {
"id": 456
}]});
let response: BlocklistResponse = serde_json::from_value(blocklist_json.clone()).unwrap();
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(blocklist_json),
None,
SonarrEvent::GetBlocklist,
None,
None,
)
.await;
app_arc.lock().await.data.sonarr_data.blocklist.sort_asc = true;
app_arc
let (mock, app, _server) = MockServarrApi::get()
.returns(blocklist_json)
.build_for(SonarrEvent::GetBlocklist)
.await;
app.lock().await.data.sonarr_data.blocklist.sort_asc = true;
app
.lock()
.await
.push_navigation_stack(ActiveSonarrBlock::BlocklistSortPrompt.into());
@@ -246,24 +223,24 @@ mod tests {
name: "Source Title",
cmp_fn: Some(cmp_fn),
};
app_arc
app
.lock()
.await
.data
.sonarr_data
.blocklist
.sorting(vec![blocklist_sort_option]);
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
if let SonarrSerdeable::BlocklistResponse(blocklist) = network
.handle_sonarr_event(SonarrEvent::GetBlocklist)
.await
.unwrap()
{
async_server.assert_async().await;
assert!(app_arc.lock().await.data.sonarr_data.blocklist.is_empty());
assert!(app_arc.lock().await.data.sonarr_data.blocklist.sort_asc);
mock.assert_async().await;
assert!(app.lock().await.data.sonarr_data.blocklist.is_empty());
assert!(app.lock().await.data.sonarr_data.blocklist.sort_asc);
assert_eq!(blocklist, response);
}
}
src/network/sonarr_network/downloads/sonarr_downloads_network_tests.rs
+40 -55
View File
@@ -1,45 +1,38 @@
#[cfg(test)]
mod tests {
use crate::models::sonarr_models::{DownloadsResponse, SonarrSerdeable};
use crate::network::network_tests::test_utils::mock_servarr_api;
use crate::network::network_tests::test_utils::{MockServarrApi, test_network};
use crate::network::sonarr_network::SonarrEvent;
use crate::network::sonarr_network::sonarr_network_test_utils::test_utils::{
download_record, downloads_response,
};
use crate::network::sonarr_network::SonarrEvent;
use crate::network::{Network, RequestMethod};
use pretty_assertions::assert_eq;
use reqwest::Client;
use serde_json::json;
use tokio_util::sync::CancellationToken;
#[tokio::test]
async fn test_handle_delete_sonarr_download_event() {
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Delete,
None,
None,
None,
SonarrEvent::DeleteDownload(1),
Some("/1"),
None,
)
.await;
app_arc
let (mock, app, _server) = MockServarrApi::delete()
.path("/1")
.build_for(SonarrEvent::DeleteDownload(1))
.await;
app
.lock()
.await
.data
.sonarr_data
.downloads
.set_items(vec![download_record()]);
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
assert!(network
.handle_sonarr_event(SonarrEvent::DeleteDownload(1))
.await
.is_ok());
assert!(
network
.handle_sonarr_event(SonarrEvent::DeleteDownload(1))
.await
.is_ok()
);
async_server.assert_async().await;
mock.assert_async().await;
}
#[tokio::test]
@@ -59,27 +52,22 @@ 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,
SonarrEvent::GetDownloads(500),
None,
Some("pageSize=500"),
)
.await;
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let (mock, app, _server) = MockServarrApi::get()
.returns(downloads_response_json)
.query("pageSize=500")
.build_for(SonarrEvent::GetDownloads(500))
.await;
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
if let SonarrSerdeable::DownloadsResponse(downloads) = network
.handle_sonarr_event(SonarrEvent::GetDownloads(500))
.await
.unwrap()
{
async_server.assert_async().await;
mock.assert_async().await;
assert_eq!(
app_arc.lock().await.data.sonarr_data.downloads.items,
app.lock().await.data.sonarr_data.downloads.items,
downloads_response().records
);
assert_eq!(downloads, response);
@@ -88,26 +76,23 @@ mod tests {
#[tokio::test]
async fn test_handle_update_sonarr_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,
SonarrEvent::UpdateDownloads,
None,
None,
)
.await;
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
}))
.returns(json!({}))
.build_for(SonarrEvent::UpdateDownloads)
.await;
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
assert!(network
.handle_sonarr_event(SonarrEvent::UpdateDownloads)
.await
.is_ok());
assert!(
network
.handle_sonarr_event(SonarrEvent::UpdateDownloads)
.await
.is_ok()
);
async_server.assert_async().await;
mock.assert_async().await;
}
}
src/network/sonarr_network/history/mod.rs
+1 -1
View File
@@ -1,6 +1,6 @@
use crate::models::Route;
use crate::models::servarr_data::sonarr::sonarr_data::ActiveSonarrBlock;
use crate::models::sonarr_models::SonarrHistoryWrapper;
use crate::models::Route;
use crate::network::sonarr_network::SonarrEvent;
use crate::network::{Network, RequestMethod};
use anyhow::Result;
src/network/sonarr_network/history/sonarr_history_network_tests.rs
+45 -59
View File
@@ -3,15 +3,12 @@ mod tests {
use crate::models::servarr_data::sonarr::sonarr_data::ActiveSonarrBlock;
use crate::models::sonarr_models::{SonarrHistoryItem, SonarrHistoryWrapper, SonarrSerdeable};
use crate::models::stateful_table::SortOption;
use crate::network::network_tests::test_utils::mock_servarr_api;
use crate::network::sonarr_network::sonarr_network_test_utils::test_utils::history_item;
use crate::network::network_tests::test_utils::{MockServarrApi, test_network};
use crate::network::sonarr_network::SonarrEvent;
use crate::network::{Network, RequestMethod};
use crate::network::sonarr_network::sonarr_network_test_utils::test_utils::history_item;
use pretty_assertions::assert_eq;
use reqwest::Client;
use rstest::rstest;
use serde_json::json;
use tokio_util::sync::CancellationToken;
#[rstest]
#[tokio::test]
@@ -57,17 +54,12 @@ mod tests {
..history_item()
},
];
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(history_json),
None,
SonarrEvent::GetHistory(500),
None,
Some("pageSize=500&sortDirection=descending&sortKey=date"),
)
.await;
app_arc.lock().await.data.sonarr_data.history.sort_asc = true;
let (mock, app, _server) = MockServarrApi::get()
.returns(history_json)
.query("pageSize=500&sortDirection=descending&sortKey=date")
.build_for(SonarrEvent::GetHistory(500))
.await;
app.lock().await.data.sonarr_data.history.sort_asc = true;
if use_custom_sorting {
let cmp_fn = |a: &SonarrHistoryItem, b: &SonarrHistoryItem| {
a.source_title
@@ -81,7 +73,7 @@ mod tests {
name: "Source Title",
cmp_fn: Some(cmp_fn),
};
app_arc
app
.lock()
.await
.data
@@ -89,20 +81,20 @@ mod tests {
.history
.sorting(vec![history_sort_option]);
}
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
if let SonarrSerdeable::SonarrHistoryWrapper(history) = network
.handle_sonarr_event(SonarrEvent::GetHistory(500))
.await
.unwrap()
{
async_server.assert_async().await;
mock.assert_async().await;
assert_eq!(
app_arc.lock().await.data.sonarr_data.history.items,
app.lock().await.data.sonarr_data.history.items,
expected_history_items
);
assert!(app_arc.lock().await.data.sonarr_data.history.sort_asc);
assert!(app.lock().await.data.sonarr_data.history.sort_asc);
assert_eq!(history, response);
}
}
@@ -136,18 +128,13 @@ mod tests {
}
}]});
let response: SonarrHistoryWrapper = serde_json::from_value(history_json.clone()).unwrap();
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(history_json),
None,
SonarrEvent::GetHistory(500),
None,
Some("pageSize=500&sortDirection=descending&sortKey=date"),
)
.await;
app_arc.lock().await.data.sonarr_data.history.sort_asc = true;
app_arc
let (mock, app, _server) = MockServarrApi::get()
.returns(history_json)
.query("pageSize=500&sortDirection=descending&sortKey=date")
.build_for(SonarrEvent::GetHistory(500))
.await;
app.lock().await.data.sonarr_data.history.sort_asc = true;
app
.lock()
.await
.push_navigation_stack(ActiveSonarrBlock::HistorySortPrompt.into());
@@ -161,24 +148,24 @@ mod tests {
name: "Source Title",
cmp_fn: Some(cmp_fn),
};
app_arc
app
.lock()
.await
.data
.sonarr_data
.history
.sorting(vec![history_sort_option]);
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
if let SonarrSerdeable::SonarrHistoryWrapper(history) = network
.handle_sonarr_event(SonarrEvent::GetHistory(500))
.await
.unwrap()
{
async_server.assert_async().await;
assert!(app_arc.lock().await.data.sonarr_data.history.is_empty());
assert!(app_arc.lock().await.data.sonarr_data.history.sort_asc);
mock.assert_async().await;
assert!(app.lock().await.data.sonarr_data.history.is_empty());
assert!(app.lock().await.data.sonarr_data.history.sort_asc);
assert_eq!(history, response);
}
}
@@ -186,25 +173,24 @@ mod tests {
#[tokio::test]
async fn test_handle_mark_sonarr_history_item_as_failed_event() {
let expected_history_item_id = 1;
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Post,
None,
Some(json!({})),
None,
SonarrEvent::MarkHistoryItemAsFailed(expected_history_item_id),
Some("/1"),
None,
)
.await;
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
assert!(network
.handle_sonarr_event(SonarrEvent::MarkHistoryItemAsFailed(
expected_history_item_id
let (mock, app, _server) = MockServarrApi::post()
.returns(json!({}))
.path("/1")
.build_for(SonarrEvent::MarkHistoryItemAsFailed(
expected_history_item_id,
))
.await
.is_ok());
async_server.assert_async().await;
.await;
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
assert!(
network
.handle_sonarr_event(SonarrEvent::MarkHistoryItemAsFailed(
expected_history_item_id
))
.await
.is_ok()
);
mock.assert_async().await;
}
}
src/network/sonarr_network/indexers/mod.rs
+1 -1
View File
@@ -6,7 +6,7 @@ use crate::network::sonarr_network::SonarrEvent;
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 = "sonarr_indexers_network_tests.rs"]
src/network/sonarr_network/indexers/sonarr_indexers_network_tests.rs
+176 -223
View File
@@ -1,50 +1,44 @@
#[cfg(test)]
mod tests {
use crate::models::HorizontallyScrollableText;
use crate::models::servarr_data::modals::IndexerTestResultModalItem;
use crate::models::servarr_models::{EditIndexerParams, Indexer, IndexerTestResult};
use crate::models::sonarr_models::SonarrSerdeable;
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::sonarr_network::SonarrEvent;
use crate::network::sonarr_network::sonarr_network_test_utils::test_utils::{
indexer, indexer_settings,
};
use crate::network::sonarr_network::SonarrEvent;
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_sonarr_indexer_event() {
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Delete,
None,
None,
None,
SonarrEvent::DeleteIndexer(1),
Some("/1"),
None,
)
.await;
app_arc
let (mock, app, _server) = MockServarrApi::delete()
.path("/1")
.build_for(SonarrEvent::DeleteIndexer(1))
.await;
app
.lock()
.await
.data
.sonarr_data
.indexers
.set_items(vec![indexer()]);
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
assert!(network
.handle_sonarr_event(SonarrEvent::DeleteIndexer(1))
.await
.is_ok());
assert!(
network
.handle_sonarr_event(SonarrEvent::DeleteIndexer(1))
.await
.is_ok()
);
async_server.assert_async().await;
mock.assert_async().await;
}
#[tokio::test]
@@ -56,26 +50,22 @@ mod tests {
"retention": 1,
"rssSyncInterval": 60
});
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Put,
Some(indexer_settings_json),
None,
None,
SonarrEvent::EditAllIndexerSettings(indexer_settings()),
None,
None,
)
.await;
let (mock, app, _server) = MockServarrApi::put()
.with_request_body(indexer_settings_json)
.build_for(SonarrEvent::EditAllIndexerSettings(indexer_settings()))
.await;
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
assert!(network
.handle_sonarr_event(SonarrEvent::EditAllIndexerSettings(indexer_settings()))
.await
.is_ok());
assert!(
network
.handle_sonarr_event(SonarrEvent::EditAllIndexerSettings(indexer_settings()))
.await
.is_ok()
);
async_server.assert_async().await;
mock.assert_async().await;
}
#[tokio::test]
@@ -139,17 +129,12 @@ mod tests {
"tags": [1, 2],
"id": 1
});
let (async_details_server, app_arc, mut server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(indexer_details_json),
None,
SonarrEvent::GetIndexers,
Some("/1"),
None,
)
.await;
let async_edit_server = server
let (mock_details_server, app, mut server) = MockServarrApi::get()
.returns(indexer_details_json)
.path("/1")
.build_for(SonarrEvent::GetIndexers)
.await;
let mock_edit_server = server
.mock(
"PUT",
format!(
@@ -163,23 +148,25 @@ mod tests {
.match_body(Matcher::Json(expected_indexer_edit_body_json))
.create_async()
.await;
app_arc.lock().await.data.sonarr_data.tags_map =
app.lock().await.data.sonarr_data.tags_map =
BiMap::from_iter([(1, "usenet".to_owned()), (2, "testing".to_owned())]);
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
assert!(network
.handle_sonarr_event(SonarrEvent::EditIndexer(expected_edit_indexer_params))
.await
.is_ok());
assert!(
network
.handle_sonarr_event(SonarrEvent::EditIndexer(expected_edit_indexer_params))
.await
.is_ok()
);
async_details_server.assert_async().await;
async_edit_server.assert_async().await;
mock_details_server.assert_async().await;
mock_edit_server.assert_async().await;
}
#[tokio::test]
async fn test_handle_edit_sonarr_indexer_event_does_not_overwrite_tags_vec_if_tag_input_string_is_none(
) {
async fn test_handle_edit_sonarr_indexer_event_does_not_overwrite_tags_vec_if_tag_input_string_is_none()
{
let expected_edit_indexer_params = EditIndexerParams {
indexer_id: 1,
name: Some("Test Update".to_owned()),
@@ -239,17 +226,12 @@ mod tests {
"tags": [1, 2],
"id": 1
});
let (async_details_server, app_arc, mut server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(indexer_details_json),
None,
SonarrEvent::GetIndexers,
Some("/1"),
None,
)
.await;
let async_edit_server = server
let (mock_details_server, app, mut server) = MockServarrApi::get()
.returns(indexer_details_json)
.path("/1")
.build_for(SonarrEvent::GetIndexers)
.await;
let mock_edit_server = server
.mock(
"PUT",
format!(
@@ -263,21 +245,23 @@ mod tests {
.match_body(Matcher::Json(expected_indexer_edit_body_json))
.create_async()
.await;
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
assert!(network
.handle_sonarr_event(SonarrEvent::EditIndexer(expected_edit_indexer_params))
.await
.is_ok());
assert!(
network
.handle_sonarr_event(SonarrEvent::EditIndexer(expected_edit_indexer_params))
.await
.is_ok()
);
async_details_server.assert_async().await;
async_edit_server.assert_async().await;
mock_details_server.assert_async().await;
mock_edit_server.assert_async().await;
}
#[tokio::test]
async fn test_handle_edit_sonarr_indexer_event_does_not_add_seed_ratio_when_seed_ratio_field_is_none_in_details(
) {
async fn test_handle_edit_sonarr_indexer_event_does_not_add_seed_ratio_when_seed_ratio_field_is_none_in_details()
{
let expected_edit_indexer_params = EditIndexerParams {
indexer_id: 1,
name: Some("Test Update".to_owned()),
@@ -330,17 +314,12 @@ mod tests {
"id": 1
});
let (async_details_server, app_arc, mut server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(indexer_details_json),
None,
SonarrEvent::GetIndexers,
Some("/1"),
None,
)
.await;
let async_edit_server = server
let (mock_details_server, app, mut server) = MockServarrApi::get()
.returns(indexer_details_json)
.path("/1")
.build_for(SonarrEvent::GetIndexers)
.await;
let mock_edit_server = server
.mock(
"PUT",
format!(
@@ -354,23 +333,25 @@ mod tests {
.match_body(Matcher::Json(expected_indexer_edit_body_json))
.create_async()
.await;
app_arc.lock().await.data.sonarr_data.tags_map =
app.lock().await.data.sonarr_data.tags_map =
BiMap::from_iter([(1, "usenet".to_owned()), (2, "testing".to_owned())]);
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
assert!(network
.handle_sonarr_event(SonarrEvent::EditIndexer(expected_edit_indexer_params))
.await
.is_ok());
assert!(
network
.handle_sonarr_event(SonarrEvent::EditIndexer(expected_edit_indexer_params))
.await
.is_ok()
);
async_details_server.assert_async().await;
async_edit_server.assert_async().await;
mock_details_server.assert_async().await;
mock_edit_server.assert_async().await;
}
#[tokio::test]
async fn test_handle_edit_sonarr_indexer_event_populates_the_seed_ratio_value_when_seed_ratio_field_is_present_in_details(
) {
async fn test_handle_edit_sonarr_indexer_event_populates_the_seed_ratio_value_when_seed_ratio_field_is_present_in_details()
{
let expected_edit_indexer_params = EditIndexerParams {
indexer_id: 1,
name: Some("Test Update".to_owned()),
@@ -430,17 +411,12 @@ mod tests {
"id": 1
});
let (async_details_server, app_arc, mut server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(indexer_details_json),
None,
SonarrEvent::GetIndexers,
Some("/1"),
None,
)
.await;
let async_edit_server = server
let (mock_details_server, app, mut server) = MockServarrApi::get()
.returns(indexer_details_json)
.path("/1")
.build_for(SonarrEvent::GetIndexers)
.await;
let mock_edit_server = server
.mock(
"PUT",
format!(
@@ -454,18 +430,20 @@ mod tests {
.match_body(Matcher::Json(expected_indexer_edit_body_json))
.create_async()
.await;
app_arc.lock().await.data.sonarr_data.tags_map =
app.lock().await.data.sonarr_data.tags_map =
BiMap::from_iter([(1, "usenet".to_owned()), (2, "testing".to_owned())]);
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
assert!(network
.handle_sonarr_event(SonarrEvent::EditIndexer(expected_edit_indexer_params))
.await
.is_ok());
assert!(
network
.handle_sonarr_event(SonarrEvent::EditIndexer(expected_edit_indexer_params))
.await
.is_ok()
);
async_details_server.assert_async().await;
async_edit_server.assert_async().await;
mock_details_server.assert_async().await;
mock_edit_server.assert_async().await;
}
#[tokio::test]
@@ -497,17 +475,12 @@ mod tests {
indexer_id: 1,
..EditIndexerParams::default()
};
let (async_details_server, app_arc, mut server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(indexer_details_json.clone()),
None,
SonarrEvent::GetIndexers,
Some("/1"),
None,
)
.await;
let async_edit_server = server
let (mock_details_server, app, mut server) = MockServarrApi::get()
.returns(indexer_details_json.clone())
.path("/1")
.build_for(SonarrEvent::GetIndexers)
.await;
let mock_edit_server = server
.mock(
"PUT",
format!(
@@ -521,16 +494,18 @@ mod tests {
.match_body(Matcher::Json(indexer_details_json))
.create_async()
.await;
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
assert!(network
.handle_sonarr_event(SonarrEvent::EditIndexer(edit_indexer_params))
.await
.is_ok());
assert!(
network
.handle_sonarr_event(SonarrEvent::EditIndexer(edit_indexer_params))
.await
.is_ok()
);
async_details_server.assert_async().await;
async_edit_server.assert_async().await;
mock_details_server.assert_async().await;
mock_edit_server.assert_async().await;
}
#[tokio::test]
@@ -587,16 +562,11 @@ mod tests {
..EditIndexerParams::default()
};
let (async_details_server, app_arc, mut server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(indexer_details_json),
None,
SonarrEvent::GetIndexers,
Some("/1"),
None,
)
.await;
let (async_details_server, app, mut server) = MockServarrApi::get()
.returns(indexer_details_json)
.path("/1")
.build_for(SonarrEvent::GetIndexers)
.await;
let async_edit_server = server
.mock(
"PUT",
@@ -611,13 +581,15 @@ mod tests {
.match_body(Matcher::Json(expected_edit_indexer_body))
.create_async()
.await;
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
assert!(network
.handle_sonarr_event(SonarrEvent::EditIndexer(edit_indexer_params))
.await
.is_ok());
assert!(
network
.handle_sonarr_event(SonarrEvent::EditIndexer(edit_indexer_params))
.await
.is_ok()
);
async_details_server.assert_async().await;
async_edit_server.assert_async().await;
@@ -656,18 +628,12 @@ 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,
SonarrEvent::GetIndexers,
None,
None,
)
.await;
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let (async_server, app, _server) = MockServarrApi::get()
.returns(indexers_response_json)
.build_for(SonarrEvent::GetIndexers)
.await;
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
if let SonarrSerdeable::Indexers(indexers) = network
.handle_sonarr_event(SonarrEvent::GetIndexers)
@@ -676,7 +642,7 @@ mod tests {
{
async_server.assert_async().await;
assert_eq!(
app_arc.lock().await.data.sonarr_data.indexers.items,
app.lock().await.data.sonarr_data.indexers.items,
vec![indexer()]
);
assert_eq!(indexers, response);
@@ -714,16 +680,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,
SonarrEvent::GetIndexers,
Some("/1"),
None,
)
.await;
let (async_details_server, app, mut server) = MockServarrApi::get()
.returns(indexer_details_json.clone())
.path("/1")
.build_for(SonarrEvent::GetIndexers)
.await;
let async_test_server = server
.mock(
"POST",
@@ -735,15 +696,15 @@ mod tests {
.with_body(response_json.to_string())
.create_async()
.await;
app_arc
app
.lock()
.await
.data
.sonarr_data
.indexers
.set_items(vec![indexer()]);
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
if let SonarrSerdeable::Value(value) = network
.handle_sonarr_event(SonarrEvent::TestIndexer(1))
@@ -753,7 +714,7 @@ mod tests {
async_details_server.assert_async().await;
async_test_server.assert_async().await;
assert_eq!(
app_arc.lock().await.data.sonarr_data.indexer_test_errors,
app.lock().await.data.sonarr_data.indexer_test_errors,
Some("\"test failure\"".to_owned())
);
assert_eq!(value, response_json)
@@ -784,16 +745,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,
SonarrEvent::GetIndexers,
Some("/1"),
None,
)
.await;
let (async_details_server, app, mut server) = MockServarrApi::get()
.returns(indexer_details_json.clone())
.path("/1")
.build_for(SonarrEvent::GetIndexers)
.await;
let async_test_server = server
.mock(
"POST",
@@ -805,15 +761,15 @@ mod tests {
.with_body("{}")
.create_async()
.await;
app_arc
app
.lock()
.await
.data
.sonarr_data
.indexers
.set_items(vec![indexer()]);
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
if let SonarrSerdeable::Value(value) = network
.handle_sonarr_event(SonarrEvent::TestIndexer(1))
@@ -823,7 +779,7 @@ mod tests {
async_details_server.assert_async().await;
async_test_server.assert_async().await;
assert_eq!(
app_arc.lock().await.data.sonarr_data.indexer_test_errors,
app.lock().await.data.sonarr_data.indexer_test_errors,
Some(String::new())
);
assert_eq!(value, json!({}));
@@ -879,25 +835,20 @@ 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),
SonarrEvent::TestAllIndexers,
None,
None,
)
.await;
app_arc
let (async_server, app, _server) = MockServarrApi::post()
.returns(response_json)
.status(400)
.build_for(SonarrEvent::TestAllIndexers)
.await;
app
.lock()
.await
.data
.sonarr_data
.indexers
.set_items(indexers);
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
if let SonarrSerdeable::IndexerTestResults(results) = network
.handle_sonarr_event(SonarrEvent::TestAllIndexers)
@@ -905,15 +856,17 @@ mod tests {
.unwrap()
{
async_server.assert_async().await;
assert!(app_arc
.lock()
.await
.data
.sonarr_data
.indexer_test_all_results
.is_some());
assert!(
app
.lock()
.await
.data
.sonarr_data
.indexer_test_all_results
.is_some()
);
assert_eq!(
app_arc
app
.lock()
.await
.data
src/network/sonarr_network/library/episodes/sonarr_episodes_network_tests.rs
+258 -332
View File
@@ -7,43 +7,37 @@ mod tests {
SonarrHistoryWrapper, SonarrSerdeable,
};
use crate::models::stateful_table::SortOption;
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::sonarr_network::SonarrEvent;
use crate::network::sonarr_network::library::episodes::get_episode_status;
use crate::network::sonarr_network::sonarr_network_test_utils::test_utils::{
episode, episode_file, history_item, release, EPISODE_JSON,
EPISODE_JSON, episode, episode_file, history_item, release,
};
use crate::network::sonarr_network::SonarrEvent;
use crate::network::{Network, NetworkResource, RequestMethod};
use indoc::formatdoc;
use mockito::Matcher;
use pretty_assertions::{assert_eq, assert_str_eq};
use reqwest::Client;
use rstest::rstest;
use serde_json::{json, Number};
use serde_json::{Number, json};
use std::slice;
use tokio_util::sync::CancellationToken;
#[tokio::test]
async fn test_handle_delete_sonarr_episode_file_event() {
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Delete,
None,
None,
None,
SonarrEvent::DeleteEpisodeFile(1),
Some("/1"),
None,
)
.await;
let (async_server, app_arc, _server) = MockServarrApi::delete()
.path("/1")
.build_for(SonarrEvent::DeleteEpisodeFile(1))
.await;
app_arc.lock().await.data.sonarr_data.season_details_modal =
Some(SeasonDetailsModal::default());
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let mut network = test_network(&app_arc);
assert!(network
.handle_sonarr_event(SonarrEvent::DeleteEpisodeFile(1))
.await
.is_ok());
assert!(
network
.handle_sonarr_event(SonarrEvent::DeleteEpisodeFile(1))
.await
.is_ok()
);
async_server.assert_async().await;
}
@@ -76,16 +70,11 @@ mod tests {
};
let expected_episodes = vec![episode_1.clone(), episode_2.clone(), episode_3.clone()];
let mut expected_sorted_episodes = vec![episode_1.clone(), episode_3.clone()];
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(json!([episode_1, episode_2, episode_3])),
None,
SonarrEvent::GetEpisodes(1),
None,
Some("seriesId=1"),
)
.await;
let (mock, app, _server) = MockServarrApi::get()
.query("seriesId=1")
.returns(json!([episode_1, episode_2, episode_3]))
.build_for(SonarrEvent::GetEpisodes(1))
.await;
let mut season_details_modal = SeasonDetailsModal::default();
season_details_modal.episodes.sort_asc = true;
if use_custom_sorting {
@@ -99,8 +88,8 @@ mod tests {
.episodes
.sorting(vec![title_sort_option]);
}
app_arc.lock().await.data.sonarr_data.season_details_modal = Some(season_details_modal);
app_arc
app.lock().await.data.sonarr_data.season_details_modal = Some(season_details_modal);
app
.lock()
.await
.data
@@ -110,7 +99,7 @@ mod tests {
id: 1,
..Series::default()
}]);
app_arc
app
.lock()
.await
.data
@@ -120,42 +109,44 @@ mod tests {
season_number: 1,
..Season::default()
}]);
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
if let SonarrSerdeable::Episodes(episodes) = network
let result = network
.handle_sonarr_event(SonarrEvent::GetEpisodes(1))
.await
.unwrap()
{
async_server.assert_async().await;
assert_eq!(
app_arc
.lock()
.await
.data
.sonarr_data
.season_details_modal
.as_ref()
.unwrap()
.episodes
.items,
expected_sorted_episodes
);
assert!(
app_arc
.lock()
.await
.data
.sonarr_data
.season_details_modal
.as_ref()
.unwrap()
.episodes
.sort_asc
);
assert_eq!(episodes, expected_episodes);
}
.await;
mock.assert_async().await;
let SonarrSerdeable::Episodes(episodes) = result.unwrap() else {
panic!("Expected Episodes variant")
};
assert_eq!(
app
.lock()
.await
.data
.sonarr_data
.season_details_modal
.as_ref()
.unwrap()
.episodes
.items,
expected_sorted_episodes
);
assert!(
app
.lock()
.await
.data
.sonarr_data
.season_details_modal
.as_ref()
.unwrap()
.episodes
.sort_asc
);
assert_eq!(episodes, expected_episodes);
}
#[tokio::test]
@@ -184,20 +175,15 @@ mod tests {
..episode()
};
let expected_episodes = vec![episode_1.clone(), episode_2.clone(), episode_3.clone()];
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(json!([episode_1, episode_2, episode_3])),
None,
SonarrEvent::GetEpisodes(1),
None,
Some("seriesId=1"),
)
.await;
let (mock, app, _server) = MockServarrApi::get()
.query("seriesId=1")
.returns(json!([episode_1, episode_2, episode_3]))
.build_for(SonarrEvent::GetEpisodes(1))
.await;
let mut season_details_modal = SeasonDetailsModal::default();
season_details_modal.episodes.sort_asc = true;
app_arc.lock().await.data.sonarr_data.season_details_modal = Some(season_details_modal);
app_arc
app.lock().await.data.sonarr_data.season_details_modal = Some(season_details_modal);
app
.lock()
.await
.data
@@ -207,56 +193,53 @@ mod tests {
id: 1,
..Series::default()
}]);
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
if let SonarrSerdeable::Episodes(episodes) = network
let result = network
.handle_sonarr_event(SonarrEvent::GetEpisodes(1))
.await
.unwrap()
{
async_server.assert_async().await;
assert_eq!(
app_arc
.lock()
.await
.data
.sonarr_data
.season_details_modal
.as_ref()
.unwrap()
.episodes
.items,
expected_episodes
);
assert!(
app_arc
.lock()
.await
.data
.sonarr_data
.season_details_modal
.as_ref()
.unwrap()
.episodes
.sort_asc
);
assert_eq!(episodes, expected_episodes);
}
.await;
mock.assert_async().await;
let SonarrSerdeable::Episodes(episodes) = result.unwrap() else {
panic!("Expected Episodes variant")
};
assert_eq!(
app
.lock()
.await
.data
.sonarr_data
.season_details_modal
.as_ref()
.unwrap()
.episodes
.items,
expected_episodes
);
assert!(
app
.lock()
.await
.data
.sonarr_data
.season_details_modal
.as_ref()
.unwrap()
.episodes
.sort_asc
);
assert_eq!(episodes, expected_episodes);
}
#[tokio::test]
async fn test_handle_get_episodes_event_empty_season_details_modal() {
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(json!([episode()])),
None,
SonarrEvent::GetEpisodes(1),
None,
Some("seriesId=1"),
)
.await;
let (async_server, app_arc, _server) = MockServarrApi::get()
.returns(json!([episode()]))
.query("seriesId=1")
.build_for(SonarrEvent::GetEpisodes(1))
.await;
app_arc
.lock()
.await
@@ -268,7 +251,7 @@ mod tests {
..Series::default()
}]);
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let mut network = test_network(&app_arc);
if let SonarrSerdeable::Episodes(episodes) = network
.handle_sonarr_event(SonarrEvent::GetEpisodes(1))
@@ -336,16 +319,11 @@ mod tests {
..episode()
};
let mut expected_episodes = vec![episode_2.clone(), episode_1.clone()];
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(episodes_json),
None,
SonarrEvent::GetEpisodes(1),
None,
Some("seriesId=1"),
)
.await;
let (async_server, app_arc, _server) = MockServarrApi::get()
.returns(episodes_json)
.query("seriesId=1")
.build_for(SonarrEvent::GetEpisodes(1))
.await;
app_arc
.lock()
.await
@@ -373,7 +351,7 @@ mod tests {
}]);
app_arc.lock().await.data.sonarr_data.season_details_modal = Some(season_details_modal);
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let mut network = test_network(&app_arc);
if let SonarrSerdeable::Episodes(episodes) = network
.handle_sonarr_event(SonarrEvent::GetEpisodes(1))
@@ -381,16 +359,18 @@ mod tests {
.unwrap()
{
async_server.assert_async().await;
assert!(app_arc
.lock()
.await
.data
.sonarr_data
.season_details_modal
.as_ref()
.unwrap()
.episodes
.is_empty());
assert!(
app_arc
.lock()
.await
.data
.sonarr_data
.season_details_modal
.as_ref()
.unwrap()
.episodes
.is_empty()
);
assert!(
app_arc
.lock()
@@ -409,16 +389,11 @@ mod tests {
#[tokio::test]
async fn test_handle_get_episode_files_event() {
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(json!([episode_file()])),
None,
SonarrEvent::GetEpisodeFiles(1),
None,
Some("seriesId=1"),
)
.await;
let (async_server, app_arc, _server) = MockServarrApi::get()
.returns(json!([episode_file()]))
.query("seriesId=1")
.build_for(SonarrEvent::GetEpisodeFiles(1))
.await;
app_arc.lock().await.data.sonarr_data.season_details_modal =
Some(SeasonDetailsModal::default());
app_arc
@@ -432,7 +407,7 @@ mod tests {
..Series::default()
}]);
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let mut network = test_network(&app_arc);
if let SonarrSerdeable::EpisodeFiles(episode_files) = network
.handle_sonarr_event(SonarrEvent::GetEpisodeFiles(1))
@@ -459,16 +434,11 @@ mod tests {
#[tokio::test]
async fn test_handle_get_episode_files_event_empty_season_details_modal() {
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(json!([episode_file()])),
None,
SonarrEvent::GetEpisodeFiles(1),
None,
Some("seriesId=1"),
)
.await;
let (async_server, app_arc, _server) = MockServarrApi::get()
.returns(json!([episode_file()]))
.query("seriesId=1")
.build_for(SonarrEvent::GetEpisodeFiles(1))
.await;
app_arc
.lock()
.await
@@ -480,7 +450,7 @@ mod tests {
..Series::default()
}]);
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let mut network = test_network(&app_arc);
if let SonarrSerdeable::EpisodeFiles(episode_files) = network
.handle_sonarr_event(SonarrEvent::GetEpisodeFiles(1))
@@ -488,13 +458,15 @@ mod tests {
.unwrap()
{
async_server.assert_async().await;
assert!(app_arc
.lock()
.await
.data
.sonarr_data
.season_details_modal
.is_some());
assert!(
app_arc
.lock()
.await
.data
.sonarr_data
.season_details_modal
.is_some()
);
assert_eq!(
app_arc
.lock()
@@ -555,16 +527,11 @@ mod tests {
..history_item()
},
];
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(history_json),
None,
SonarrEvent::GetEpisodeHistory(1),
None,
Some("episodeId=1&pageSize=1000&sortDirection=descending&sortKey=date"),
)
.await;
let (async_server, app_arc, _server) = MockServarrApi::get()
.returns(history_json)
.query("episodeId=1&pageSize=1000&sortDirection=descending&sortKey=date")
.build_for(SonarrEvent::GetEpisodeHistory(1))
.await;
app_arc.lock().await.data.sonarr_data.season_details_modal =
Some(SeasonDetailsModal::default());
app_arc
@@ -600,7 +567,7 @@ mod tests {
.episode_history
.sort_asc = true;
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let mut network = test_network(&app_arc);
if let SonarrSerdeable::SonarrHistoryWrapper(history) = network
.handle_sonarr_event(SonarrEvent::GetEpisodeHistory(1))
@@ -686,16 +653,11 @@ mod tests {
..history_item()
},
];
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(history_json),
None,
SonarrEvent::GetEpisodeHistory(1),
None,
Some("episodeId=1&pageSize=1000&sortDirection=descending&sortKey=date"),
)
.await;
let (async_server, app_arc, _server) = MockServarrApi::get()
.returns(history_json)
.query("episodeId=1&pageSize=1000&sortDirection=descending&sortKey=date")
.build_for(SonarrEvent::GetEpisodeHistory(1))
.await;
app_arc.lock().await.data.sonarr_data.season_details_modal =
Some(SeasonDetailsModal::default());
app_arc
@@ -709,7 +671,7 @@ mod tests {
.episodes
.set_items(vec![episode()]);
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let mut network = test_network(&app_arc);
if let SonarrSerdeable::SonarrHistoryWrapper(history) = network
.handle_sonarr_event(SonarrEvent::GetEpisodeHistory(1))
@@ -795,18 +757,13 @@ mod tests {
..history_item()
},
];
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(history_json),
None,
SonarrEvent::GetEpisodeHistory(1),
None,
Some("episodeId=1&pageSize=1000&sortDirection=descending&sortKey=date"),
)
.await;
let (async_server, app_arc, _server) = MockServarrApi::get()
.returns(history_json)
.query("episodeId=1&pageSize=1000&sortDirection=descending&sortKey=date")
.build_for(SonarrEvent::GetEpisodeHistory(1))
.await;
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let mut network = test_network(&app_arc);
if let SonarrSerdeable::SonarrHistoryWrapper(history) = network
.handle_sonarr_event(SonarrEvent::GetEpisodeHistory(1))
@@ -852,16 +809,11 @@ mod tests {
#[tokio::test]
async fn test_handle_get_episode_details_event() {
let response: Episode = serde_json::from_str(EPISODE_JSON).unwrap();
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(serde_json::from_str(EPISODE_JSON).unwrap()),
None,
SonarrEvent::GetEpisodeDetails(1),
Some("/1"),
None,
)
.await;
let (async_server, app_arc, _server) = MockServarrApi::get()
.returns(serde_json::from_str(EPISODE_JSON).unwrap())
.path("/1")
.build_for(SonarrEvent::GetEpisodeDetails(1))
.await;
let mut episode_details_modal = EpisodeDetailsModal::default();
episode_details_modal.episode_details_tabs.next();
let mut season_details_modal = SeasonDetailsModal::default();
@@ -873,7 +825,7 @@ mod tests {
.await
.push_navigation_stack(ActiveSonarrBlock::EpisodeDetails.into());
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let mut network = test_network(&app_arc);
if let SonarrSerdeable::Episode(episode) = network
.handle_sonarr_event(SonarrEvent::GetEpisodeDetails(1))
@@ -881,16 +833,18 @@ mod tests {
.unwrap()
{
async_server.assert_async().await;
assert!(app_arc
.lock()
.await
.data
.sonarr_data
.season_details_modal
.as_ref()
.unwrap()
.episode_details_modal
.is_some());
assert!(
app_arc
.lock()
.await
.data
.sonarr_data
.season_details_modal
.as_ref()
.unwrap()
.episode_details_modal
.is_some()
);
assert_eq!(
app_arc
.lock()
@@ -969,16 +923,11 @@ mod tests {
#[tokio::test]
async fn test_handle_get_episode_details_event_empty_episode_details_modal() {
let response: Episode = serde_json::from_str(EPISODE_JSON).unwrap();
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(serde_json::from_str(EPISODE_JSON).unwrap()),
None,
SonarrEvent::GetEpisodeDetails(1),
Some("/1"),
None,
)
.await;
let (async_server, app_arc, _server) = MockServarrApi::get()
.returns(serde_json::from_str(EPISODE_JSON).unwrap())
.path("/1")
.build_for(SonarrEvent::GetEpisodeDetails(1))
.await;
let mut season_details_modal = SeasonDetailsModal::default();
season_details_modal.episodes.set_items(vec![episode()]);
app_arc.lock().await.data.sonarr_data.season_details_modal = Some(season_details_modal);
@@ -987,7 +936,7 @@ mod tests {
.await
.push_navigation_stack(ActiveSonarrBlock::EpisodeDetails.into());
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let mut network = test_network(&app_arc);
if let SonarrSerdeable::Episode(episode) = network
.handle_sonarr_event(SonarrEvent::GetEpisodeDetails(1))
@@ -995,16 +944,18 @@ mod tests {
.unwrap()
{
async_server.assert_async().await;
assert!(app_arc
.lock()
.await
.data
.sonarr_data
.season_details_modal
.as_ref()
.unwrap()
.episode_details_modal
.is_some());
assert!(
app_arc
.lock()
.await
.data
.sonarr_data
.season_details_modal
.as_ref()
.unwrap()
.episode_details_modal
.is_some()
);
assert_eq!(episode, response);
let app = app_arc.lock().await;
@@ -1067,19 +1018,14 @@ mod tests {
#[tokio::test]
async fn test_handle_get_episode_details_event_season_details_modal_not_required_in_cli_mode() {
let response: Episode = serde_json::from_str(EPISODE_JSON).unwrap();
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(serde_json::from_str(EPISODE_JSON).unwrap()),
None,
SonarrEvent::GetEpisodeDetails(1),
Some("/1"),
None,
)
.await;
let (async_server, app_arc, _server) = MockServarrApi::get()
.returns(serde_json::from_str(EPISODE_JSON).unwrap())
.path("/1")
.build_for(SonarrEvent::GetEpisodeDetails(1))
.await;
app_arc.lock().await.cli_mode = true;
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let mut network = test_network(&app_arc);
if let SonarrSerdeable::Episode(episode) = network
.handle_sonarr_event(SonarrEvent::GetEpisodeDetails(1))
@@ -1093,20 +1039,15 @@ mod tests {
#[tokio::test]
#[should_panic(expected = "Season details modal is empty")]
async fn test_handle_get_episode_details_event_requires_season_details_modal_to_be_some_when_in_tui_mode(
) {
let (_async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(serde_json::from_str(EPISODE_JSON).unwrap()),
None,
SonarrEvent::GetEpisodeDetails(1),
Some("/1"),
None,
)
.await;
async fn test_handle_get_episode_details_event_requires_season_details_modal_to_be_some_when_in_tui_mode()
{
let (_async_server, app_arc, _server) = MockServarrApi::get()
.returns(serde_json::from_str(EPISODE_JSON).unwrap())
.path("/1")
.build_for(SonarrEvent::GetEpisodeDetails(1))
.await;
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let mut network = test_network(&app_arc);
network
.handle_sonarr_event(SonarrEvent::GetEpisodeDetails(1))
@@ -1131,16 +1072,11 @@ mod tests {
"languages": [ { "id": 1, "name": "English" } ],
"quality": { "quality": { "name": "Bluray-1080p" }}
}]);
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(release_json),
None,
SonarrEvent::GetEpisodeReleases(1),
None,
Some("episodeId=1"),
)
.await;
let (async_server, app_arc, _server) = MockServarrApi::get()
.returns(release_json)
.query("episodeId=1")
.build_for(SonarrEvent::GetEpisodeReleases(1))
.await;
let mut season_details_modal = SeasonDetailsModal::default();
season_details_modal.episodes.set_items(vec![episode()]);
app_arc.lock().await.data.sonarr_data.season_details_modal = Some(season_details_modal);
@@ -1154,7 +1090,7 @@ mod tests {
.unwrap()
.episode_details_modal = Some(EpisodeDetailsModal::default());
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let mut network = test_network(&app_arc);
if let SonarrSerdeable::Releases(releases_vec) = network
.handle_sonarr_event(SonarrEvent::GetEpisodeReleases(1))
@@ -1199,21 +1135,16 @@ mod tests {
"languages": [ { "id": 1, "name": "English" } ],
"quality": { "quality": { "name": "Bluray-1080p" }}
}]);
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(release_json),
None,
SonarrEvent::GetEpisodeReleases(1),
None,
Some("episodeId=1"),
)
.await;
let (async_server, app_arc, _server) = MockServarrApi::get()
.returns(release_json)
.query("episodeId=1")
.build_for(SonarrEvent::GetEpisodeReleases(1))
.await;
let mut season_details_modal = SeasonDetailsModal::default();
season_details_modal.episodes.set_items(vec![episode()]);
app_arc.lock().await.data.sonarr_data.season_details_modal = Some(season_details_modal);
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let mut network = test_network(&app_arc);
if let SonarrSerdeable::Releases(releases_vec) = network
.handle_sonarr_event(SonarrEvent::GetEpisodeReleases(1))
@@ -1249,16 +1180,11 @@ mod tests {
};
let body = Episode { id: 2, ..episode() };
let (async_details_server, app_arc, mut server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(json!(body)),
None,
SonarrEvent::GetEpisodeDetails(2),
Some("/2"),
None,
)
.await;
let (async_details_server, app_arc, mut server) = MockServarrApi::get()
.returns(json!(body))
.path("/2")
.build_for(SonarrEvent::GetEpisodeDetails(2))
.await;
let async_toggle_server = server
.mock(
"PUT",
@@ -1274,12 +1200,14 @@ mod tests {
.create_async()
.await;
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let mut network = test_network(&app_arc);
assert!(network
.handle_sonarr_event(SonarrEvent::ToggleEpisodeMonitoring(2))
.await
.is_ok());
assert!(
network
.handle_sonarr_event(SonarrEvent::ToggleEpisodeMonitoring(2))
.await
.is_ok()
);
async_details_server.assert_async().await;
async_toggle_server.assert_async().await;
@@ -1287,28 +1215,26 @@ mod tests {
#[tokio::test]
async fn test_handle_trigger_automatic_episode_search_event() {
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Post,
Some(json!({
"name": "EpisodeSearch",
"episodeIds": [ 1 ]
})),
Some(json!({})),
None,
SonarrEvent::TriggerAutomaticEpisodeSearch(1),
None,
None,
)
.await;
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let body = json!({
"name": "EpisodeSearch",
"episodeIds": [ 1 ]
});
let (mock, app, _server) = MockServarrApi::post()
.with_request_body(body)
.returns(json!({}))
.build_for(SonarrEvent::TriggerAutomaticEpisodeSearch(1))
.await;
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
assert!(network
.handle_sonarr_event(SonarrEvent::TriggerAutomaticEpisodeSearch(1))
.await
.is_ok());
assert!(
network
.handle_sonarr_event(SonarrEvent::TriggerAutomaticEpisodeSearch(1))
.await
.is_ok()
);
async_server.assert_async().await;
mock.assert_async().await;
}
#[test]
src/network/sonarr_network/library/seasons/mod.rs
+1 -1
View File
@@ -4,7 +4,7 @@ use crate::network::sonarr_network::SonarrEvent;
use crate::network::{Network, RequestMethod};
use anyhow::Result;
use log::{debug, info, warn};
use serde_json::{json, Value};
use serde_json::{Value, json};
#[cfg(test)]
#[path = "sonarr_seasons_network_tests.rs"]
src/network/sonarr_network/library/seasons/sonarr_seasons_network_tests.rs
+101 -127
View File
@@ -2,17 +2,15 @@
mod tests {
use crate::models::servarr_data::sonarr::modals::SeasonDetailsModal;
use crate::models::sonarr_models::{SonarrHistoryItem, SonarrRelease, SonarrSerdeable};
use crate::network::network_tests::test_utils::mock_servarr_api;
use crate::network::sonarr_network::sonarr_network_test_utils::test_utils::{
history_item, release, season, series, SERIES_JSON,
};
use crate::network::NetworkResource;
use crate::network::network_tests::test_utils::{MockServarrApi, test_network};
use crate::network::sonarr_network::SonarrEvent;
use crate::network::{Network, NetworkResource, RequestMethod};
use crate::network::sonarr_network::sonarr_network_test_utils::test_utils::{
SERIES_JSON, history_item, release, season, series,
};
use mockito::Matcher;
use pretty_assertions::assert_eq;
use reqwest::Client;
use serde_json::{json, Value};
use tokio_util::sync::CancellationToken;
use serde_json::{Value, json};
#[tokio::test]
async fn test_handle_toggle_season_monitoring_event() {
@@ -28,16 +26,11 @@ mod tests {
.get_mut("monitored")
.unwrap() = json!(false);
let (async_details_server, app_arc, mut server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(serde_json::from_str(SERIES_JSON).unwrap()),
None,
SonarrEvent::GetSeriesDetails(1),
Some("/1"),
None,
)
.await;
let (async_details_server, app, mut server) = MockServarrApi::get()
.returns(serde_json::from_str(SERIES_JSON).unwrap())
.path("/1")
.build_for(SonarrEvent::GetSeriesDetails(1))
.await;
let async_toggle_server = server
.mock(
"PUT",
@@ -53,17 +46,19 @@ mod tests {
.create_async()
.await;
{
let mut app = app_arc.lock().await;
app.data.sonarr_data.series.set_items(vec![series()]);
app.data.sonarr_data.seasons.set_items(vec![season()]);
let mut app_lock = app.lock().await;
app_lock.data.sonarr_data.series.set_items(vec![series()]);
app_lock.data.sonarr_data.seasons.set_items(vec![season()]);
}
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
assert!(network
.handle_sonarr_event(SonarrEvent::ToggleSeasonMonitoring((1, 1)))
.await
.is_ok());
assert!(
network
.handle_sonarr_event(SonarrEvent::ToggleSeasonMonitoring((1, 1)))
.await
.is_ok()
);
async_details_server.assert_async().await;
async_toggle_server.assert_async().await;
@@ -118,43 +113,37 @@ mod tests {
..release()
},
];
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(release_json),
None,
SonarrEvent::GetSeasonReleases((1, 1)),
None,
Some("seriesId=1&seasonNumber=1"),
)
.await;
app_arc
let (mock, app, _server) = MockServarrApi::get()
.returns(release_json)
.query("seriesId=1&seasonNumber=1")
.build_for(SonarrEvent::GetSeasonReleases((1, 1)))
.await;
app
.lock()
.await
.data
.sonarr_data
.series
.set_items(vec![series()]);
app_arc
app
.lock()
.await
.data
.sonarr_data
.seasons
.set_items(vec![season()]);
app_arc.lock().await.data.sonarr_data.season_details_modal =
Some(SeasonDetailsModal::default());
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
app.lock().await.data.sonarr_data.season_details_modal = Some(SeasonDetailsModal::default());
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
if let SonarrSerdeable::Releases(releases_vec) = network
.handle_sonarr_event(SonarrEvent::GetSeasonReleases((1, 1)))
.await
.unwrap()
{
async_server.assert_async().await;
mock.assert_async().await;
assert_eq!(
app_arc
app
.lock()
.await
.data
@@ -209,41 +198,38 @@ mod tests {
full_season: true,
..release()
};
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(release_json),
None,
SonarrEvent::GetSeasonReleases((1, 1)),
None,
Some("seriesId=1&seasonNumber=1"),
)
.await;
app_arc
let (mock, app, _server) = MockServarrApi::get()
.returns(release_json)
.query("seriesId=1&seasonNumber=1")
.build_for(SonarrEvent::GetSeasonReleases((1, 1)))
.await;
app
.lock()
.await
.data
.sonarr_data
.series
.set_items(vec![series()]);
app_arc
app
.lock()
.await
.data
.sonarr_data
.seasons
.set_items(vec![season()]);
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
assert!(network
.handle_sonarr_event(SonarrEvent::GetSeasonReleases((1, 1)))
.await
.is_ok());
assert!(
network
.handle_sonarr_event(SonarrEvent::GetSeasonReleases((1, 1)))
.await
.is_ok()
);
async_server.assert_async().await;
mock.assert_async().await;
assert_eq!(
app_arc
app
.lock()
.await
.data
@@ -300,33 +286,27 @@ mod tests {
..history_item()
},
];
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(history_json),
None,
SonarrEvent::GetSeasonHistory((1, 1)),
None,
Some("seriesId=1&seasonNumber=1"),
)
.await;
app_arc.lock().await.data.sonarr_data.season_details_modal =
Some(SeasonDetailsModal::default());
app_arc
let (mock, app, _server) = MockServarrApi::get()
.returns(history_json)
.query("seriesId=1&seasonNumber=1")
.build_for(SonarrEvent::GetSeasonHistory((1, 1)))
.await;
app.lock().await.data.sonarr_data.season_details_modal = Some(SeasonDetailsModal::default());
app
.lock()
.await
.data
.sonarr_data
.series
.set_items(vec![series()]);
app_arc
app
.lock()
.await
.data
.sonarr_data
.seasons
.set_items(vec![season()]);
app_arc
app
.lock()
.await
.data
@@ -336,17 +316,17 @@ mod tests {
.unwrap()
.season_history
.sort_asc = true;
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
if let SonarrSerdeable::SonarrHistoryItems(history) = network
.handle_sonarr_event(SonarrEvent::GetSeasonHistory((1, 1)))
.await
.unwrap()
{
async_server.assert_async().await;
mock.assert_async().await;
assert_eq!(
app_arc
app
.lock()
.await
.data
@@ -359,7 +339,7 @@ mod tests {
expected_history_items
);
assert!(
app_arc
app
.lock()
.await
.data
@@ -417,48 +397,45 @@ mod tests {
..history_item()
},
];
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(history_json),
None,
SonarrEvent::GetSeasonHistory((1, 1)),
None,
Some("seriesId=1&seasonNumber=1"),
)
.await;
app_arc
let (mock, app, _server) = MockServarrApi::get()
.returns(history_json)
.query("seriesId=1&seasonNumber=1")
.build_for(SonarrEvent::GetSeasonHistory((1, 1)))
.await;
app
.lock()
.await
.data
.sonarr_data
.series
.set_items(vec![series()]);
app_arc
app
.lock()
.await
.data
.sonarr_data
.seasons
.set_items(vec![season()]);
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
if let SonarrSerdeable::SonarrHistoryItems(history) = network
.handle_sonarr_event(SonarrEvent::GetSeasonHistory((1, 1)))
.await
.unwrap()
{
async_server.assert_async().await;
assert!(app_arc
.lock()
.await
.data
.sonarr_data
.season_details_modal
.is_some());
mock.assert_async().await;
assert!(
app
.lock()
.await
.data
.sonarr_data
.season_details_modal
.is_some()
);
assert_eq!(
app_arc
app
.lock()
.await
.data
@@ -471,7 +448,7 @@ mod tests {
expected_history_items
);
assert!(
!app_arc
!app
.lock()
.await
.data
@@ -488,28 +465,25 @@ mod tests {
#[tokio::test]
async fn test_handle_trigger_automatic_season_search_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": "SeasonSearch",
"seriesId": 1,
"seasonNumber": 1
})),
Some(json!({})),
None,
SonarrEvent::TriggerAutomaticSeasonSearch((1, 1)),
None,
None,
)
.await;
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
}))
.returns(json!({}))
.build_for(SonarrEvent::TriggerAutomaticSeasonSearch((1, 1)))
.await;
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
assert!(network
.handle_sonarr_event(SonarrEvent::TriggerAutomaticSeasonSearch((1, 1)))
.await
.is_ok());
assert!(
network
.handle_sonarr_event(SonarrEvent::TriggerAutomaticSeasonSearch((1, 1)))
.await
.is_ok()
);
async_server.assert_async().await;
mock.assert_async().await;
}
}
src/network/sonarr_network/library/series/mod.rs
+5 -3
View File
@@ -1,15 +1,15 @@
use crate::models::Route;
use crate::models::servarr_data::sonarr::sonarr_data::ActiveSonarrBlock;
use crate::models::sonarr_models::{
AddSeriesBody, AddSeriesSearchResult, DeleteSeriesParams, EditSeriesParams, Series,
SonarrCommandBody, SonarrHistoryItem,
};
use crate::models::stateful_table::StatefulTable;
use crate::models::Route;
use crate::network::sonarr_network::SonarrEvent;
use crate::network::{Network, RequestMethod};
use anyhow::Result;
use log::{debug, info, warn};
use serde_json::{json, Value};
use serde_json::{Value, json};
use urlencoding::encode;
#[cfg(test)]
@@ -56,7 +56,9 @@ impl Network<'_, '_> {
add_list_exclusion,
} = delete_series_params;
info!("Deleting Sonarr series with ID: {id} with deleteFiles={delete_series_files} and addImportExclusion={add_list_exclusion}");
info!(
"Deleting Sonarr series with ID: {id} with deleteFiles={delete_series_files} and addImportExclusion={add_list_exclusion}"
);
let request_props = self
.request_props_from(
src/network/sonarr_network/library/series/sonarr_series_network_tests.rs
+286 -378
View File
@@ -6,19 +6,17 @@ mod tests {
SonarrHistoryItem, SonarrSerdeable,
};
use crate::models::stateful_table::{SortOption, StatefulTable};
use crate::network::network_tests::test_utils::mock_servarr_api;
use crate::network::sonarr_network::sonarr_network_test_utils::test_utils::{
add_series_search_result, history_item, season, series, SERIES_JSON,
};
use crate::network::NetworkResource;
use crate::network::network_tests::test_utils::{MockServarrApi, test_network};
use crate::network::sonarr_network::SonarrEvent;
use crate::network::{Network, NetworkResource, RequestMethod};
use crate::network::sonarr_network::sonarr_network_test_utils::test_utils::{
SERIES_JSON, add_series_search_result, history_item, season, series,
};
use bimap::BiMap;
use mockito::Matcher;
use pretty_assertions::assert_eq;
use reqwest::Client;
use rstest::rstest;
use serde_json::{json, Value};
use tokio_util::sync::CancellationToken;
use serde_json::{Value, json};
#[tokio::test]
async fn test_handle_add_sonarr_series_event() {
@@ -39,9 +37,8 @@ mod tests {
search_for_missing_episodes: true,
},
};
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Post,
Some(json!({
let (async_server, app, _server) = MockServarrApi::post()
.with_request_body(json!({
"tvdbId": 1234,
"title": "Test",
"monitored": true,
@@ -56,30 +53,28 @@ mod tests {
"searchForCutoffUnmetEpisodes": true,
"searchForMissingEpisodes": true
}
})),
Some(json!({})),
None,
SonarrEvent::AddSeries(expected_add_series_body.clone()),
None,
None,
)
.await;
app_arc.lock().await.data.sonarr_data.tags_map =
}))
.returns(json!({}))
.build_for(SonarrEvent::AddSeries(expected_add_series_body.clone()))
.await;
app.lock().await.data.sonarr_data.tags_map =
BiMap::from_iter([(1, "usenet".to_owned()), (2, "testing".to_owned())]);
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
assert!(network
.handle_sonarr_event(SonarrEvent::AddSeries(expected_add_series_body))
.await
.is_ok());
assert!(
network
.handle_sonarr_event(SonarrEvent::AddSeries(expected_add_series_body))
.await
.is_ok()
);
async_server.assert_async().await;
}
#[tokio::test]
async fn test_handle_add_sonarr_series_event_does_not_overwrite_tags_vec_when_tag_input_string_is_none(
) {
async fn test_handle_add_sonarr_series_event_does_not_overwrite_tags_vec_when_tag_input_string_is_none()
{
let expected_add_series_body = AddSeriesBody {
tvdb_id: 1234,
title: "Test".to_owned(),
@@ -97,9 +92,8 @@ mod tests {
search_for_missing_episodes: true,
},
};
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Post,
Some(json!({
let (async_server, app, _server) = MockServarrApi::post()
.with_request_body(json!({
"tvdbId": 1234,
"title": "Test",
"monitored": true,
@@ -114,21 +108,19 @@ mod tests {
"searchForCutoffUnmetEpisodes": true,
"searchForMissingEpisodes": true
}
})),
Some(json!({})),
None,
SonarrEvent::AddSeries(expected_add_series_body.clone()),
None,
None,
)
.await;
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
}))
.returns(json!({}))
.build_for(SonarrEvent::AddSeries(expected_add_series_body.clone()))
.await;
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
assert!(network
.handle_sonarr_event(SonarrEvent::AddSeries(expected_add_series_body))
.await
.is_ok());
assert!(
network
.handle_sonarr_event(SonarrEvent::AddSeries(expected_add_series_body))
.await
.is_ok()
);
async_server.assert_async().await;
}
@@ -140,23 +132,20 @@ mod tests {
delete_series_files: true,
add_list_exclusion: true,
};
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Delete,
None,
None,
None,
SonarrEvent::DeleteSeries(delete_series_params.clone()),
Some("/1"),
Some("deleteFiles=true&addImportExclusion=true"),
)
.await;
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let (async_server, app, _server) = MockServarrApi::delete()
.path("/1")
.query("deleteFiles=true&addImportExclusion=true")
.build_for(SonarrEvent::DeleteSeries(delete_series_params.clone()))
.await;
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
assert!(network
.handle_sonarr_event(SonarrEvent::DeleteSeries(delete_series_params))
.await
.is_ok());
assert!(
network
.handle_sonarr_event(SonarrEvent::DeleteSeries(delete_series_params))
.await
.is_ok()
);
async_server.assert_async().await;
}
@@ -183,16 +172,11 @@ mod tests {
..EditSeriesParams::default()
};
let (async_details_server, app_arc, mut server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(serde_json::from_str(SERIES_JSON).unwrap()),
None,
SonarrEvent::GetSeriesDetails(1),
Some("/1"),
None,
)
.await;
let (async_details_server, app, mut server) = MockServarrApi::get()
.returns(serde_json::from_str(SERIES_JSON).unwrap())
.path("/1")
.build_for(SonarrEvent::GetSeriesDetails(1))
.await;
let async_edit_server = server
.mock(
"PUT",
@@ -207,23 +191,25 @@ mod tests {
.match_body(Matcher::Json(expected_body))
.create_async()
.await;
app_arc.lock().await.data.sonarr_data.tags_map =
app.lock().await.data.sonarr_data.tags_map =
BiMap::from_iter([(1, "usenet".to_owned()), (2, "testing".to_owned())]);
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
assert!(network
.handle_sonarr_event(SonarrEvent::EditSeries(edit_series_params))
.await
.is_ok());
assert!(
network
.handle_sonarr_event(SonarrEvent::EditSeries(edit_series_params))
.await
.is_ok()
);
async_details_server.assert_async().await;
async_edit_server.assert_async().await;
}
#[tokio::test]
async fn test_handle_edit_series_event_does_not_overwrite_tag_ids_vec_when_tag_input_string_is_none(
) {
async fn test_handle_edit_series_event_does_not_overwrite_tag_ids_vec_when_tag_input_string_is_none()
{
let mut expected_body: Value = serde_json::from_str(SERIES_JSON).unwrap();
*expected_body.get_mut("monitored").unwrap() = json!(false);
*expected_body.get_mut("seasonFolder").unwrap() = json!(false);
@@ -244,16 +230,11 @@ mod tests {
..EditSeriesParams::default()
};
let (async_details_server, app_arc, mut server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(serde_json::from_str(SERIES_JSON).unwrap()),
None,
SonarrEvent::GetSeriesDetails(1),
Some("/1"),
None,
)
.await;
let (async_details_server, app, mut server) = MockServarrApi::get()
.returns(serde_json::from_str(SERIES_JSON).unwrap())
.path("/1")
.build_for(SonarrEvent::GetSeriesDetails(1))
.await;
let async_edit_server = server
.mock(
"PUT",
@@ -268,15 +249,17 @@ mod tests {
.match_body(Matcher::Json(expected_body))
.create_async()
.await;
app_arc.lock().await.data.sonarr_data.tags_map =
app.lock().await.data.sonarr_data.tags_map =
BiMap::from_iter([(1, "usenet".to_owned()), (2, "testing".to_owned())]);
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
assert!(network
.handle_sonarr_event(SonarrEvent::EditSeries(edit_series_params))
.await
.is_ok());
assert!(
network
.handle_sonarr_event(SonarrEvent::EditSeries(edit_series_params))
.await
.is_ok()
);
async_details_server.assert_async().await;
async_edit_server.assert_async().await;
@@ -289,16 +272,11 @@ mod tests {
..EditSeriesParams::default()
};
let expected_body: Value = serde_json::from_str(SERIES_JSON).unwrap();
let (async_details_server, app_arc, mut server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(serde_json::from_str(SERIES_JSON).unwrap()),
None,
SonarrEvent::GetSeriesDetails(1),
Some("/1"),
None,
)
.await;
let (async_details_server, app, mut server) = MockServarrApi::get()
.returns(serde_json::from_str(SERIES_JSON).unwrap())
.path("/1")
.build_for(SonarrEvent::GetSeriesDetails(1))
.await;
let async_edit_server = server
.mock(
"PUT",
@@ -313,13 +291,15 @@ mod tests {
.match_body(Matcher::Json(expected_body))
.create_async()
.await;
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
assert!(network
.handle_sonarr_event(SonarrEvent::EditSeries(edit_series_params))
.await
.is_ok());
assert!(
network
.handle_sonarr_event(SonarrEvent::EditSeries(edit_series_params))
.await
.is_ok()
);
async_details_server.assert_async().await;
async_edit_server.assert_async().await;
@@ -330,16 +310,11 @@ mod tests {
let mut expected_body: Value = serde_json::from_str(SERIES_JSON).unwrap();
*expected_body.get_mut("tags").unwrap() = json!([]);
let (async_details_server, app_arc, mut server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(serde_json::from_str(SERIES_JSON).unwrap()),
None,
SonarrEvent::GetSeriesDetails(1),
Some("/1"),
None,
)
.await;
let (async_details_server, app, mut server) = MockServarrApi::get()
.returns(serde_json::from_str(SERIES_JSON).unwrap())
.path("/1")
.build_for(SonarrEvent::GetSeriesDetails(1))
.await;
let edit_series_params = EditSeriesParams {
series_id: 1,
clear_tags: true,
@@ -359,13 +334,15 @@ mod tests {
.match_body(Matcher::Json(expected_body))
.create_async()
.await;
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
assert!(network
.handle_sonarr_event(SonarrEvent::EditSeries(edit_series_params))
.await
.is_ok());
assert!(
network
.handle_sonarr_event(SonarrEvent::EditSeries(edit_series_params))
.await
.is_ok()
);
async_details_server.assert_async().await;
async_edit_server.assert_async().await;
@@ -376,16 +353,11 @@ mod tests {
let mut expected_body: Value = serde_json::from_str(SERIES_JSON).unwrap();
*expected_body.get_mut("monitored").unwrap() = json!(false);
let (async_details_server, app_arc, mut server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(serde_json::from_str(SERIES_JSON).unwrap()),
None,
SonarrEvent::GetSeriesDetails(1),
Some("/1"),
None,
)
.await;
let (async_details_server, app, mut server) = MockServarrApi::get()
.returns(serde_json::from_str(SERIES_JSON).unwrap())
.path("/1")
.build_for(SonarrEvent::GetSeriesDetails(1))
.await;
let async_toggle_server = server
.mock(
"PUT",
@@ -401,17 +373,19 @@ mod tests {
.create_async()
.await;
{
let mut app = app_arc.lock().await;
let mut app = app.lock().await;
app.data.sonarr_data.series.set_items(vec![series()]);
app.data.sonarr_data.seasons.set_items(vec![season()]);
}
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
assert!(network
.handle_sonarr_event(SonarrEvent::ToggleSeriesMonitoring(1))
.await
.is_ok());
assert!(
network
.handle_sonarr_event(SonarrEvent::ToggleSeriesMonitoring(1))
.await
.is_ok()
);
async_details_server.assert_async().await;
async_toggle_server.assert_async().await;
@@ -420,25 +394,20 @@ mod tests {
#[tokio::test]
async fn test_handle_get_series_details_event() {
let expected_series: Series = serde_json::from_str(SERIES_JSON).unwrap();
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(serde_json::from_str(SERIES_JSON).unwrap()),
None,
SonarrEvent::GetSeriesDetails(1),
Some("/1"),
None,
)
.await;
app_arc
let (async_server, app, _server) = MockServarrApi::get()
.returns(serde_json::from_str(SERIES_JSON).unwrap())
.path("/1")
.build_for(SonarrEvent::GetSeriesDetails(1))
.await;
app
.lock()
.await
.data
.sonarr_data
.series
.set_items(vec![series()]);
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
if let SonarrSerdeable::Series(series) = network
.handle_sonarr_event(SonarrEvent::GetSeriesDetails(1))
@@ -496,16 +465,11 @@ mod tests {
..history_item()
},
];
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(history_json),
None,
SonarrEvent::GetSeriesHistory(1),
None,
Some("seriesId=1"),
)
.await;
let (async_server, app, _server) = MockServarrApi::get()
.returns(history_json)
.query("seriesId=1")
.build_for(SonarrEvent::GetSeriesHistory(1))
.await;
let mut series_history_table = StatefulTable {
sort_asc: true,
..StatefulTable::default()
@@ -525,16 +489,16 @@ mod tests {
};
series_history_table.sorting(vec![history_sort_option]);
}
app_arc
app
.lock()
.await
.data
.sonarr_data
.series
.set_items(vec![series()]);
app_arc.lock().await.data.sonarr_data.series_history = Some(series_history_table);
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
app.lock().await.data.sonarr_data.series_history = Some(series_history_table);
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
if let SonarrSerdeable::SonarrHistoryItems(history_items) = network
.handle_sonarr_event(SonarrEvent::GetSeriesHistory(1))
@@ -542,15 +506,9 @@ mod tests {
.unwrap()
{
async_server.assert_async().await;
assert!(app_arc
.lock()
.await
.data
.sonarr_data
.series_history
.is_some());
assert!(app.lock().await.data.sonarr_data.series_history.is_some());
assert_eq!(
app_arc
app
.lock()
.await
.data
@@ -562,7 +520,7 @@ mod tests {
expected_history_items
);
assert!(
app_arc
app
.lock()
.await
.data
@@ -619,25 +577,20 @@ mod tests {
..history_item()
},
];
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(history_json),
None,
SonarrEvent::GetSeriesHistory(1),
None,
Some("seriesId=1"),
)
.await;
app_arc
let (async_server, app, _server) = MockServarrApi::get()
.returns(history_json)
.query("seriesId=1")
.build_for(SonarrEvent::GetSeriesHistory(1))
.await;
app
.lock()
.await
.data
.sonarr_data
.series
.set_items(vec![series()]);
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
if let SonarrSerdeable::SonarrHistoryItems(history_items) = network
.handle_sonarr_event(SonarrEvent::GetSeriesHistory(1))
@@ -645,15 +598,9 @@ mod tests {
.unwrap()
{
async_server.assert_async().await;
assert!(app_arc
.lock()
.await
.data
.sonarr_data
.series_history
.is_some());
assert!(app.lock().await.data.sonarr_data.series_history.is_some());
assert_eq!(
app_arc
app
.lock()
.await
.data
@@ -665,7 +612,7 @@ mod tests {
expected_history_items
);
assert!(
!app_arc
!app
.lock()
.await
.data
@@ -708,16 +655,11 @@ mod tests {
}
}]);
let response: Vec<SonarrHistoryItem> = serde_json::from_value(history_json.clone()).unwrap();
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(history_json),
None,
SonarrEvent::GetSeriesHistory(1),
None,
Some("seriesId=1"),
)
.await;
let (async_server, app, _server) = MockServarrApi::get()
.returns(history_json)
.query("seriesId=1")
.build_for(SonarrEvent::GetSeriesHistory(1))
.await;
let cmp_fn = |a: &SonarrHistoryItem, b: &SonarrHistoryItem| {
a.source_title
.text
@@ -733,20 +675,20 @@ mod tests {
..StatefulTable::default()
};
series_history_table.sorting(vec![history_sort_option]);
app_arc.lock().await.data.sonarr_data.series_history = Some(series_history_table);
app_arc
app.lock().await.data.sonarr_data.series_history = Some(series_history_table);
app
.lock()
.await
.data
.sonarr_data
.series
.set_items(vec![series()]);
app_arc
app
.lock()
.await
.push_navigation_stack(ActiveSonarrBlock::SeriesHistorySortPrompt.into());
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
if let SonarrSerdeable::SonarrHistoryItems(history_items) = network
.handle_sonarr_event(SonarrEvent::GetSeriesHistory(1))
@@ -754,24 +696,20 @@ mod tests {
.unwrap()
{
async_server.assert_async().await;
assert!(app_arc
.lock()
.await
.data
.sonarr_data
.series_history
.is_some());
assert!(app_arc
.lock()
.await
.data
.sonarr_data
.series_history
.as_ref()
.unwrap()
.is_empty());
assert!(app.lock().await.data.sonarr_data.series_history.is_some());
assert!(
app_arc
app
.lock()
.await
.data
.sonarr_data
.series_history
.as_ref()
.unwrap()
.is_empty()
);
assert!(
app
.lock()
.await
.data
@@ -818,17 +756,11 @@ mod tests {
..series()
},
];
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(json!([series_1, series_2])),
None,
SonarrEvent::ListSeries,
None,
None,
)
.await;
app_arc.lock().await.data.sonarr_data.series.sort_asc = true;
let (async_server, app, _server) = MockServarrApi::get()
.returns(json!([series_1, series_2]))
.build_for(SonarrEvent::ListSeries)
.await;
app.lock().await.data.sonarr_data.series.sort_asc = true;
if use_custom_sorting {
let cmp_fn = |a: &Series, b: &Series| {
a.title
@@ -841,7 +773,7 @@ mod tests {
name: "Title",
cmp_fn: Some(cmp_fn),
};
app_arc
app
.lock()
.await
.data
@@ -849,8 +781,8 @@ mod tests {
.series
.sorting(vec![title_sort_option]);
}
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
if let SonarrSerdeable::SeriesVec(series) = network
.handle_sonarr_event(SonarrEvent::ListSeries)
@@ -859,10 +791,10 @@ mod tests {
{
async_server.assert_async().await;
assert_eq!(
app_arc.lock().await.data.sonarr_data.series.items,
app.lock().await.data.sonarr_data.series.items,
expected_sorted_series
);
assert!(app_arc.lock().await.data.sonarr_data.series.sort_asc);
assert!(app.lock().await.data.sonarr_data.series.sort_asc);
assert_eq!(series, expected_series);
}
}
@@ -875,21 +807,15 @@ mod tests {
*series_1.get_mut("title").unwrap() = json!("z test");
*series_2.get_mut("id").unwrap() = json!(2);
*series_2.get_mut("title").unwrap() = json!("A test");
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(json!([series_1, series_2])),
None,
SonarrEvent::ListSeries,
None,
None,
)
.await;
app_arc
let (async_server, app, _server) = MockServarrApi::get()
.returns(json!([series_1, series_2]))
.build_for(SonarrEvent::ListSeries)
.await;
app
.lock()
.await
.push_navigation_stack(ActiveSonarrBlock::SeriesSortPrompt.into());
app_arc.lock().await.data.sonarr_data.series.sort_asc = true;
app.lock().await.data.sonarr_data.series.sort_asc = true;
let cmp_fn = |a: &Series, b: &Series| {
a.title
.text
@@ -900,31 +826,26 @@ mod tests {
name: "Title",
cmp_fn: Some(cmp_fn),
};
app_arc
app
.lock()
.await
.data
.sonarr_data
.series
.sorting(vec![title_sort_option]);
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
assert!(network
.handle_sonarr_event(SonarrEvent::ListSeries)
.await
.is_ok());
assert!(
network
.handle_sonarr_event(SonarrEvent::ListSeries)
.await
.is_ok()
);
async_server.assert_async().await;
assert!(app_arc
.lock()
.await
.data
.sonarr_data
.series
.items
.is_empty());
assert!(app_arc.lock().await.data.sonarr_data.series.sort_asc);
assert!(app.lock().await.data.sonarr_data.series.items.is_empty());
assert!(app.lock().await.data.sonarr_data.series.sort_asc);
}
#[tokio::test]
@@ -942,19 +863,14 @@ mod tests {
"ratings": { "votes": 406744, "value": 8.4 },
"statistics": { "seasonCount": 3 }
}]);
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(add_series_search_result_json),
None,
SonarrEvent::SearchNewSeries("test term".into()),
None,
Some("term=test%20term"),
)
.await;
app_arc.lock().await.data.sonarr_data.add_series_search = Some("test term".into());
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let (async_server, app, _server) = MockServarrApi::get()
.returns(add_series_search_result_json)
.query("term=test%20term")
.build_for(SonarrEvent::SearchNewSeries("test term".into()))
.await;
app.lock().await.data.sonarr_data.add_series_search = Some("test term".into());
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
if let SonarrSerdeable::AddSeriesSearchResults(add_series_search_results) = network
.handle_sonarr_event(SonarrEvent::SearchNewSeries("test term".into()))
@@ -962,15 +878,17 @@ mod tests {
.unwrap()
{
async_server.assert_async().await;
assert!(app_arc
.lock()
.await
.data
.sonarr_data
.add_searched_series
.is_some());
assert!(
app
.lock()
.await
.data
.sonarr_data
.add_searched_series
.is_some()
);
assert_eq!(
app_arc
app
.lock()
.await
.data
@@ -987,119 +905,109 @@ mod tests {
#[tokio::test]
async fn test_handle_search_new_series_event_no_results() {
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(json!([])),
None,
SonarrEvent::SearchNewSeries("test term".into()),
None,
Some("term=test%20term"),
)
.await;
app_arc.lock().await.data.sonarr_data.add_series_search = Some("test term".into());
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let (async_server, app, _server) = MockServarrApi::get()
.returns(json!([]))
.query("term=test%20term")
.build_for(SonarrEvent::SearchNewSeries("test term".into()))
.await;
app.lock().await.data.sonarr_data.add_series_search = Some("test term".into());
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
assert!(network
.handle_sonarr_event(SonarrEvent::SearchNewSeries("test term".into()))
.await
.is_ok());
assert!(
network
.handle_sonarr_event(SonarrEvent::SearchNewSeries("test term".into()))
.await
.is_ok()
);
async_server.assert_async().await;
assert!(app_arc
.lock()
.await
.data
.sonarr_data
.add_searched_series
.is_none());
assert!(
app
.lock()
.await
.data
.sonarr_data
.add_searched_series
.is_none()
);
assert_eq!(
app_arc.lock().await.get_current_route(),
app.lock().await.get_current_route(),
ActiveSonarrBlock::AddSeriesEmptySearchResults.into()
);
}
#[tokio::test]
async fn test_handle_trigger_automatic_series_search_event() {
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": "SeriesSearch",
"seriesId": 1
})),
Some(json!({})),
None,
SonarrEvent::TriggerAutomaticSeriesSearch(1),
None,
None,
)
.await;
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
}))
.returns(json!({}))
.build_for(SonarrEvent::TriggerAutomaticSeriesSearch(1))
.await;
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
assert!(network
.handle_sonarr_event(SonarrEvent::TriggerAutomaticSeriesSearch(1))
.await
.is_ok());
assert!(
network
.handle_sonarr_event(SonarrEvent::TriggerAutomaticSeriesSearch(1))
.await
.is_ok()
);
async_server.assert_async().await;
}
#[tokio::test]
async fn test_handle_update_all_series_event() {
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": "RefreshSeries",
})),
Some(json!({})),
None,
SonarrEvent::UpdateAllSeries,
None,
None,
)
.await;
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
}))
.returns(json!({}))
.build_for(SonarrEvent::UpdateAllSeries)
.await;
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
assert!(network
.handle_sonarr_event(SonarrEvent::UpdateAllSeries)
.await
.is_ok());
assert!(
network
.handle_sonarr_event(SonarrEvent::UpdateAllSeries)
.await
.is_ok()
);
async_server.assert_async().await;
}
#[tokio::test]
async fn test_handle_update_and_scan_series_event() {
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": "RefreshSeries",
"seriesId": 1,
})),
Some(json!({})),
None,
SonarrEvent::UpdateAndScanSeries(1),
None,
None,
)
.await;
app_arc
}))
.returns(json!({}))
.build_for(SonarrEvent::UpdateAndScanSeries(1))
.await;
app
.lock()
.await
.data
.sonarr_data
.series
.set_items(vec![series()]);
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
assert!(network
.handle_sonarr_event(SonarrEvent::UpdateAndScanSeries(1))
.await
.is_ok());
assert!(
network
.handle_sonarr_event(SonarrEvent::UpdateAndScanSeries(1))
.await
.is_ok()
);
async_server.assert_async().await;
}
src/network/sonarr_network/library/sonarr_library_network_tests.rs
+15 -21
View File
@@ -1,12 +1,9 @@
#[cfg(test)]
mod tests {
use crate::models::sonarr_models::SonarrReleaseDownloadBody;
use crate::network::network_tests::test_utils::mock_servarr_api;
use crate::network::network_tests::test_utils::{MockServarrApi, test_network};
use crate::network::sonarr_network::SonarrEvent;
use crate::network::{Network, RequestMethod};
use reqwest::Client;
use serde_json::json;
use tokio_util::sync::CancellationToken;
#[tokio::test]
async fn test_handle_download_sonarr_release_event_uses_provided_params() {
@@ -16,28 +13,25 @@ mod tests {
series_id: Some(1),
..SonarrReleaseDownloadBody::default()
};
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Post,
Some(json!({
let (mock, app, _server) = MockServarrApi::post()
.with_request_body(json!({
"guid": "1234",
"indexerId": 2,
"seriesId": 1,
})),
Some(json!({})),
None,
SonarrEvent::DownloadRelease(params.clone()),
None,
None,
)
.await;
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
}))
.returns(json!({}))
.build_for(SonarrEvent::DownloadRelease(params.clone()))
.await;
assert!(network
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
let result = network
.handle_sonarr_event(SonarrEvent::DownloadRelease(params))
.await
.is_ok());
.await;
async_server.assert_async().await;
mock.assert_async().await;
assert!(result.is_ok());
}
}
src/network/sonarr_network/mod.rs
+1 -1
View File
@@ -1,6 +1,6 @@
use anyhow::Result;
use log::info;
use serde_json::{json, Value};
use serde_json::{Value, json};
use super::{Network, NetworkEvent, NetworkResource};
use crate::{
src/network/sonarr_network/root_folders/sonarr_root_folders_network_tests.rs
+41 -61
View File
@@ -2,71 +2,57 @@
mod tests {
use crate::models::servarr_models::{AddRootFolderBody, RootFolder};
use crate::models::sonarr_models::SonarrSerdeable;
use crate::network::network_tests::test_utils::mock_servarr_api;
use crate::network::sonarr_network::sonarr_network_test_utils::test_utils::root_folder;
use crate::network::network_tests::test_utils::{MockServarrApi, test_network};
use crate::network::sonarr_network::SonarrEvent;
use crate::network::{Network, RequestMethod};
use crate::network::sonarr_network::sonarr_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_sonarr_root_folder_event() {
let expected_add_root_folder_body = AddRootFolderBody {
path: "/nfs/test".to_owned(),
};
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,
SonarrEvent::AddRootFolder(expected_add_root_folder_body.clone()),
None,
None,
)
.await;
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
}))
.returns(json!({}))
.build_for(SonarrEvent::AddRootFolder(
expected_add_root_folder_body.clone(),
))
.await;
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
assert!(network
.handle_sonarr_event(SonarrEvent::AddRootFolder(expected_add_root_folder_body))
.await
.is_ok());
assert!(
network
.handle_sonarr_event(SonarrEvent::AddRootFolder(expected_add_root_folder_body))
.await
.is_ok()
);
async_server.assert_async().await;
assert!(app_arc
.lock()
.await
.data
.sonarr_data
.edit_root_folder
.is_none());
mock.assert_async().await;
assert!(app.lock().await.data.sonarr_data.edit_root_folder.is_none());
}
#[tokio::test]
async fn test_handle_delete_sonarr_root_folder_event() {
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Delete,
None,
None,
None,
SonarrEvent::DeleteRootFolder(1),
Some("/1"),
None,
)
.await;
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let (mock, app, _server) = MockServarrApi::delete()
.path("/1")
.build_for(SonarrEvent::DeleteRootFolder(1))
.await;
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
assert!(network
.handle_sonarr_event(SonarrEvent::DeleteRootFolder(1))
.await
.is_ok());
assert!(
network
.handle_sonarr_event(SonarrEvent::DeleteRootFolder(1))
.await
.is_ok()
);
async_server.assert_async().await;
mock.assert_async().await;
}
#[tokio::test]
@@ -78,27 +64,21 @@ 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,
SonarrEvent::GetRootFolders,
None,
None,
)
.await;
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let (mock, app, _server) = MockServarrApi::get()
.returns(root_folder_json)
.build_for(SonarrEvent::GetRootFolders)
.await;
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
if let SonarrSerdeable::RootFolders(root_folders) = network
.handle_sonarr_event(SonarrEvent::GetRootFolders)
.await
.unwrap()
{
async_server.assert_async().await;
mock.assert_async().await;
assert_eq!(
app_arc.lock().await.data.sonarr_data.root_folders.items,
app.lock().await.data.sonarr_data.root_folders.items,
vec![root_folder()]
);
assert_eq!(root_folders, response);
src/network/sonarr_network/sonarr_network_test_utils.rs
+9 -2
View File
@@ -1,5 +1,6 @@
#[cfg(test)]
pub(in crate::network::sonarr_network) mod test_utils {
use crate::models::HorizontallyScrollableText;
use crate::models::servarr_models::{
Indexer, IndexerField, Language, Quality, QualityWrapper, RootFolder,
};
@@ -9,9 +10,8 @@ pub(in crate::network::sonarr_network) mod test_utils {
Season, SeasonStatistics, Series, SeriesStatistics, SeriesStatus, SeriesType,
SonarrHistoryData, SonarrHistoryEventType, SonarrHistoryItem, SonarrRelease,
};
use crate::models::HorizontallyScrollableText;
use chrono::DateTime;
use serde_json::{json, Number};
use serde_json::{Number, Value, json};
pub const SERIES_JSON: &str = r#"{
"title": "Test",
@@ -392,4 +392,11 @@ pub(in crate::network::sonarr_network) mod test_utils {
unmapped_folders: None,
}
}
pub fn tag() -> Value {
json!({
"id": 3,
"label": "testing"
})
}
}
src/network/sonarr_network/sonarr_network_tests.rs
+124 -154
View File
@@ -9,18 +9,15 @@ mod test {
AddSeriesBody, EditSeriesParams, IndexerSettings, SonarrTaskName,
};
use crate::models::sonarr_models::{DeleteSeriesParams, SonarrSerdeable};
use crate::network::{
network_tests::test_utils::mock_servarr_api, sonarr_network::SonarrEvent, Network,
NetworkEvent, NetworkResource, RequestMethod,
};
use crate::network::network_tests::test_utils::{MockServarrApi, test_network};
use crate::network::sonarr_network::sonarr_network_test_utils::test_utils::tag;
use crate::network::{NetworkEvent, NetworkResource, sonarr_network::SonarrEvent};
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_all_indexer_settings(
@@ -191,82 +188,73 @@ mod test {
#[tokio::test]
async fn test_handle_add_sonarr_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,
SonarrEvent::AddTag(String::new()),
None,
None,
)
.await;
app_arc.lock().await.data.sonarr_data.tags_map =
BiMap::from_iter([(1, "usenet".to_owned()), (2, "test".to_owned())]);
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let expected = Tag {
id: 3,
label: "testing".to_owned(),
};
if let SonarrSerdeable::Tag(tag) = network
let (mock, app, _server) = MockServarrApi::post()
.with_request_body(json!({ "label": "testing" }))
.returns(tag())
.build_for(SonarrEvent::AddTag(String::new()))
.await;
app.lock().await.data.sonarr_data.tags_map =
BiMap::from_iter([(1, "usenet".to_owned()), (2, "test".to_owned())]);
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
let result = network
.handle_sonarr_event(SonarrEvent::AddTag("testing".to_owned()))
.await
.unwrap()
{
async_server.assert_async().await;
assert_eq!(
app_arc.lock().await.data.sonarr_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 SonarrSerdeable::Tag(tag) = result.unwrap() else {
panic!("Expected Tag variant");
};
assert_eq!(tag, expected);
assert_eq!(
app.lock().await.data.sonarr_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_sonarr_tag_event() {
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Delete,
None,
None,
None,
SonarrEvent::DeleteTag(1),
Some("/1"),
None,
)
.await;
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let (async_server, app, _server) = MockServarrApi::delete()
.path("/1")
.build_for(SonarrEvent::DeleteTag(1))
.await;
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
assert!(network
.handle_sonarr_event(SonarrEvent::DeleteTag(1))
.await
.is_ok());
assert!(
network
.handle_sonarr_event(SonarrEvent::DeleteTag(1))
.await
.is_ok()
);
async_server.assert_async().await;
}
#[tokio::test]
async fn test_handle_get_sonarr_healthcheck_event() {
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
None,
None,
SonarrEvent::HealthCheck,
None,
None,
)
.await;
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let (mock, app, _server) = MockServarrApi::get()
.build_for(SonarrEvent::HealthCheck)
.await;
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
let _ = network.handle_sonarr_event(SonarrEvent::HealthCheck).await;
async_server.assert_async().await;
mock.assert_async().await;
}
#[tokio::test]
@@ -276,31 +264,27 @@ mod test {
"name": "English"
}]);
let response: Vec<Language> = serde_json::from_value(language_profiles_json.clone()).unwrap();
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(language_profiles_json),
None,
SonarrEvent::GetLanguageProfiles,
None,
None,
)
.await;
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let (mock, app, _server) = MockServarrApi::get()
.returns(language_profiles_json)
.build_for(SonarrEvent::GetLanguageProfiles)
.await;
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
if let SonarrSerdeable::LanguageProfiles(language_profiles) = network
let result = network
.handle_sonarr_event(SonarrEvent::GetLanguageProfiles)
.await
.unwrap()
{
async_server.assert_async().await;
assert_eq!(
app_arc.lock().await.data.sonarr_data.language_profiles_map,
BiMap::from_iter([(2222i64, "English".to_owned())])
);
assert_eq!(language_profiles, response);
}
.await;
mock.assert_async().await;
let SonarrSerdeable::LanguageProfiles(language_profiles) = result.unwrap() else {
panic!("Expected the LanguageProfiles variant")
};
assert_eq!(
app.lock().await.data.sonarr_data.language_profiles_map,
BiMap::from_iter([(2222i64, "English".to_owned())])
);
assert_eq!(language_profiles, response);
}
#[tokio::test]
@@ -311,31 +295,27 @@ mod test {
}]);
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,
SonarrEvent::GetQualityProfiles,
None,
None,
)
.await;
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let (mock, app, _server) = MockServarrApi::get()
.returns(quality_profile_json)
.build_for(SonarrEvent::GetQualityProfiles)
.await;
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
if let SonarrSerdeable::QualityProfiles(quality_profiles) = network
let result = network
.handle_sonarr_event(SonarrEvent::GetQualityProfiles)
.await
.unwrap()
{
async_server.assert_async().await;
assert_eq!(
app_arc.lock().await.data.sonarr_data.quality_profile_map,
BiMap::from_iter([(2222i64, "HD - 1080p".to_owned())])
);
assert_eq!(quality_profiles, response);
}
.await;
mock.assert_async().await;
let SonarrSerdeable::QualityProfiles(quality_profiles) = result.unwrap() else {
panic!("Expected the QualityProfiles variant")
};
assert_eq!(
app.lock().await.data.sonarr_data.quality_profile_map,
BiMap::from_iter([(2222i64, "HD - 1080p".to_owned())])
);
assert_eq!(quality_profiles, response);
}
#[tokio::test]
@@ -345,31 +325,26 @@ mod test {
"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,
SonarrEvent::GetTags,
None,
None,
)
.await;
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let (mock, app, _server) = MockServarrApi::get()
.returns(tags_json)
.build_for(SonarrEvent::GetTags)
.await;
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
if let SonarrSerdeable::Tags(tags) = network
.handle_sonarr_event(SonarrEvent::GetTags)
.await
.unwrap()
{
async_server.assert_async().await;
assert_eq!(
app_arc.lock().await.data.sonarr_data.tags_map,
BiMap::from_iter([(2222i64, "usenet".to_owned())])
);
assert_eq!(tags, response);
}
let result = network.handle_sonarr_event(SonarrEvent::GetTags).await;
mock.assert_async().await;
let SonarrSerdeable::Tags(tags) = result.unwrap() else {
panic!("Expected the Tag variant")
};
mock.assert_async().await;
assert_eq!(
app.lock().await.data.sonarr_data.tags_map,
BiMap::from_iter([(2222i64, "usenet".to_owned())])
);
assert_eq!(tags, response);
}
#[tokio::test]
@@ -385,7 +360,7 @@ mod test {
]);
}
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let mut network = test_network(&app_arc);
assert_eq!(
network.extract_and_add_sonarr_tag_ids_vec(tags).await,
@@ -395,35 +370,30 @@ mod test {
#[tokio::test]
async fn test_extract_and_add_sonarr_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,
SonarrEvent::GetTags,
None,
None,
)
.await;
let (mock, app, _server) = MockServarrApi::post()
.with_request_body(json!({ "label": "TESTING" }))
.returns(json!({ "id": 3, "label": "testing" }))
.build_for(SonarrEvent::GetTags)
.await;
let tags = "usenet, test, TESTING";
{
let mut app = app_arc.lock().await;
app.data.sonarr_data.add_series_modal = Some(AddSeriesModal {
let mut app_guard = app.lock().await;
app_guard.data.sonarr_data.add_series_modal = Some(AddSeriesModal {
tags: tags.into(),
..AddSeriesModal::default()
});
app.data.sonarr_data.tags_map =
app_guard.data.sonarr_data.tags_map =
BiMap::from_iter([(1, "usenet".to_owned()), (2, "test".to_owned())]);
}
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
let tag_ids_vec = network.extract_and_add_sonarr_tag_ids_vec(tags).await;
async_server.assert_async().await;
mock.assert_async().await;
assert_eq!(tag_ids_vec, vec![1, 2, 3]);
assert_eq!(
app_arc.lock().await.data.sonarr_data.tags_map,
app.lock().await.data.sonarr_data.tags_map,
BiMap::from_iter([
(1, "usenet".to_owned()),
(2, "test".to_owned()),
src/network/sonarr_network/system/sonarr_system_network_tests.rs
+103 -150
View File
@@ -5,15 +5,12 @@ mod tests {
};
use crate::models::sonarr_models::{SonarrSerdeable, SonarrTask, SonarrTaskName, SystemStatus};
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::sonarr_network::SonarrEvent;
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_sonarr_host_config_event() {
@@ -29,25 +26,19 @@ 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,
SonarrEvent::GetHostConfig,
None,
None,
)
.await;
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let (mock, app, _server) = MockServarrApi::get()
.returns(host_config_response)
.build_for(SonarrEvent::GetHostConfig)
.await;
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
if let SonarrSerdeable::HostConfig(host_config) = network
.handle_sonarr_event(SonarrEvent::GetHostConfig)
.await
.unwrap()
{
async_server.assert_async().await;
mock.assert_async().await;
assert_eq!(host_config, response);
}
}
@@ -85,48 +76,40 @@ 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,
SonarrEvent::GetLogs(500),
None,
Some("pageSize=500&sortDirection=descending&sortKey=time"),
)
.await;
app_arc.lock().await.server_tabs.next();
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(SonarrEvent::GetLogs(500))
.await;
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
if let SonarrSerdeable::LogResponse(logs) = network
.handle_sonarr_event(SonarrEvent::GetLogs(500))
.await
.unwrap()
{
async_server.assert_async().await;
assert_eq!(
app_arc.lock().await.data.sonarr_data.logs.items,
expected_logs
mock.assert_async().await;
assert_eq!(app.lock().await.data.sonarr_data.logs.items, expected_logs);
assert!(
app
.lock()
.await
.data
.sonarr_data
.logs
.current_selection()
.text
.contains("INFO")
);
assert!(app_arc
.lock()
.await
.data
.sonarr_data
.logs
.current_selection()
.text
.contains("INFO"));
assert_eq!(logs, response);
}
}
#[tokio::test]
async fn test_handle_get_sonarr_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,
@@ -135,15 +118,11 @@ mod tests {
"freeSpace": 3333,
"totalSpace": 4444
}
])),
None,
SonarrEvent::GetDiskSpace,
None,
None,
)
.await;
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
]))
.build_for(SonarrEvent::GetDiskSpace)
.await;
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
let disk_space_vec = vec![
DiskSpace {
free_space: 1111,
@@ -160,9 +139,9 @@ mod tests {
.await
.unwrap()
{
async_server.assert_async().await;
mock.assert_async().await;
assert_eq!(
app_arc.lock().await.data.sonarr_data.disk_space_vec,
app.lock().await.data.sonarr_data.disk_space_vec,
disk_space_vec
);
assert_eq!(disk_space, disk_space_vec);
@@ -194,27 +173,21 @@ mod tests {
trigger: "scheduled".to_owned(),
};
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(queued_events_json),
None,
SonarrEvent::GetQueuedEvents,
None,
None,
)
.await;
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let (mock, app, _server) = MockServarrApi::get()
.returns(queued_events_json)
.build_for(SonarrEvent::GetQueuedEvents)
.await;
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
if let SonarrSerdeable::QueueEvents(events) = network
.handle_sonarr_event(SonarrEvent::GetQueuedEvents)
.await
.unwrap()
{
async_server.assert_async().await;
mock.assert_async().await;
assert_eq!(
app_arc.lock().await.data.sonarr_data.queued_events.items,
app.lock().await.data.sonarr_data.queued_events.items,
vec![expected_event]
);
assert_eq!(events, response);
@@ -233,46 +206,34 @@ 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,
SonarrEvent::GetSecurityConfig,
None,
None,
)
.await;
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let (mock, app, _server) = MockServarrApi::get()
.returns(security_config_response)
.build_for(SonarrEvent::GetSecurityConfig)
.await;
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
if let SonarrSerdeable::SecurityConfig(security_config) = network
.handle_sonarr_event(SonarrEvent::GetSecurityConfig)
.await
.unwrap()
{
async_server.assert_async().await;
mock.assert_async().await;
assert_eq!(security_config, response);
}
}
#[tokio::test]
async fn test_handle_get_status_event() {
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(json!({
let (mock, app, _server) = MockServarrApi::get()
.returns(json!({
"version": "v1",
"startTime": "2023-02-25T20:16:43Z"
})),
None,
SonarrEvent::GetStatus,
None,
None,
)
.await;
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
}))
.build_for(SonarrEvent::GetStatus)
.await;
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
let date_time = DateTime::from(DateTime::parse_from_rfc3339("2023-02-25T20:16:43Z").unwrap());
if let SonarrSerdeable::SystemStatus(status) = network
@@ -280,9 +241,9 @@ mod tests {
.await
.unwrap()
{
async_server.assert_async().await;
assert_str_eq!(app_arc.lock().await.data.sonarr_data.version, "v1");
assert_eq!(app_arc.lock().await.data.sonarr_data.start_time, date_time);
mock.assert_async().await;
assert_str_eq!(app.lock().await.data.sonarr_data.version, "v1");
assert_eq!(app.lock().await.data.sonarr_data.start_time, date_time);
assert_eq!(
status,
SystemStatus {
@@ -327,27 +288,21 @@ mod tests {
next_execution: timestamp,
},
];
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(tasks_json),
None,
SonarrEvent::GetTasks,
None,
None,
)
.await;
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let (mock, app, _server) = MockServarrApi::get()
.returns(tasks_json)
.build_for(SonarrEvent::GetTasks)
.await;
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
if let SonarrSerdeable::Tasks(tasks) = network
.handle_sonarr_event(SonarrEvent::GetTasks)
.await
.unwrap()
{
async_server.assert_async().await;
mock.assert_async().await;
assert_eq!(
app_arc.lock().await.data.sonarr_data.tasks.items,
app.lock().await.data.sonarr_data.tasks.items,
expected_tasks
);
assert_eq!(tasks, response);
@@ -408,43 +363,44 @@ mod tests {
* Cool new thing
Fixed:
* Some bugs killed
3.2.1.0 - 2023-04-15 02:02:53 UTC (Previously Installed)
{line_break}
New:
* Cool new thing (old)
* Other cool new thing (old)
2.1.0 - 2023-04-15 02:02:53 UTC
2.1.0 - 2023-04-15 02:02:53 UTC
{line_break}
Fixed:
* Killed bug 1
* Fixed bug 2"
));
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Get,
None,
Some(updates_json),
None,
SonarrEvent::GetUpdates,
None,
None,
)
.await;
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
let (mock, app, _server) = MockServarrApi::get()
.returns(updates_json)
.build_for(SonarrEvent::GetUpdates)
.await;
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
if let SonarrSerdeable::Updates(updates) = network
.handle_sonarr_event(SonarrEvent::GetUpdates)
.await
.unwrap()
{
async_server.assert_async().await;
assert_str_eq!(
app_arc.lock().await.data.sonarr_data.updates.get_text(),
expected_text.get_text()
mock.assert_async().await;
let actual_text = app.lock().await.data.sonarr_data.updates.get_text();
let expected = expected_text.get_text();
// Trim trailing whitespace from each line for comparison
let actual_trimmed: Vec<&str> = actual_text.lines().map(|l| l.trim_end()).collect();
let expected_trimmed: Vec<&str> = expected.lines().map(|l| l.trim_end()).collect();
assert_eq!(
actual_trimmed, expected_trimmed,
"Updates text mismatch (after trimming trailing whitespace)"
);
assert_eq!(updates, response);
}
@@ -453,19 +409,16 @@ mod tests {
#[tokio::test]
async fn test_handle_start_sonarr_task_event() {
let response = json!({ "test": "test"});
let (async_server, app_arc, _server) = mock_servarr_api(
RequestMethod::Post,
Some(json!({
let (mock, app, _server) = MockServarrApi::post()
.with_request_body(json!({
"name": "ApplicationUpdateCheck"
})),
Some(response.clone()),
None,
SonarrEvent::StartTask(SonarrTaskName::ApplicationUpdateCheck),
None,
None,
)
.await;
app_arc
}))
.returns(response.clone())
.build_for(SonarrEvent::StartTask(
SonarrTaskName::ApplicationUpdateCheck,
))
.await;
app
.lock()
.await
.data
@@ -475,8 +428,8 @@ mod tests {
task_name: SonarrTaskName::default(),
..SonarrTask::default()
}]);
app_arc.lock().await.server_tabs.next();
let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
if let SonarrSerdeable::Value(value) = network
.handle_sonarr_event(SonarrEvent::StartTask(
@@ -485,7 +438,7 @@ mod tests {
.await
.unwrap()
{
async_server.assert_async().await;
mock.assert_async().await;
assert_eq!(value, response);
}
}