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

src/network/radarr_network/blocklist/radarr_blocklist_network_tests.rs

@@ -195,19 +195,20 @@ mod tests {
     }
     let mut network = test_network(&app);
 
-    if let RadarrSerdeable::BlocklistResponse(blocklist) = network
+    let RadarrSerdeable::BlocklistResponse(blocklist) = network
       .handle_radarr_event(RadarrEvent::GetBlocklist)
       .await
       .unwrap()
-    {
-      mock.assert_async().await;
-      assert_eq!(
-        app.lock().await.data.radarr_data.blocklist.items,
-        expected_blocklist
-      );
-      assert!(app.lock().await.data.radarr_data.blocklist.sort_asc);
-      assert_eq!(blocklist, response);
-    }
+    else {
+      panic!("Expected BlocklistResponse")
+    };
+    mock.assert_async().await;
+    assert_eq!(
+      app.lock().await.data.radarr_data.blocklist.items,
+      expected_blocklist
+    );
+    assert!(app.lock().await.data.radarr_data.blocklist.sort_asc);
+    assert_eq!(blocklist, response);
   }
 
   #[tokio::test]

src/network/radarr_network/collections/radarr_collections_network_tests.rs

@@ -277,19 +277,20 @@ mod tests {
     }
     let mut network = test_network(&app);
 
-    if let RadarrSerdeable::Collections(collections) = network
+    let RadarrSerdeable::Collections(collections) = network
       .handle_radarr_event(RadarrEvent::GetCollections)
       .await
       .unwrap()
-    {
-      mock.assert_async().await;
-      assert_eq!(
-        app.lock().await.data.radarr_data.collections.items,
-        expected_collections
-      );
-      assert!(app.lock().await.data.radarr_data.collections.sort_asc);
-      assert_eq!(collections, response);
-    }
+    else {
+      panic!("Expected Collections")
+    };
+    mock.assert_async().await;
+    assert_eq!(
+      app.lock().await.data.radarr_data.collections.items,
+      expected_collections
+    );
+    assert!(app.lock().await.data.radarr_data.collections.sort_asc);
+    assert_eq!(collections, response);
   }
 
   #[tokio::test]

src/network/radarr_network/downloads/radarr_downloads_network_tests.rs

@@ -48,18 +48,19 @@ mod tests {
       .await;
     let mut network = test_network(&app);
 
-    if let RadarrSerdeable::DownloadsResponse(downloads) = network
+    let RadarrSerdeable::DownloadsResponse(downloads) = network
       .handle_radarr_event(RadarrEvent::GetDownloads(500))
       .await
       .unwrap()
-    {
-      mock.assert_async().await;
-      pretty_assertions::assert_eq!(
-        app.lock().await.data.radarr_data.downloads.items,
-        downloads_response().records
-      );
-      pretty_assertions::assert_eq!(downloads, response);
-    }
+    else {
+      panic!("Expected DownloadsResponse")
+    };
+    mock.assert_async().await;
+    pretty_assertions::assert_eq!(
+      app.lock().await.data.radarr_data.downloads.items,
+      downloads_response().records
+    );
+    pretty_assertions::assert_eq!(downloads, response);
   }
 
   #[tokio::test]

src/network/radarr_network/indexers/radarr_indexers_network_tests.rs

@@ -623,18 +623,19 @@ mod tests {
       .await;
     let mut network = test_network(&app);
 
-    if let RadarrSerdeable::Indexers(indexers) = network
+    let RadarrSerdeable::Indexers(indexers) = network
       .handle_radarr_event(RadarrEvent::GetIndexers)
       .await
       .unwrap()
-    {
-      async_server.assert_async().await;
-      assert_eq!(
-        app.lock().await.data.radarr_data.indexers.items,
-        vec![indexer()]
-      );
-      assert_eq!(indexers, response);
-    }
+    else {
+      panic!("Expected Indexers")
+    };
+    async_server.assert_async().await;
+    assert_eq!(
+      app.lock().await.data.radarr_data.indexers.items,
+      vec![indexer()]
+    );
+    assert_eq!(indexers, response);
   }
 
   #[tokio::test]
