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

refactor: Refactored to use more idiomatic let-else statements where applicable

Browse Source
This commit is contained in:
Alex Clarke
2025-12-03 15:23:07 -07:00
parent ad58912baf
commit e50fb88bfc
43 changed files with 1337 additions and 1291 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/network/sonarr_network/blocklist/sonarr_blocklist_network_tests.rs
+19 -17
View File
@@ -163,19 +163,20 @@ mod tests {
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
if let SonarrSerdeable::BlocklistResponse(blocklist) = network
let SonarrSerdeable::BlocklistResponse(blocklist) = network
.handle_sonarr_event(SonarrEvent::GetBlocklist)
.await
.unwrap()
{
mock.assert_async().await;
assert_eq!(
app.lock().await.data.sonarr_data.blocklist.items,
expected_blocklist
);
assert!(app.lock().await.data.sonarr_data.blocklist.sort_asc);
assert_eq!(blocklist, response);
}
else {
panic!("Expected BlocklistResponse")
};
mock.assert_async().await;
assert_eq!(
app.lock().await.data.sonarr_data.blocklist.items,
expected_blocklist
);
assert!(app.lock().await.data.sonarr_data.blocklist.sort_asc);
assert_eq!(blocklist, response);
}
#[tokio::test]
@@ -233,15 +234,16 @@ mod tests {
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
if let SonarrSerdeable::BlocklistResponse(blocklist) = network
let SonarrSerdeable::BlocklistResponse(blocklist) = network
.handle_sonarr_event(SonarrEvent::GetBlocklist)
.await
.unwrap()
{
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);
}
else {
panic!("Expected BlocklistResponse")
};
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
+10 -9
View File
@@ -60,18 +60,19 @@ mod tests {
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
if let SonarrSerdeable::DownloadsResponse(downloads) = network
let SonarrSerdeable::DownloadsResponse(downloads) = network
.handle_sonarr_event(SonarrEvent::GetDownloads(500))
.await
.unwrap()
{
mock.assert_async().await;
assert_eq!(
app.lock().await.data.sonarr_data.downloads.items,
downloads_response().records
);
assert_eq!(downloads, response);
}
else {
panic!("Expected DownloadsResponse")
};
mock.assert_async().await;
assert_eq!(
app.lock().await.data.sonarr_data.downloads.items,
downloads_response().records
);
assert_eq!(downloads, response);
}
#[tokio::test]
src/network/sonarr_network/history/sonarr_history_network_tests.rs
+19 -17
View File
@@ -84,19 +84,20 @@ mod tests {
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
if let SonarrSerdeable::SonarrHistoryWrapper(history) = network
let SonarrSerdeable::SonarrHistoryWrapper(history) = network
.handle_sonarr_event(SonarrEvent::GetHistory(500))
.await
.unwrap()
{
mock.assert_async().await;
assert_eq!(
app.lock().await.data.sonarr_data.history.items,
expected_history_items
);
assert!(app.lock().await.data.sonarr_data.history.sort_asc);
assert_eq!(history, response);
}
else {
panic!("Expected SonarrHistoryWrapper")
};
mock.assert_async().await;
assert_eq!(
app.lock().await.data.sonarr_data.history.items,
expected_history_items
);
assert!(app.lock().await.data.sonarr_data.history.sort_asc);
assert_eq!(history, response);
}
#[tokio::test]
@@ -158,16 +159,17 @@ mod tests {
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
if let SonarrSerdeable::SonarrHistoryWrapper(history) = network
let SonarrSerdeable::SonarrHistoryWrapper(history) = network
.handle_sonarr_event(SonarrEvent::GetHistory(500))
.await
.unwrap()
{
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);
}
else {
panic!("Expected SonarrHistoryWrapper")
};
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);
}
#[tokio::test]
src/network/sonarr_network/indexers/sonarr_indexers_network_tests.rs
+59 -55
View File
@@ -635,18 +635,19 @@ mod tests {
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
if let SonarrSerdeable::Indexers(indexers) = network
let SonarrSerdeable::Indexers(indexers) = network
.handle_sonarr_event(SonarrEvent::GetIndexers)
.await
.unwrap()
{
async_server.assert_async().await;
assert_eq!(
app.lock().await.data.sonarr_data.indexers.items,
vec![indexer()]
);
assert_eq!(indexers, response);
}
else {
panic!("Expected Indexers")
};
async_server.assert_async().await;
assert_eq!(
app.lock().await.data.sonarr_data.indexers.items,
vec![indexer()]
);
assert_eq!(indexers, response);
}
#[tokio::test]
@@ -706,19 +707,20 @@ mod tests {
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
if let SonarrSerdeable::Value(value) = network
let SonarrSerdeable::Value(value) = network
.handle_sonarr_event(SonarrEvent::TestIndexer(1))
.await
.unwrap()
{
async_details_server.assert_async().await;
async_test_server.assert_async().await;
assert_eq!(
app.lock().await.data.sonarr_data.indexer_test_errors,
Some("\"test failure\"".to_owned())
);
assert_eq!(value, response_json)
}
else {
panic!("Expected Value")
};
async_details_server.assert_async().await;
async_test_server.assert_async().await;
assert_eq!(
app.lock().await.data.sonarr_data.indexer_test_errors,
Some("\"test failure\"".to_owned())
);
assert_eq!(value, response_json);
}
#[tokio::test]
@@ -771,19 +773,20 @@ mod tests {
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
if let SonarrSerdeable::Value(value) = network
let SonarrSerdeable::Value(value) = network
.handle_sonarr_event(SonarrEvent::TestIndexer(1))
.await
.unwrap()
{
async_details_server.assert_async().await;
async_test_server.assert_async().await;
assert_eq!(
app.lock().await.data.sonarr_data.indexer_test_errors,
Some(String::new())
);
assert_eq!(value, json!({}));
}
else {
panic!("Expected Value")
};
async_details_server.assert_async().await;
async_test_server.assert_async().await;
assert_eq!(
app.lock().await.data.sonarr_data.indexer_test_errors,
Some(String::new())
);
assert_eq!(value, json!({}));
}
#[tokio::test]
@@ -850,34 +853,35 @@ mod tests {
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
if let SonarrSerdeable::IndexerTestResults(results) = network
let SonarrSerdeable::IndexerTestResults(results) = network
.handle_sonarr_event(SonarrEvent::TestAllIndexers)
.await
.unwrap()
{
async_server.assert_async().await;
assert!(
app
.lock()
.await
.data
.sonarr_data
.indexer_test_all_results
.is_some()
);
assert_eq!(
app
.lock()
.await
.data
.sonarr_data
.indexer_test_all_results
.as_ref()
.unwrap()
.items,
indexer_test_results_modal_items
);
assert_eq!(results, response);
}
else {
panic!("Expected IndexerTestResults")
};
async_server.assert_async().await;
assert!(
app
.lock()
.await
.data
.sonarr_data
.indexer_test_all_results
.is_some()
);
assert_eq!(
app
.lock()
.await
.data
.sonarr_data
.indexer_test_all_results
.as_ref()
.unwrap()
.items,
indexer_test_results_modal_items
);
assert_eq!(results, response);
}
}
src/network/sonarr_network/library/episodes/sonarr_episodes_network_tests.rs
+406 -394
View File
@@ -253,27 +253,28 @@ mod tests {
app_arc.lock().await.server_tabs.next();
let mut network = test_network(&app_arc);
if let SonarrSerdeable::Episodes(episodes) = network
let SonarrSerdeable::Episodes(episodes) = 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,
vec![episode()]
);
assert_eq!(episodes, vec![episode()]);
}
else {
panic!("Expected Episodes")
};
async_server.assert_async().await;
assert_eq!(
app_arc
.lock()
.await
.data
.sonarr_data
.season_details_modal
.as_ref()
.unwrap()
.episodes
.items,
vec![episode()]
);
assert_eq!(episodes, vec![episode()]);
}
#[tokio::test]
@@ -353,38 +354,39 @@ mod tests {
app_arc.lock().await.server_tabs.next();
let mut network = test_network(&app_arc);
if let SonarrSerdeable::Episodes(episodes) = network
let SonarrSerdeable::Episodes(episodes) = network
.handle_sonarr_event(SonarrEvent::GetEpisodes(1))
.await
.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
.sort_asc
);
assert_eq!(episodes, expected_episodes);
}
else {
panic!("Expected Episodes")
};
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
.sort_asc
);
assert_eq!(episodes, expected_episodes);
}
#[tokio::test]
@@ -409,27 +411,28 @@ mod tests {
app_arc.lock().await.server_tabs.next();
let mut network = test_network(&app_arc);
if let SonarrSerdeable::EpisodeFiles(episode_files) = network
let SonarrSerdeable::EpisodeFiles(episode_files) = network
.handle_sonarr_event(SonarrEvent::GetEpisodeFiles(1))
.await
.unwrap()
{
async_server.assert_async().await;
assert_eq!(
app_arc
.lock()
.await
.data
.sonarr_data
.season_details_modal
.as_ref()
.unwrap()
.episode_files
.items,
vec![episode_file()]
);
assert_eq!(episode_files, vec![episode_file()]);
}
else {
panic!("Expected EpisodeFiles")
};
async_server.assert_async().await;
assert_eq!(
app_arc
.lock()
.await
.data
.sonarr_data
.season_details_modal
.as_ref()
.unwrap()
.episode_files
.items,
vec![episode_file()]
);
assert_eq!(episode_files, vec![episode_file()]);
}
#[tokio::test]
@@ -452,36 +455,37 @@ mod tests {
app_arc.lock().await.server_tabs.next();
let mut network = test_network(&app_arc);
if let SonarrSerdeable::EpisodeFiles(episode_files) = network
let SonarrSerdeable::EpisodeFiles(episode_files) = network
.handle_sonarr_event(SonarrEvent::GetEpisodeFiles(1))
.await
.unwrap()
{
async_server.assert_async().await;
assert!(
app_arc
.lock()
.await
.data
.sonarr_data
.season_details_modal
.is_some()
);
assert_eq!(
app_arc
.lock()
.await
.data
.sonarr_data
.season_details_modal
.as_ref()
.unwrap()
.episode_files
.items,
vec![episode_file()]
);
assert_eq!(episode_files, vec![episode_file()]);
}
else {
panic!("Expected EpisodeFiles")
};
async_server.assert_async().await;
assert!(
app_arc
.lock()
.await
.data
.sonarr_data
.season_details_modal
.is_some()
);
assert_eq!(
app_arc
.lock()
.await
.data
.sonarr_data
.season_details_modal
.as_ref()
.unwrap()
.episode_files
.items,
vec![episode_file()]
);
assert_eq!(episode_files, vec![episode_file()]);
}
#[tokio::test]
@@ -569,45 +573,46 @@ mod tests {
app_arc.lock().await.server_tabs.next();
let mut network = test_network(&app_arc);
if let SonarrSerdeable::SonarrHistoryWrapper(history) = network
let SonarrSerdeable::SonarrHistoryWrapper(history) = network
.handle_sonarr_event(SonarrEvent::GetEpisodeHistory(1))
.await
.unwrap()
{
async_server.assert_async().await;
assert_eq!(
app_arc
.lock()
.await
.data
.sonarr_data
.season_details_modal
.as_ref()
.unwrap()
.episode_details_modal
.as_ref()
.unwrap()
.episode_history
.items,
expected_history_items
);
assert!(
app_arc
.lock()
.await
.data
.sonarr_data
.season_details_modal
.as_ref()
.unwrap()
.episode_details_modal
.as_ref()
.unwrap()
.episode_history
.sort_asc
);
assert_eq!(history, response);
}
else {
panic!("Expected SonarrHistoryWrapper")
};
async_server.assert_async().await;
assert_eq!(
app_arc
.lock()
.await
.data
.sonarr_data
.season_details_modal
.as_ref()
.unwrap()
.episode_details_modal
.as_ref()
.unwrap()
.episode_history
.items,
expected_history_items
);
assert!(
app_arc
.lock()
.await
.data
.sonarr_data
.season_details_modal
.as_ref()
.unwrap()
.episode_details_modal
.as_ref()
.unwrap()
.episode_history
.sort_asc
);
assert_eq!(history, response);
}
#[tokio::test]
@@ -673,45 +678,46 @@ mod tests {
app_arc.lock().await.server_tabs.next();
let mut network = test_network(&app_arc);
if let SonarrSerdeable::SonarrHistoryWrapper(history) = network
let SonarrSerdeable::SonarrHistoryWrapper(history) = network
.handle_sonarr_event(SonarrEvent::GetEpisodeHistory(1))
.await
.unwrap()
{
async_server.assert_async().await;
assert_eq!(
app_arc
.lock()
.await
.data
.sonarr_data
.season_details_modal
.as_ref()
.unwrap()
.episode_details_modal
.as_ref()
.unwrap()
.episode_history
.items,
expected_history_items
);
assert!(
!app_arc
.lock()
.await
.data
.sonarr_data
.season_details_modal
.as_ref()
.unwrap()
.episode_details_modal
.as_ref()
.unwrap()
.episode_history
.sort_asc
);
assert_eq!(history, response);
}
else {
panic!("Expected SonarrHistoryWrapper")
};
async_server.assert_async().await;
assert_eq!(
app_arc
.lock()
.await
.data
.sonarr_data
.season_details_modal
.as_ref()
.unwrap()
.episode_details_modal
.as_ref()
.unwrap()
.episode_history
.items,
expected_history_items
);
assert!(
!app_arc
.lock()
.await
.data
.sonarr_data
.season_details_modal
.as_ref()
.unwrap()
.episode_details_modal
.as_ref()
.unwrap()
.episode_history
.sort_asc
);
assert_eq!(history, response);
}
#[tokio::test]
@@ -765,45 +771,46 @@ mod tests {
app_arc.lock().await.server_tabs.next();
let mut network = test_network(&app_arc);
if let SonarrSerdeable::SonarrHistoryWrapper(history) = network
let SonarrSerdeable::SonarrHistoryWrapper(history) = network
.handle_sonarr_event(SonarrEvent::GetEpisodeHistory(1))
.await
.unwrap()
{
async_server.assert_async().await;
assert_eq!(
app_arc
.lock()
.await
.data
.sonarr_data
.season_details_modal
.as_ref()
.unwrap()
.episode_details_modal
.as_ref()
.unwrap()
.episode_history
.items,
expected_history_items
);
assert!(
!app_arc
.lock()
.await
.data
.sonarr_data
.season_details_modal
.as_ref()
.unwrap()
.episode_details_modal
.as_ref()
.unwrap()
.episode_history
.sort_asc
);
assert_eq!(history, response);
}
else {
panic!("Expected SonarrHistoryWrapper")
};
async_server.assert_async().await;
assert_eq!(
app_arc
.lock()
.await
.data
.sonarr_data
.season_details_modal
.as_ref()
.unwrap()
.episode_details_modal
.as_ref()
.unwrap()
.episode_history
.items,
expected_history_items
);
assert!(
!app_arc
.lock()
.await
.data
.sonarr_data
.season_details_modal
.as_ref()
.unwrap()
.episode_details_modal
.as_ref()
.unwrap()
.episode_history
.sort_asc
);
assert_eq!(history, response);
}
#[tokio::test]
@@ -827,44 +834,30 @@ mod tests {
app_arc.lock().await.server_tabs.next();
let mut network = test_network(&app_arc);
if let SonarrSerdeable::Episode(episode) = network
let SonarrSerdeable::Episode(episode) = network
.handle_sonarr_event(SonarrEvent::GetEpisodeDetails(1))
.await
.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_eq!(
app_arc
.lock()
.await
.data
.sonarr_data
.season_details_modal
.as_ref()
.unwrap()
.episode_details_modal
.as_ref()
.unwrap()
.episode_details_tabs
.get_active_route(),
ActiveSonarrBlock::EpisodeHistory.into()
);
assert_eq!(episode, response);
let app = app_arc.lock().await;
let episode_details_modal = app
else {
panic!("Expected Episode")
};
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_eq!(
app_arc
.lock()
.await
.data
.sonarr_data
.season_details_modal
@@ -872,52 +865,67 @@ mod tests {
.unwrap()
.episode_details_modal
.as_ref()
.unwrap();
assert_str_eq!(
episode_details_modal.episode_details.get_text(),
formatdoc!(
"Title: Something cool
Season: 1
Episode Number: 1
Air Date: 2024-02-10 07:28:45 UTC
Status: Downloaded
Description: Okay so this one time at band camp..."
)
);
assert_str_eq!(
episode_details_modal.file_details,
formatdoc!(
"Relative Path: /season 1/episode 1.mkv
Absolute Path: /nfs/tv/series/season 1/episode 1.mkv
Size: 3.30 GB
Language: English
Date Added: 2024-02-10 07:28:45 UTC"
)
);
assert_str_eq!(
episode_details_modal.audio_details,
formatdoc!(
"Bitrate: 0
Channels: 7.1
Codec: AAC
Languages: eng
Stream Count: 1"
)
);
assert_str_eq!(
episode_details_modal.video_details,
formatdoc!(
"Bit Depth: 10
Bitrate: 0
Codec: x265
FPS: 23.976
Resolution: 1920x1080
Scan Type: Progressive
Runtime: 23:51
Subtitles: English"
)
);
}
.unwrap()
.episode_details_tabs
.get_active_route(),
ActiveSonarrBlock::EpisodeHistory.into()
);
assert_eq!(episode, response);
let app = app_arc.lock().await;
let episode_details_modal = app
.data
.sonarr_data
.season_details_modal
.as_ref()
.unwrap()
.episode_details_modal
.as_ref()
.unwrap();
assert_str_eq!(
episode_details_modal.episode_details.get_text(),
formatdoc!(
"Title: Something cool
Season: 1
Episode Number: 1
Air Date: 2024-02-10 07:28:45 UTC
Status: Downloaded
Description: Okay so this one time at band camp..."
)
);
assert_str_eq!(
episode_details_modal.file_details,
formatdoc!(
"Relative Path: /season 1/episode 1.mkv
Absolute Path: /nfs/tv/series/season 1/episode 1.mkv
Size: 3.30 GB
Language: English
Date Added: 2024-02-10 07:28:45 UTC"
)
);
assert_str_eq!(
episode_details_modal.audio_details,
formatdoc!(
"Bitrate: 0
Channels: 7.1
Codec: AAC
Languages: eng
Stream Count: 1"
)
);
assert_str_eq!(
episode_details_modal.video_details,
formatdoc!(
"Bit Depth: 10
Bitrate: 0
Codec: x265
FPS: 23.976
Resolution: 1920x1080
Scan Type: Progressive
Runtime: 23:51
Subtitles: English"
)
);
}
#[tokio::test]
@@ -938,81 +946,82 @@ mod tests {
app_arc.lock().await.server_tabs.next();
let mut network = test_network(&app_arc);
if let SonarrSerdeable::Episode(episode) = network
let SonarrSerdeable::Episode(episode) = network
.handle_sonarr_event(SonarrEvent::GetEpisodeDetails(1))
.await
.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_eq!(episode, response);
let app = app_arc.lock().await;
let episode_details_modal = app
else {
panic!("Expected Episode")
};
async_server.assert_async().await;
assert!(
app_arc
.lock()
.await
.data
.sonarr_data
.season_details_modal
.as_ref()
.unwrap()
.episode_details_modal
.as_ref()
.unwrap();
assert_str_eq!(
episode_details_modal.episode_details.get_text(),
formatdoc!(
"Title: Something cool
Season: 1
Episode Number: 1
Air Date: 2024-02-10 07:28:45 UTC
Status: Downloaded
Description: Okay so this one time at band camp..."
)
);
assert_str_eq!(
episode_details_modal.file_details,
formatdoc!(
"Relative Path: /season 1/episode 1.mkv
Absolute Path: /nfs/tv/series/season 1/episode 1.mkv
Size: 3.30 GB
Language: English
Date Added: 2024-02-10 07:28:45 UTC"
)
);
assert_str_eq!(
episode_details_modal.audio_details,
formatdoc!(
"Bitrate: 0
Channels: 7.1
Codec: AAC
Languages: eng
Stream Count: 1"
)
);
assert_str_eq!(
episode_details_modal.video_details,
formatdoc!(
"Bit Depth: 10
Bitrate: 0
Codec: x265
FPS: 23.976
Resolution: 1920x1080
Scan Type: Progressive
Runtime: 23:51
Subtitles: English"
)
);
}
.is_some()
);
assert_eq!(episode, response);
let app = app_arc.lock().await;
let episode_details_modal = app
.data
.sonarr_data
.season_details_modal
.as_ref()
.unwrap()
.episode_details_modal
.as_ref()
.unwrap();
assert_str_eq!(
episode_details_modal.episode_details.get_text(),
formatdoc!(
"Title: Something cool
Season: 1
Episode Number: 1
Air Date: 2024-02-10 07:28:45 UTC
Status: Downloaded
Description: Okay so this one time at band camp..."
)
);
assert_str_eq!(
episode_details_modal.file_details,
formatdoc!(
"Relative Path: /season 1/episode 1.mkv
Absolute Path: /nfs/tv/series/season 1/episode 1.mkv
Size: 3.30 GB
Language: English
Date Added: 2024-02-10 07:28:45 UTC"
)
);
assert_str_eq!(
episode_details_modal.audio_details,
formatdoc!(
"Bitrate: 0
Channels: 7.1
Codec: AAC
Languages: eng
Stream Count: 1"
)
);
assert_str_eq!(
episode_details_modal.video_details,
formatdoc!(
"Bit Depth: 10
Bitrate: 0
Codec: x265
FPS: 23.976
Resolution: 1920x1080
Scan Type: Progressive
Runtime: 23:51
Subtitles: English"
)
);
}
#[tokio::test]
@@ -1027,14 +1036,15 @@ mod tests {
app_arc.lock().await.server_tabs.next();
let mut network = test_network(&app_arc);
if let SonarrSerdeable::Episode(episode) = network
let SonarrSerdeable::Episode(episode) = network
.handle_sonarr_event(SonarrEvent::GetEpisodeDetails(1))
.await
.unwrap()
{
async_server.assert_async().await;
assert_eq!(episode, response);
}
else {
panic!("Expected Episode")
};
async_server.assert_async().await;
assert_eq!(episode, response);
}
#[tokio::test]
@@ -1092,30 +1102,31 @@ mod tests {
app_arc.lock().await.server_tabs.next();
let mut network = test_network(&app_arc);
if let SonarrSerdeable::Releases(releases_vec) = network
let SonarrSerdeable::Releases(releases_vec) = network
.handle_sonarr_event(SonarrEvent::GetEpisodeReleases(1))
.await
.unwrap()
{
async_server.assert_async().await;
assert_eq!(
app_arc
.lock()
.await
.data
.sonarr_data
.season_details_modal
.as_ref()
.unwrap()
.episode_details_modal
.as_ref()
.unwrap()
.episode_releases
.items,
vec![release()]
);
assert_eq!(releases_vec, vec![release()]);
}
else {
panic!("Expected Releases")
};
async_server.assert_async().await;
assert_eq!(
app_arc
.lock()
.await
.data
.sonarr_data
.season_details_modal
.as_ref()
.unwrap()
.episode_details_modal
.as_ref()
.unwrap()
.episode_releases
.items,
vec![release()]
);
assert_eq!(releases_vec, vec![release()]);
}
#[tokio::test]
@@ -1146,30 +1157,31 @@ mod tests {
app_arc.lock().await.server_tabs.next();
let mut network = test_network(&app_arc);
if let SonarrSerdeable::Releases(releases_vec) = network
let SonarrSerdeable::Releases(releases_vec) = network
.handle_sonarr_event(SonarrEvent::GetEpisodeReleases(1))
.await
.unwrap()
{
async_server.assert_async().await;
assert_eq!(
app_arc
.lock()
.await
.data
.sonarr_data
.season_details_modal
.as_ref()
.unwrap()
.episode_details_modal
.as_ref()
.unwrap()
.episode_releases
.items,
vec![release()]
);
assert_eq!(releases_vec, vec![release()]);
}
else {
panic!("Expected Releases")
};
async_server.assert_async().await;
assert_eq!(
app_arc
.lock()
.await
.data
.sonarr_data
.season_details_modal
.as_ref()
.unwrap()
.episode_details_modal
.as_ref()
.unwrap()
.episode_releases
.items,
vec![release()]
);
assert_eq!(releases_vec, vec![release()]);
}
#[tokio::test]
src/network/sonarr_network/library/seasons/sonarr_seasons_network_tests.rs
+90 -87
View File
@@ -136,27 +136,28 @@ mod tests {
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
if let SonarrSerdeable::Releases(releases_vec) = network
let SonarrSerdeable::Releases(releases_vec) = network
.handle_sonarr_event(SonarrEvent::GetSeasonReleases((1, 1)))
.await
.unwrap()
{
mock.assert_async().await;
assert_eq!(
app
.lock()
.await
.data
.sonarr_data
.season_details_modal
.as_ref()
.unwrap()
.season_releases
.items,
vec![expected_filtered_sonarr_release]
);
assert_eq!(releases_vec, expected_raw_sonarr_releases);
}
else {
panic!("Expected Releases")
};
mock.assert_async().await;
assert_eq!(
app
.lock()
.await
.data
.sonarr_data
.season_details_modal
.as_ref()
.unwrap()
.season_releases
.items,
vec![expected_filtered_sonarr_release]
);
assert_eq!(releases_vec, expected_raw_sonarr_releases);
}
#[tokio::test]
@@ -319,39 +320,40 @@ mod tests {
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
if let SonarrSerdeable::SonarrHistoryItems(history) = network
let SonarrSerdeable::SonarrHistoryItems(history) = network
.handle_sonarr_event(SonarrEvent::GetSeasonHistory((1, 1)))
.await
.unwrap()
{
mock.assert_async().await;
assert_eq!(
app
.lock()
.await
.data
.sonarr_data
.season_details_modal
.as_ref()
.unwrap()
.season_history
.items,
expected_history_items
);
assert!(
app
.lock()
.await
.data
.sonarr_data
.season_details_modal
.as_ref()
.unwrap()
.season_history
.sort_asc
);
assert_eq!(history, response);
}
else {
panic!("Expected SonarrHistoryItems")
};
mock.assert_async().await;
assert_eq!(
app
.lock()
.await
.data
.sonarr_data
.season_details_modal
.as_ref()
.unwrap()
.season_history
.items,
expected_history_items
);
assert!(
app
.lock()
.await
.data
.sonarr_data
.season_details_modal
.as_ref()
.unwrap()
.season_history
.sort_asc
);
assert_eq!(history, response);
}
#[tokio::test]
@@ -419,48 +421,49 @@ mod tests {
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
if let SonarrSerdeable::SonarrHistoryItems(history) = network
let SonarrSerdeable::SonarrHistoryItems(history) = network
.handle_sonarr_event(SonarrEvent::GetSeasonHistory((1, 1)))
.await
.unwrap()
{
mock.assert_async().await;
assert!(
app
.lock()
.await
.data
.sonarr_data
.season_details_modal
.is_some()
);
assert_eq!(
app
.lock()
.await
.data
.sonarr_data
.season_details_modal
.as_ref()
.unwrap()
.season_history
.items,
expected_history_items
);
assert!(
!app
.lock()
.await
.data
.sonarr_data
.season_details_modal
.as_ref()
.unwrap()
.season_history
.sort_asc
);
assert_eq!(history, response);
}
else {
panic!("Expected SonarrHistoryItems")
};
mock.assert_async().await;
assert!(
app
.lock()
.await
.data
.sonarr_data
.season_details_modal
.is_some()
);
assert_eq!(
app
.lock()
.await
.data
.sonarr_data
.season_details_modal
.as_ref()
.unwrap()
.season_history
.items,
expected_history_items
);
assert!(
!app
.lock()
.await
.data
.sonarr_data
.season_details_modal
.as_ref()
.unwrap()
.season_history
.sort_asc
);
assert_eq!(history, response);
}
#[tokio::test]
src/network/sonarr_network/library/series/sonarr_series_network_tests.rs
+133 -127
View File
@@ -409,14 +409,15 @@ mod tests {
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
if let SonarrSerdeable::Series(series) = network
let SonarrSerdeable::Series(series) = network
.handle_sonarr_event(SonarrEvent::GetSeriesDetails(1))
.await
.unwrap()
{
async_server.assert_async().await;
assert_eq!(series, expected_series);
}
else {
panic!("Expected Series")
};
async_server.assert_async().await;
assert_eq!(series, expected_series);
}
#[rstest]
@@ -500,38 +501,39 @@ mod tests {
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
if let SonarrSerdeable::SonarrHistoryItems(history_items) = network
let SonarrSerdeable::SonarrHistoryItems(history_items) = network
.handle_sonarr_event(SonarrEvent::GetSeriesHistory(1))
.await
.unwrap()
{
async_server.assert_async().await;
assert!(app.lock().await.data.sonarr_data.series_history.is_some());
assert_eq!(
app
.lock()
.await
.data
.sonarr_data
.series_history
.as_ref()
.unwrap()
.items,
expected_history_items
);
assert!(
app
.lock()
.await
.data
.sonarr_data
.series_history
.as_ref()
.unwrap()
.sort_asc
);
assert_eq!(history_items, response);
}
else {
panic!("Expected SonarrHistoryItems")
};
async_server.assert_async().await;
assert!(app.lock().await.data.sonarr_data.series_history.is_some());
assert_eq!(
app
.lock()
.await
.data
.sonarr_data
.series_history
.as_ref()
.unwrap()
.items,
expected_history_items
);
assert!(
app
.lock()
.await
.data
.sonarr_data
.series_history
.as_ref()
.unwrap()
.sort_asc
);
assert_eq!(history_items, response);
}
#[tokio::test]
@@ -592,38 +594,39 @@ mod tests {
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
if let SonarrSerdeable::SonarrHistoryItems(history_items) = network
let SonarrSerdeable::SonarrHistoryItems(history_items) = network
.handle_sonarr_event(SonarrEvent::GetSeriesHistory(1))
.await
.unwrap()
{
async_server.assert_async().await;
assert!(app.lock().await.data.sonarr_data.series_history.is_some());
assert_eq!(
app
.lock()
.await
.data
.sonarr_data
.series_history
.as_ref()
.unwrap()
.items,
expected_history_items
);
assert!(
!app
.lock()
.await
.data
.sonarr_data
.series_history
.as_ref()
.unwrap()
.sort_asc
);
assert_eq!(history_items, response);
}
else {
panic!("Expected SonarrHistoryItems")
};
async_server.assert_async().await;
assert!(app.lock().await.data.sonarr_data.series_history.is_some());
assert_eq!(
app
.lock()
.await
.data
.sonarr_data
.series_history
.as_ref()
.unwrap()
.items,
expected_history_items
);
assert!(
!app
.lock()
.await
.data
.sonarr_data
.series_history
.as_ref()
.unwrap()
.sort_asc
);
assert_eq!(history_items, response);
}
#[tokio::test]
@@ -690,37 +693,38 @@ mod tests {
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
if let SonarrSerdeable::SonarrHistoryItems(history_items) = network
let SonarrSerdeable::SonarrHistoryItems(history_items) = network
.handle_sonarr_event(SonarrEvent::GetSeriesHistory(1))
.await
.unwrap()
{
async_server.assert_async().await;
assert!(app.lock().await.data.sonarr_data.series_history.is_some());
assert!(
app
.lock()
.await
.data
.sonarr_data
.series_history
.as_ref()
.unwrap()
.is_empty()
);
assert!(
app
.lock()
.await
.data
.sonarr_data
.series_history
.as_ref()
.unwrap()
.sort_asc
);
assert_eq!(history_items, response);
}
else {
panic!("Expected SonarrHistoryItems")
};
async_server.assert_async().await;
assert!(app.lock().await.data.sonarr_data.series_history.is_some());
assert!(
app
.lock()
.await
.data
.sonarr_data
.series_history
.as_ref()
.unwrap()
.is_empty()
);
assert!(
app
.lock()
.await
.data
.sonarr_data
.series_history
.as_ref()
.unwrap()
.sort_asc
);
assert_eq!(history_items, response);
}
#[rstest]
@@ -784,19 +788,20 @@ mod tests {
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
if let SonarrSerdeable::SeriesVec(series) = network
let SonarrSerdeable::SeriesVec(series) = network
.handle_sonarr_event(SonarrEvent::ListSeries)
.await
.unwrap()
{
async_server.assert_async().await;
assert_eq!(
app.lock().await.data.sonarr_data.series.items,
expected_sorted_series
);
assert!(app.lock().await.data.sonarr_data.series.sort_asc);
assert_eq!(series, expected_series);
}
else {
panic!("Expected SeriesVec")
};
async_server.assert_async().await;
assert_eq!(
app.lock().await.data.sonarr_data.series.items,
expected_sorted_series
);
assert!(app.lock().await.data.sonarr_data.series.sort_asc);
assert_eq!(series, expected_series);
}
#[tokio::test]
@@ -872,35 +877,36 @@ mod tests {
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
if let SonarrSerdeable::AddSeriesSearchResults(add_series_search_results) = network
let SonarrSerdeable::AddSeriesSearchResults(add_series_search_results) = network
.handle_sonarr_event(SonarrEvent::SearchNewSeries("test term".into()))
.await
.unwrap()
{
async_server.assert_async().await;
assert!(
app
.lock()
.await
.data
.sonarr_data
.add_searched_series
.is_some()
);
assert_eq!(
app
.lock()
.await
.data
.sonarr_data
.add_searched_series
.as_ref()
.unwrap()
.items,
vec![add_series_search_result()]
);
assert_eq!(add_series_search_results, vec![add_series_search_result()]);
}
else {
panic!("Expected AddSeriesSearchResults")
};
async_server.assert_async().await;
assert!(
app
.lock()
.await
.data
.sonarr_data
.add_searched_series
.is_some()
);
assert_eq!(
app
.lock()
.await
.data
.sonarr_data
.add_searched_series
.as_ref()
.unwrap()
.items,
vec![add_series_search_result()]
);
assert_eq!(add_series_search_results, vec![add_series_search_result()]);
}
#[tokio::test]
src/network/sonarr_network/root_folders/sonarr_root_folders_network_tests.rs
+10 -9
View File
@@ -71,17 +71,18 @@ mod tests {
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
if let SonarrSerdeable::RootFolders(root_folders) = network
let SonarrSerdeable::RootFolders(root_folders) = network
.handle_sonarr_event(SonarrEvent::GetRootFolders)
.await
.unwrap()
{
mock.assert_async().await;
assert_eq!(
app.lock().await.data.sonarr_data.root_folders.items,
vec![root_folder()]
);
assert_eq!(root_folders, response);
}
else {
panic!("Expected RootFolders")
};
mock.assert_async().await;
assert_eq!(
app.lock().await.data.sonarr_data.root_folders.items,
vec![root_folder()]
);
assert_eq!(root_folders, response);
}
}
src/network/sonarr_network/sonarr_network_tests.rs
+8 -4
View File
@@ -212,8 +212,9 @@ mod test {
mock.assert_async().await;
let SonarrSerdeable::Tag(tag) = result.unwrap() else {
panic!("Expected Tag variant");
panic!("Expected Tag");
};
assert_eq!(tag, expected);
assert_eq!(
app.lock().await.data.sonarr_data.tags_map,
@@ -278,8 +279,9 @@ mod test {
mock.assert_async().await;
let SonarrSerdeable::LanguageProfiles(language_profiles) = result.unwrap() else {
panic!("Expected the LanguageProfiles variant")
panic!("Expected LanguageProfiles")
};
assert_eq!(
app.lock().await.data.sonarr_data.language_profiles_map,
BiMap::from_iter([(2222i64, "English".to_owned())])
@@ -309,8 +311,9 @@ mod test {
mock.assert_async().await;
let SonarrSerdeable::QualityProfiles(quality_profiles) = result.unwrap() else {
panic!("Expected the QualityProfiles variant")
panic!("Expected QualityProfiles")
};
assert_eq!(
app.lock().await.data.sonarr_data.quality_profile_map,
BiMap::from_iter([(2222i64, "HD - 1080p".to_owned())])
@@ -337,8 +340,9 @@ mod test {
mock.assert_async().await;
let SonarrSerdeable::Tags(tags) = result.unwrap() else {
panic!("Expected the Tag variant")
panic!("Expected Tags")
};
mock.assert_async().await;
assert_eq!(
app.lock().await.data.sonarr_data.tags_map,
src/network/sonarr_network/system/sonarr_system_network_tests.rs
+95 -86
View File
@@ -33,14 +33,15 @@ mod tests {
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
if let SonarrSerdeable::HostConfig(host_config) = network
let SonarrSerdeable::HostConfig(host_config) = network
.handle_sonarr_event(SonarrEvent::GetHostConfig)
.await
.unwrap()
{
mock.assert_async().await;
assert_eq!(host_config, response);
}
else {
panic!("Expected HostConfig")
};
mock.assert_async().await;
assert_eq!(host_config, response);
}
#[tokio::test]
@@ -84,26 +85,27 @@ mod tests {
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
if let SonarrSerdeable::LogResponse(logs) = network
let SonarrSerdeable::LogResponse(logs) = network
.handle_sonarr_event(SonarrEvent::GetLogs(500))
.await
.unwrap()
{
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_eq!(logs, response);
}
else {
panic!("Expected LogResponse")
};
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_eq!(logs, response);
}
#[tokio::test]
@@ -134,18 +136,19 @@ mod tests {
},
];
if let SonarrSerdeable::DiskSpaces(disk_space) = network
let SonarrSerdeable::DiskSpaces(disk_space) = network
.handle_sonarr_event(SonarrEvent::GetDiskSpace)
.await
.unwrap()
{
mock.assert_async().await;
assert_eq!(
app.lock().await.data.sonarr_data.disk_space_vec,
disk_space_vec
);
assert_eq!(disk_space, disk_space_vec);
}
else {
panic!("Expected DiskSpaces")
};
mock.assert_async().await;
assert_eq!(
app.lock().await.data.sonarr_data.disk_space_vec,
disk_space_vec
);
assert_eq!(disk_space, disk_space_vec);
}
#[tokio::test]
@@ -180,18 +183,19 @@ mod tests {
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
if let SonarrSerdeable::QueueEvents(events) = network
let SonarrSerdeable::QueueEvents(events) = network
.handle_sonarr_event(SonarrEvent::GetQueuedEvents)
.await
.unwrap()
{
mock.assert_async().await;
assert_eq!(
app.lock().await.data.sonarr_data.queued_events.items,
vec![expected_event]
);
assert_eq!(events, response);
}
else {
panic!("Expected QueueEvents")
};
mock.assert_async().await;
assert_eq!(
app.lock().await.data.sonarr_data.queued_events.items,
vec![expected_event]
);
assert_eq!(events, response);
}
#[tokio::test]
@@ -213,14 +217,15 @@ mod tests {
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
if let SonarrSerdeable::SecurityConfig(security_config) = network
let SonarrSerdeable::SecurityConfig(security_config) = network
.handle_sonarr_event(SonarrEvent::GetSecurityConfig)
.await
.unwrap()
{
mock.assert_async().await;
assert_eq!(security_config, response);
}
else {
panic!("Expected SecurityConfig")
};
mock.assert_async().await;
assert_eq!(security_config, response);
}
#[tokio::test]
@@ -236,22 +241,23 @@ mod tests {
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
let SonarrSerdeable::SystemStatus(status) = network
.handle_sonarr_event(SonarrEvent::GetStatus)
.await
.unwrap()
{
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 {
version: "v1".to_owned(),
start_time: date_time
}
);
}
else {
panic!("Expected SystemStatus")
};
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 {
version: "v1".to_owned(),
start_time: date_time
}
);
}
#[tokio::test]
@@ -295,18 +301,19 @@ mod tests {
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
if let SonarrSerdeable::Tasks(tasks) = network
let SonarrSerdeable::Tasks(tasks) = network
.handle_sonarr_event(SonarrEvent::GetTasks)
.await
.unwrap()
{
mock.assert_async().await;
assert_eq!(
app.lock().await.data.sonarr_data.tasks.items,
expected_tasks
);
assert_eq!(tasks, response);
}
else {
panic!("Expected Tasks")
};
mock.assert_async().await;
assert_eq!(
app.lock().await.data.sonarr_data.tasks.items,
expected_tasks
);
assert_eq!(tasks, response);
}
#[tokio::test]
@@ -385,25 +392,26 @@ mod tests {
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
if let SonarrSerdeable::Updates(updates) = network
let SonarrSerdeable::Updates(updates) = network
.handle_sonarr_event(SonarrEvent::GetUpdates)
.await
.unwrap()
{
mock.assert_async().await;
let actual_text = app.lock().await.data.sonarr_data.updates.get_text();
let expected = expected_text.get_text();
else {
panic!("Expected Updates")
};
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();
// 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);
}
assert_eq!(
actual_trimmed, expected_trimmed,
"Updates text mismatch (after trimming trailing whitespace)"
);
assert_eq!(updates, response);
}
#[tokio::test]
@@ -431,15 +439,16 @@ mod tests {
app.lock().await.server_tabs.next();
let mut network = test_network(&app);
if let SonarrSerdeable::Value(value) = network
let SonarrSerdeable::Value(value) = network
.handle_sonarr_event(SonarrEvent::StartTask(
SonarrTaskName::ApplicationUpdateCheck,
))
.await
.unwrap()
{
mock.assert_async().await;
assert_eq!(value, response);
}
else {
panic!("Expected Value")
};
mock.assert_async().await;
assert_eq!(value, response);
}
}