fix(radarr): Pass the number of log events to fetch in with the GetLogs event when publishing to the networking channel

src/app/radarr/mod.rs

@@ -93,7 +93,7 @@ impl<'a> App<'a> {
           .dispatch_network_event(RadarrEvent::GetQueuedEvents.into())
           .await;
         self
-          .dispatch_network_event(RadarrEvent::GetLogs(None).into())
+          .dispatch_network_event(RadarrEvent::GetLogs(500).into())
           .await;
       }
       ActiveRadarrBlock::SystemUpdates => {

src/app/radarr/radarr_tests.rs

@@ -282,7 +282,7 @@ mod tests {
       );
       assert_eq!(
         sync_network_rx.recv().await.unwrap(),
-        RadarrEvent::GetLogs(None).into()
+        RadarrEvent::GetLogs(500).into()
       );
       assert!(!app.data.radarr_data.prompt_confirm);
       assert_eq!(app.tick_count, 0);

src/cli/radarr/list_command_handler.rs

@@ -131,7 +131,7 @@ impl<'a, 'b> CliCommandHandler<'a, 'b, RadarrListCommand> for RadarrListCommandH
       } => {
         let logs = self
           .network
-          .handle_network_event(RadarrEvent::GetLogs(Some(events)).into())
+          .handle_network_event(RadarrEvent::GetLogs(events).into())
           .await?;
 
         if output_in_log_format {

src/cli/radarr/list_command_handler_tests.rs

@@ -189,7 +189,7 @@ mod tests {
       mock_network
         .expect_handle_network_event()
         .with(eq::<NetworkEvent>(
-          RadarrEvent::GetLogs(Some(expected_events)).into(),
+          RadarrEvent::GetLogs(expected_events).into(),
         ))
         .times(1)
         .returning(|_| {

src/network/radarr_network.rs

@@ -54,7 +54,7 @@ pub enum RadarrEvent {
   GetHostConfig,
   GetIndexers,
   GetAllIndexerSettings,
-  GetLogs(Option<u64>),
+  GetLogs(u64),
   GetMovieCredits(Option<i64>),
   GetMovieDetails(Option<i64>),
   GetMovieHistory(Option<i64>),
@@ -1118,13 +1118,13 @@ impl<'a, 'b> Network<'a, 'b> {
       .await
   }
 
-  async fn get_radarr_logs(&mut self, events: Option<u64>) -> Result<LogResponse> {
+  async fn get_radarr_logs(&mut self, events: u64) -> Result<LogResponse> {
     info!("Fetching Radarr logs");
     let event = RadarrEvent::GetLogs(events);
 
     let params = format!(
       "pageSize={}&sortDirection=descending&sortKey=time",
-      events.unwrap_or(500)
+      events
     );
     let request_props = self
       .request_props_from(event, RequestMethod::Get, None::<()>, None, Some(params))

src/network/radarr_network_tests.rs

@@ -12,11 +12,13 @@ mod test {
   use tokio::sync::Mutex;
   use tokio_util::sync::CancellationToken;
 
+  use super::super::*;
   use crate::app::ServarrConfig;
   use crate::models::radarr_models::{
     AddMovieOptions, BlocklistItem, BlocklistItemMovie, CollectionMovie, EditCollectionParams,
     EditMovieParams, IndexerSettings, MediaInfo, MinimumAvailability, MovieCollection, MovieFile, Rating, RatingsList
   };
+  use crate::models::servarr_data::radarr::modals::EditMovieModal;
   use crate::models::servarr_data::radarr::radarr_data::ActiveRadarrBlock;
   use crate::models::servarr_models::{
     EditIndexerParams,
@@ -27,8 +29,6 @@ mod test {
   use crate::network::network_tests::test_utils::mock_servarr_api;
   use crate::App;
 
-  use super::super::*;
-
   const MOVIE_JSON: &str = r#"{
         "id": 1,
         "title": "Test",
@@ -219,7 +219,7 @@ mod test {
   #[case(RadarrEvent::ClearBlocklist, "/blocklist/bulk")]
   #[case(RadarrEvent::DeleteBlocklistItem(1), "/blocklist")]
   #[case(RadarrEvent::GetBlocklist, "/blocklist?page=1&pageSize=10000")]
-  #[case(RadarrEvent::GetLogs(Some(500)), "/log")]
+  #[case(RadarrEvent::GetLogs(500), "/log")]
   #[case(RadarrEvent::SearchNewMovie(None), "/movie/lookup")]
   #[case(RadarrEvent::GetMovieCredits(None), "/credit")]
   #[case(RadarrEvent::GetMovieHistory(None), "/history/movie")]
@@ -2501,7 +2501,7 @@ mod test {
       None,
       Some(logs_response_json),
       None,
-      RadarrEvent::GetLogs(None),
+      RadarrEvent::GetLogs(500),
       None,
       Some("pageSize=500&sortDirection=descending&sortKey=time"),
     )
@@ -2509,75 +2509,7 @@ mod test {
     let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
 
     if let RadarrSerdeable::LogResponse(logs) = network
-      .handle_radarr_event(RadarrEvent::GetLogs(None))
-      .await
-      .unwrap()
-    {
-      async_server.assert_async().await;
-      assert_eq!(
-        app_arc.lock().await.data.radarr_data.logs.items,
-        expected_logs
-      );
-      assert!(app_arc
-        .lock()
-        .await
-        .data
-        .radarr_data
-        .logs
-        .current_selection()
-        .text
-        .contains("INFO"));
-      assert_eq!(logs, response);
-    }
-  }
-
-  #[tokio::test]
-  async fn test_handle_get_radarr_logs_event_uses_provided_events() {
-    let expected_logs = vec![
-      HorizontallyScrollableText::from(
-        "2023-05-20 21:29:16 UTC|FATAL|RadarrError|Some.Big.Bad.Exception|test exception",
-      ),
-      HorizontallyScrollableText::from("2023-05-20 21:29:16 UTC|INFO|TestLogger|test message"),
-    ];
-    let logs_response_json = json!({
-      "page": 1,
-      "pageSize": 1000,
-      "sortKey": "time",
-      "sortDirection": "descending",
-      "totalRecords": 2,
-      "records": [
-          {
-              "time": "2023-05-20T21:29:16Z",
-              "level": "info",
-              "logger": "TestLogger",
-              "message": "test message",
-              "id": 1
-          },
-          {
-              "time": "2023-05-20T21:29:16Z",
-              "level": "fatal",
-              "logger": "RadarrError",
-              "exception": "test exception",
-              "exceptionType": "Some.Big.Bad.Exception",
-              "id": 2
-          }
-        ]
-    });
-    let response: LogResponse = serde_json::from_value(logs_response_json.clone()).unwrap();
-    let (async_server, app_arc, _server) = mock_servarr_api(
-      RequestMethod::Get,
-      None,
-      Some(logs_response_json),
-      None,
-      RadarrEvent::GetLogs(Some(1000)),
-      None,
-      Some("pageSize=1000&sortDirection=descending&sortKey=time"),
-    )
-    .await;
-    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
-
-    if let RadarrSerdeable::LogResponse(logs) = network
-      .handle_radarr_event(RadarrEvent::GetLogs(Some(1000)))
+      .handle_radarr_event(RadarrEvent::GetLogs(500))
       .await
       .unwrap()
     {