@@ -658,18 +659,19 @@ mod tests {
       .await;
     let mut network = test_network(&app);
 
-    if let RadarrSerdeable::IndexerSettings(settings) = network
+    let RadarrSerdeable::IndexerSettings(settings) = network
       .handle_radarr_event(RadarrEvent::GetAllIndexerSettings)
       .await
       .unwrap()
-    {
-      async_server.assert_async().await;
-      assert_eq!(
-        app.lock().await.data.radarr_data.indexer_settings,
-        Some(indexer_settings())
-      );
-      assert_eq!(settings, response);
-    }
+    else {
+      panic!("Expected IndexerSettings")
+    };
+    async_server.assert_async().await;
+    assert_eq!(
+      app.lock().await.data.radarr_data.indexer_settings,
+      Some(indexer_settings())
+    );
+    assert_eq!(settings, response);
   }
 
   #[tokio::test]
@@ -755,19 +757,20 @@ mod tests {
       .await;
     let mut network = test_network(&app);
 
-    if let RadarrSerdeable::Value(value) = network
+    let RadarrSerdeable::Value(value) = network
       .handle_radarr_event(RadarrEvent::TestIndexer(1))
       .await
       .unwrap()
-    {
-      async_details_server.assert_async().await;
-      async_test_server.assert_async().await;
-      assert_eq!(
-        app.lock().await.data.radarr_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.radarr_data.indexer_test_errors,
+      Some("\"test failure\"".to_owned())
+    );
+    assert_eq!(value, response_json);
   }
 
   #[tokio::test]
@@ -812,19 +815,20 @@ mod tests {
       .await;
     let mut network = test_network(&app);
 
-    if let RadarrSerdeable::Value(value) = network
+    let RadarrSerdeable::Value(value) = network
       .handle_radarr_event(RadarrEvent::TestIndexer(1))
       .await
       .unwrap()
-    {
-      async_details_server.assert_async().await;
-      async_test_server.assert_async().await;
-      assert_eq!(
-        app.lock().await.data.radarr_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.radarr_data.indexer_test_errors,
+      Some(String::new())
+    );
+    assert_eq!(value, json!({}));
   }
 
   #[tokio::test]
@@ -890,34 +894,35 @@ mod tests {
       .set_items(indexers);
     let mut network = test_network(&app);
 
-    if let RadarrSerdeable::IndexerTestResults(results) = network
+    let RadarrSerdeable::IndexerTestResults(results) = network
       .handle_radarr_event(RadarrEvent::TestAllIndexers)
       .await
       .unwrap()
-    {
-      async_server.assert_async().await;
-      assert!(
-        app
-          .lock()
-          .await
-          .data
-          .radarr_data
-          .indexer_test_all_results
-          .is_some()
-      );
-      assert_eq!(
-        app
-          .lock()
-          .await
-          .data
-          .radarr_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
+        .radarr_data
+        .indexer_test_all_results
+        .is_some()
+    );
+    assert_eq!(
+      app
+        .lock()
+        .await
+        .data
+        .radarr_data
+        .indexer_test_all_results
+        .as_ref()
+        .unwrap()
+        .items,
+      indexer_test_results_modal_items
+    );
+    assert_eq!(results, response);
   }
 }

src/network/radarr_network/library/radarr_library_network_tests.rs

@@ -382,19 +382,20 @@ mod tests {
     app_arc.lock().await.data.radarr_data.movie_details_modal = Some(MovieDetailsModal::default());
     let mut network = test_network(&app_arc);
 
-    if let RadarrSerdeable::Credits(credits) = network
+    let RadarrSerdeable::Credits(credits) = network
       .handle_radarr_event(RadarrEvent::GetMovieCredits(1))
       .await
       .unwrap()
-    {
-      let app = app_arc.lock().await;
-      let movie_details_modal = app.data.radarr_data.movie_details_modal.as_ref().unwrap();
+    else {
+      panic!("Expected Credits")
+    };
+    let app = app_arc.lock().await;
+    let movie_details_modal = app.data.radarr_data.movie_details_modal.as_ref().unwrap();
 
-      async_server.assert_async().await;
-      assert_eq!(movie_details_modal.movie_cast.items, vec![cast_credit()]);
-      assert_eq!(movie_details_modal.movie_crew.items, vec![crew_credit()]);
-      assert_eq!(credits, response);
-    }
+    async_server.assert_async().await;
+    assert_eq!(movie_details_modal.movie_cast.items, vec![cast_credit()]);
+    assert_eq!(movie_details_modal.movie_crew.items, vec![crew_credit()]);
+    assert_eq!(credits, response);
   }
 
   #[tokio::test]
@@ -570,77 +571,78 @@ mod tests {
       BiMap::from_iter([(2222, "HD - 1080p".to_owned())]);
     let mut network = test_network(&app_arc);
 
-    if let RadarrSerdeable::Movie(movie) = network
+    let RadarrSerdeable::Movie(movie) = network
       .handle_radarr_event(RadarrEvent::GetMovieDetails(1))
       .await
       .unwrap()
-    {
-      async_server.assert_async().await;
-      assert!(
-        app_arc
-          .lock()
-          .await
-          .data
-          .radarr_data
-          .movie_details_modal
-          .is_some()
-      );
-      assert_eq!(movie, response);
+    else {
+      panic!("Expected Movie")
+    };
+    async_server.assert_async().await;
+    assert!(
+      app_arc
+        .lock()
+        .await
+        .data
+        .radarr_data
+        .movie_details_modal
+        .is_some()
+    );
+    assert_eq!(movie, response);
 
-      let app = app_arc.lock().await;
-      let movie_details_modal = app.data.radarr_data.movie_details_modal.as_ref().unwrap();
-      assert_str_eq!(
-        movie_details_modal.movie_details.get_text(),
-        formatdoc!(
-          "Title: Test
-          Year: 2023
-          Runtime: 2h 0m
-          Rating: R
-          Collection: Test Collection
-          Status: Downloaded
-          Description: Blah blah blah
-          TMDB: 99%
-          IMDB: 9.9
-          Rotten Tomatoes: 
-          Quality Profile: HD - 1080p
-          Size: 3.30 GB
-          Path: /nfs/movies
-          Studio: 21st Century Alex
-          Genres: cool, family, fun"
-        )
-      );
-      assert_str_eq!(
-        movie_details_modal.file_details,
-        formatdoc!(
-          "Relative Path: Test.mkv
-        Absolute Path: /nfs/movies/Test.mkv
+    let app = app_arc.lock().await;
+    let movie_details_modal = app.data.radarr_data.movie_details_modal.as_ref().unwrap();
+    assert_str_eq!(
+      movie_details_modal.movie_details.get_text(),
+      formatdoc!(
+        "Title: Test
+        Year: 2023
+        Runtime: 2h 0m
+        Rating: R
+        Collection: Test Collection
+        Status: Downloaded
+        Description: Blah blah blah
+        TMDB: 99%
+        IMDB: 9.9
+        Rotten Tomatoes: 
+        Quality Profile: HD - 1080p
         Size: 3.30 GB
-        Date Added: 2022-12-30 07:37:56 UTC"
-        )
-      );
-      assert_str_eq!(
-        movie_details_modal.audio_details,
-        formatdoc!(
-          "Bitrate: 0
-        Channels: 7.1
-        Codec: AAC
-        Languages: eng
-        Stream Count: 1"
-        )
-      );
-      assert_str_eq!(
-        movie_details_modal.video_details,
-        formatdoc!(
-          "Bit Depth: 10
-        Bitrate: 0
-        Codec: x265
-        FPS: 23.976
-        Resolution: 1920x804
-        Scan Type: Progressive
-        Runtime: 2:00:00"
-        )
-      );
-    }
+        Path: /nfs/movies
+        Studio: 21st Century Alex
+        Genres: cool, family, fun"
+      )
+    );
+    assert_str_eq!(
+      movie_details_modal.file_details,
+      formatdoc!(
+        "Relative Path: Test.mkv
+      Absolute Path: /nfs/movies/Test.mkv
+      Size: 3.30 GB
+      Date Added: 2022-12-30 07:37:56 UTC"
+      )
+    );
+    assert_str_eq!(
+      movie_details_modal.audio_details,
+      formatdoc!(
+        "Bitrate: 0
+      Channels: 7.1
+      Codec: AAC
+      Languages: eng
+      Stream Count: 1"
+      )
+    );
+    assert_str_eq!(
+      movie_details_modal.video_details,
+      formatdoc!(
+        "Bit Depth: 10
+      Bitrate: 0
+      Codec: x265
+      FPS: 23.976
+      Resolution: 1920x804
+      Scan Type: Progressive
+      Runtime: 2:00:00"
+      )
+    );
   }
 
   #[tokio::test]
@@ -741,27 +743,28 @@ mod tests {
     app_arc.lock().await.data.radarr_data.movie_details_modal = Some(MovieDetailsModal::default());
     let mut network = test_network(&app_arc);
 
-    if let RadarrSerdeable::MovieHistoryItems(history) = network
+    let RadarrSerdeable::MovieHistoryItems(history) = network
       .handle_radarr_event(RadarrEvent::GetMovieHistory(1))
       .await
       .unwrap()
-    {
-      async_server.assert_async().await;
-      assert_eq!(
-        app_arc
-          .lock()
-          .await
-          .data
-          .radarr_data
-          .movie_details_modal
-          .as_ref()
-          .unwrap()
-          .movie_history
-          .items,
-        vec![movie_history_item()]
-      );
-      assert_eq!(history, response);
-    }
+    else {
+      panic!("Expected MovieHistoryItems")
+    };
+    async_server.assert_async().await;
+    assert_eq!(
+      app_arc
+        .lock()
+        .await
+        .data
+        .radarr_data
+        .movie_details_modal
+        .as_ref()
+        .unwrap()
+        .movie_history
+        .items,
+      vec![movie_history_item()]
+    );
+    assert_eq!(history, response);
   }
 
   #[tokio::test]
@@ -828,27 +831,28 @@ mod tests {
     app_arc.lock().await.data.radarr_data.movie_details_modal = Some(MovieDetailsModal::default());
     let mut network = test_network(&app_arc);
 
-    if let RadarrSerdeable::Releases(releases_vec) = network
+    let RadarrSerdeable::Releases(releases_vec) = network
       .handle_radarr_event(RadarrEvent::GetReleases(1))
       .await
       .unwrap()
-    {
-      async_server.assert_async().await;
-      assert_eq!(
-        app_arc
-          .lock()
-          .await
-          .data
-          .radarr_data
-          .movie_details_modal
-          .as_ref()
-          .unwrap()
-          .movie_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
+        .radarr_data
+        .movie_details_modal
+        .as_ref()
+        .unwrap()
+        .movie_releases
+        .items,
+      vec![release()]
+    );
+    assert_eq!(releases_vec, vec![release()]);
   }
 
   #[tokio::test]
@@ -928,35 +932,36 @@ mod tests {
       .await;
     let mut network = test_network(&app_arc);
 
-    if let RadarrSerdeable::AddMovieSearchResults(add_movie_search_results) = network
+    let RadarrSerdeable::AddMovieSearchResults(add_movie_search_results) = network
       .handle_radarr_event(RadarrEvent::SearchNewMovie("test term".into()))
       .await
       .unwrap()
-    {
-      async_server.assert_async().await;
-      assert!(
-        app_arc
-          .lock()
-          .await
-          .data
-          .radarr_data
-          .add_searched_movies
-          .is_some()
-      );
-      assert_eq!(
-        app_arc
-          .lock()
-          .await
-          .data
-          .radarr_data
-          .add_searched_movies
-          .as_ref()
-          .unwrap()
-          .items,
-        vec![add_movie_search_result()]
-      );
-      assert_eq!(add_movie_search_results, vec![add_movie_search_result()]);
-    }
+    else {
+      panic!("Expected AddMovieSearchResults")
+    };
+    async_server.assert_async().await;
+    assert!(
+      app_arc
+        .lock()
+        .await
+        .data
+        .radarr_data
+        .add_searched_movies
+        .is_some()
+    );
+    assert_eq!(
+      app_arc
+        .lock()
+        .await
+        .data
+        .radarr_data
+        .add_searched_movies
+        .as_ref()
+        .unwrap()
+        .items,
+      vec![add_movie_search_result()]
+    );
+    assert_eq!(add_movie_search_results, vec![add_movie_search_result()]);
   }
 
   #[tokio::test]

src/network/radarr_network/radarr_network_tests.rs

@@ -194,8 +194,9 @@ mod test {
     mock.assert_async().await;
 
     let RadarrSerdeable::QualityProfiles(quality_profiles) = result.unwrap() else {
-      panic!("Expected QualityProfiles variant");
+      panic!("Expected QualityProfiles");
     };
+
     assert_eq!(quality_profiles, expected);
     assert_eq!(
       app.lock().await.data.radarr_data.quality_profile_map,
@@ -225,8 +226,9 @@ mod test {
     mock.assert_async().await;
 
     let RadarrSerdeable::Tags(tags) = result.unwrap() else {
-      panic!("Expected Tags variant");
+      panic!("Expected Tags");
     };
+
     assert_eq!(tags, expected);
     assert_eq!(
       app.lock().await.data.radarr_data.tags_map,
@@ -259,8 +261,9 @@ mod test {
     mock.assert_async().await;
 
     let RadarrSerdeable::Tag(tag) = result.unwrap() else {
-      panic!("Expected Tag variant");
+      panic!("Expected Tag");
     };
+
     assert_eq!(tag, expected);
     assert_eq!(
       app.lock().await.data.radarr_data.tags_map,

src/network/radarr_network/root_folders/radarr_root_folders_network_tests.rs

@@ -65,17 +65,18 @@ mod tests {
       .await;
     let mut network = test_network(&app);
 
-    if let RadarrSerdeable::RootFolders(root_folders) = network
+    let RadarrSerdeable::RootFolders(root_folders) = network
       .handle_radarr_event(RadarrEvent::GetRootFolders)
       .await
       .unwrap()
-    {
-      mock.assert_async().await;
-      assert_eq!(
-        app.lock().await.data.radarr_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.radarr_data.root_folders.items,
+      vec![root_folder()]
+    );
+    assert_eq!(root_folders, response);
   }
 }

src/network/radarr_network/system/radarr_system_network_tests.rs

@@ -39,18 +39,19 @@ mod tests {
       },
     ];
 
-    if let RadarrSerdeable::DiskSpaces(disk_space) = network
+    let RadarrSerdeable::DiskSpaces(disk_space) = network
       .handle_radarr_event(RadarrEvent::GetDiskSpace)
       .await
       .unwrap()
-    {
-      mock.assert_async().await;
-      assert_eq!(
-        app.lock().await.data.radarr_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.radarr_data.disk_space_vec,
+      disk_space_vec
+    );
+    assert_eq!(disk_space, disk_space_vec);
   }
 
   #[tokio::test]
@@ -73,14 +74,15 @@ mod tests {
       .await;
     let mut network = test_network(&app);
 
-    if let RadarrSerdeable::HostConfig(host_config) = network
+    let RadarrSerdeable::HostConfig(host_config) = network
       .handle_radarr_event(RadarrEvent::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]
@@ -123,26 +125,27 @@ mod tests {
       .await;
     let mut network = test_network(&app);
 
-    if let RadarrSerdeable::LogResponse(logs) = network
+    let RadarrSerdeable::LogResponse(logs) = network
       .handle_radarr_event(RadarrEvent::GetLogs(500))
       .await
       .unwrap()
-    {
-      mock.assert_async().await;
-      assert_eq!(app.lock().await.data.radarr_data.logs.items, expected_logs);
-      assert!(
-        app
-          .lock()
-          .await
-          .data
-          .radarr_data
-          .logs
-          .current_selection()
-          .text
-          .contains("INFO")
-      );
-      assert_eq!(logs, response);
-    }
+    else {
+      panic!("Expected LogResponse")
+    };
+    mock.assert_async().await;
+    assert_eq!(app.lock().await.data.radarr_data.logs.items, expected_logs);
+    assert!(
+      app
+        .lock()
+        .await
+        .data
+        .radarr_data
+        .logs
+        .current_selection()
+        .text
+        .contains("INFO")
+    );
+    assert_eq!(logs, response);
   }
 
   #[tokio::test]
@@ -176,18 +179,19 @@ mod tests {
       .await;
     let mut network = test_network(&app);
 
-    if let RadarrSerdeable::QueueEvents(events) = network
+    let RadarrSerdeable::QueueEvents(events) = network
       .handle_radarr_event(RadarrEvent::GetQueuedEvents)
       .await
       .unwrap()
-    {
-      mock.assert_async().await;
-      assert_eq!(
-        app.lock().await.data.radarr_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.radarr_data.queued_events.items,
+      vec![expected_event]
+    );
+    assert_eq!(events, response);
   }
 
   #[tokio::test]
@@ -208,14 +212,15 @@ mod tests {
       .await;
     let mut network = test_network(&app);
 
-    if let RadarrSerdeable::SecurityConfig(security_config) = network
+    let RadarrSerdeable::SecurityConfig(security_config) = network
       .handle_radarr_event(RadarrEvent::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]
@@ -230,22 +235,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 RadarrSerdeable::SystemStatus(status) = network
+    let RadarrSerdeable::SystemStatus(status) = network
       .handle_radarr_event(RadarrEvent::GetStatus)
       .await
       .unwrap()
-    {
-      async_server.assert_async().await;
-      assert_str_eq!(app.lock().await.data.radarr_data.version, "v1");
-      assert_eq!(app.lock().await.data.radarr_data.start_time, date_time);
-      assert_eq!(
-        status,
-        SystemStatus {
-          version: "v1".to_owned(),
-          start_time: date_time
-        }
-      );
-    }
+    else {
+      panic!("Expected SystemStatus")
+    };
+    async_server.assert_async().await;
+    assert_str_eq!(app.lock().await.data.radarr_data.version, "v1");
+    assert_eq!(app.lock().await.data.radarr_data.start_time, date_time);
+    assert_eq!(
+      status,
+      SystemStatus {
+        version: "v1".to_owned(),
+        start_time: date_time
+      }
+    );
   }
 
   #[tokio::test]
@@ -323,18 +329,19 @@ mod tests {
       .await;
     let mut network = test_network(&app);
 
-    if let RadarrSerdeable::Updates(updates) = network
+    let RadarrSerdeable::Updates(updates) = network
       .handle_radarr_event(RadarrEvent::GetUpdates)
       .await
       .unwrap()
-    {
-      async_server.assert_async().await;
-      assert_str_eq!(
-        app.lock().await.data.radarr_data.updates.get_text(),
-        expected_text.get_text()
-      );
-      assert_eq!(updates, response);
-    }
+    else {
+      panic!("Expected Updates")
+    };
+    async_server.assert_async().await;
+    assert_str_eq!(
+      app.lock().await.data.radarr_data.updates.get_text(),
+      expected_text.get_text()
+    );
+    assert_eq!(updates, response);
   }
 
   #[tokio::test]
@@ -381,18 +388,19 @@ mod tests {
       .await;
     let mut network = test_network(&app);
 
-    if let RadarrSerdeable::Tasks(tasks) = network
+    let RadarrSerdeable::Tasks(tasks) = network
       .handle_radarr_event(RadarrEvent::GetTasks)
       .await
       .unwrap()
-    {
-      async_server.assert_async().await;
-      assert_eq!(
-        app.lock().await.data.radarr_data.tasks.items,
-        expected_tasks
-      );
-      assert_eq!(tasks, response);
-    }
+    else {
+      panic!("Expected Tasks")
+    };
+    async_server.assert_async().await;
+    assert_eq!(
+      app.lock().await.data.radarr_data.tasks.items,
+      expected_tasks
+    );
+    assert_eq!(tasks, response);
   }
 
   #[tokio::test]
@@ -409,15 +417,16 @@ mod tests {
       .await;
     let mut network = test_network(&app);
 
-    if let RadarrSerdeable::Value(value) = network
+    let RadarrSerdeable::Value(value) = network
       .handle_radarr_event(RadarrEvent::StartTask(
         RadarrTaskName::ApplicationCheckUpdate,
       ))
       .await
       .unwrap()
-    {
-      async_server.assert_async().await;
-      assert_eq!(value, response);
-    }
+    else {
+      panic!("Expected Value")
+    };
+    async_server.assert_async().await;
+    assert_eq!(value, response);
   }
 }