test(tui): cover deferred restored remote dispatch

Author: 1jehuang

crates/jcode-tui/src/tui/app/tests/remote_events_reload_04.rs

@@ -132,11 +132,18 @@ fn test_remote_error_with_retryable_pending_schedules_retry() {
     assert_eq!(pending.retry_attempts, 1);
     assert!(pending.retry_at.is_some());
     assert!(app.rate_limit_reset.is_some());
-    assert!(
-        app.display_messages()
-            .iter()
-            .any(|m| m.role == "system" && m.content.contains("Auto-retrying"))
-    );
+    let retry_notice = app
+        .display_messages()
+        .iter()
+        .find(|message| message.title.as_deref() == Some("Connection"))
+        .expect("retry should surface a connection status message");
+    assert_eq!(retry_notice.role, "system");
+    assert!(retry_notice.content.contains("Connection lost - retrying"));
+    assert!(retry_notice.content.contains(&format!(
+        "attempt 1/{}",
+        App::AUTO_RETRY_MAX_ATTEMPTS
+    )));
+    assert!(retry_notice.content.contains("Remote request failed"));
 }
 
 #[test]

crates/jcode-tui/src/tui/app/tests/remote_startup_input_01/part_01.rs

@@ -337,16 +337,22 @@ fn test_new_for_remote_restores_spawn_startup_hints_and_dispatch_state() {
             super::commands::build_autojudge_startup_message("session_parent_123"),
         );
 
-        let app = App::new_for_remote(Some(session_id.to_string()));
+        let mut app = App::new_for_remote(Some(session_id.to_string()));
+        let rt = tokio::runtime::Runtime::new().unwrap();
+        let _guard = rt.enter();
+        let mut remote = crate::tui::backend::RemoteConnection::dummy();
 
-        assert!(app.pending_queued_dispatch);
-        assert!(app.is_processing());
-        assert!(app.processing_started.is_some());
+        assert!(!app.pending_queued_dispatch);
+        assert!(!app.is_processing());
+        assert!(app.processing_started.is_none());
         assert!(matches!(
             crate::tui::TuiState::status(&app),
-            ProcessingStatus::Sending
+            ProcessingStatus::Idle
         ));
-        assert_eq!(app.status_notice(), Some("Autojudge starting".to_string()));
+        assert_eq!(
+            app.status_notice(),
+            Some("Restored queued follow-up after reload".to_string())
+        );
         assert_eq!(app.hidden_queued_system_messages.len(), 1);
 
         let startup_banner = app
@@ -363,6 +369,27 @@ fn test_new_for_remote_restores_spawn_startup_hints_and_dispatch_state() {
         );
         assert!(startup_banner.content.contains("user-visible mirror"));
         assert!(startup_banner.content.contains("session_parent_123"));
+
+        rt.block_on(super::remote::process_remote_followups(
+            &mut app,
+            &mut remote,
+        ));
+        assert_eq!(app.hidden_queued_system_messages.len(), 1);
+        assert!(!app.is_processing());
+
+        remote.mark_history_loaded();
+        rt.block_on(super::remote::process_remote_followups(
+            &mut app,
+            &mut remote,
+        ));
+
+        assert!(app.hidden_queued_system_messages.is_empty());
+        assert!(app.is_processing());
+        assert!(matches!(
+            crate::tui::TuiState::status(&app),
+            ProcessingStatus::Sending
+        ));
+        assert!(app.current_message_id.is_some());
     });
 }
 
@@ -383,23 +410,39 @@ fn test_remote_startup_done_event_does_not_cancel_pending_judge_launch() {
         );
 
         let mut app = App::new_for_remote(Some(session_id.to_string()));
+        let rt = tokio::runtime::Runtime::new().unwrap();
+        let _guard = rt.enter();
         let mut remote = crate::tui::backend::RemoteConnection::dummy();
 
-        assert!(app.pending_queued_dispatch);
-        assert!(app.is_processing());
+        assert!(!app.pending_queued_dispatch);
+        assert!(!app.is_processing());
         assert_eq!(app.current_message_id, None);
         assert_eq!(app.hidden_queued_system_messages.len(), 1);
 
         app.handle_server_event(crate::protocol::ServerEvent::Done { id: 1 }, &mut remote);
 
-        assert!(app.pending_queued_dispatch);
-        assert!(app.is_processing());
+        assert!(!app.pending_queued_dispatch);
+        assert!(!app.is_processing());
         assert!(matches!(
             crate::tui::TuiState::status(&app),
-            ProcessingStatus::Sending
+            ProcessingStatus::Idle
         ));
         assert_eq!(app.current_message_id, None);
         assert_eq!(app.hidden_queued_system_messages.len(), 1);
+
+        remote.mark_history_loaded();
+        rt.block_on(super::remote::process_remote_followups(
+            &mut app,
+            &mut remote,
+        ));
+
+        assert!(app.hidden_queued_system_messages.is_empty());
+        assert!(app.is_processing());
+        assert!(matches!(
+            crate::tui::TuiState::status(&app),
+            ProcessingStatus::Sending
+        ));
+        assert!(app.current_message_id.is_some());
     });
 }
 
@@ -423,13 +466,19 @@ fn test_remote_startup_judge_hidden_prompt_dispatches_once_history_is_loaded() {
         let rt = tokio::runtime::Runtime::new().unwrap();
         let _guard = rt.enter();
         let mut remote = crate::tui::backend::RemoteConnection::dummy();
-        remote.mark_history_loaded();
 
-        assert!(app.pending_queued_dispatch);
-        assert!(app.is_processing());
+        assert!(!app.pending_queued_dispatch);
+        assert!(!app.is_processing());
         assert_eq!(app.current_message_id, None);
 
-        app.pending_queued_dispatch = false;
+        rt.block_on(super::remote::process_remote_followups(
+            &mut app,
+            &mut remote,
+        ));
+        assert_eq!(app.hidden_queued_system_messages.len(), 1);
+        assert!(!app.is_processing());
+
+        remote.mark_history_loaded();
         rt.block_on(super::remote::process_remote_followups(
             &mut app,
             &mut remote,
@@ -474,10 +523,11 @@ fn test_new_for_remote_fresh_spawn_restores_local_transcript() {
             super::commands::build_autojudge_startup_message("session_parent_123"),
         );
 
-        let app = App::new_for_remote_with_options(Some(session_id.to_string()), true);
+        let mut app = App::new_for_remote_with_options(Some(session_id.to_string()), true);
 
         assert_eq!(crate::tui::TuiState::provider_model(&app), "gpt-5.4");
-        assert!(app.pending_queued_dispatch);
+        assert!(!app.pending_queued_dispatch);
+        assert!(!app.is_processing());
         assert_eq!(app.hidden_queued_system_messages.len(), 1);
         assert_eq!(app.display_messages().len(), 2);
         assert!(
@@ -489,6 +539,25 @@ fn test_new_for_remote_fresh_spawn_restores_local_transcript() {
         let startup_banner = app.display_messages().last().expect("startup banner");
         assert_eq!(startup_banner.role, "system");
         assert_eq!(startup_banner.title.as_deref(), Some("Autojudge"));
+
+        let rt = tokio::runtime::Runtime::new().unwrap();
+        let _guard = rt.enter();
+        let mut remote = crate::tui::backend::RemoteConnection::dummy();
+        rt.block_on(super::remote::process_remote_followups(
+            &mut app,
+            &mut remote,
+        ));
+        assert_eq!(app.hidden_queued_system_messages.len(), 1);
+        assert!(!app.is_processing());
+
+        remote.mark_history_loaded();
+        rt.block_on(super::remote::process_remote_followups(
+            &mut app,
+            &mut remote,
+        ));
+        assert!(app.hidden_queued_system_messages.is_empty());
+        assert!(app.is_processing());
+        assert!(app.current_message_id.is_some());
     });
 }
 

crates/jcode-tui/src/tui/app/tests/remote_startup_input_03/part_01.rs

@@ -1122,10 +1122,36 @@ fn test_new_for_remote_restored_interleave_triggers_dispatch_state() {
     app.interleave_message = Some("interrupt after reload".to_string());
     app.save_input_for_reload(&session_id);
 
-    let restored = App::new_for_remote(Some(session_id));
+    let mut restored = App::new_for_remote(Some(session_id));
     assert!(restored.interleave_message.is_none());
     assert_eq!(restored.queued_messages(), &["interrupt after reload"]);
-    assert!(restored.pending_queued_dispatch);
+    assert!(!restored.pending_queued_dispatch);
+    assert!(!restored.is_processing);
+    assert!(matches!(restored.status, ProcessingStatus::Idle));
+
+    let rt = tokio::runtime::Runtime::new().unwrap();
+    let _guard = rt.enter();
+    let mut remote = crate::tui::backend::RemoteConnection::dummy();
+    rt.block_on(super::remote::process_remote_followups(
+        &mut restored,
+        &mut remote,
+    ));
+    assert_eq!(restored.queued_messages(), &["interrupt after reload"]);
+    assert!(!restored.is_processing);
+
+    remote.mark_history_loaded();
+    rt.block_on(super::remote::process_remote_followups(
+        &mut restored,
+        &mut remote,
+    ));
+
+    assert!(restored.queued_messages().is_empty());
     assert!(restored.is_processing);
     assert!(matches!(restored.status, ProcessingStatus::Sending));
+    assert!(
+        restored
+            .display_messages()
+            .iter()
+            .any(|message| message.role == "user" && message.content == "interrupt after reload")
+    );
 }

crates/jcode-tui/src/tui/app/tests/remote_startup_input_03/part_02.rs

@@ -7,12 +7,38 @@ fn test_new_for_remote_restored_soft_interrupt_resend_triggers_dispatch_state()
     app.pending_soft_interrupt_requests = vec![(55, "sent interrupt".to_string())];
     app.save_input_for_reload(&session_id);
 
-    let restored = App::new_for_remote(Some(session_id));
+    let mut restored = App::new_for_remote(Some(session_id));
     assert!(restored.interleave_message.is_none());
     assert_eq!(restored.queued_messages(), &["sent interrupt"]);
-    assert!(restored.pending_queued_dispatch);
+    assert!(!restored.pending_queued_dispatch);
+    assert!(!restored.is_processing);
+    assert!(matches!(restored.status, ProcessingStatus::Idle));
+
+    let rt = tokio::runtime::Runtime::new().unwrap();
+    let _guard = rt.enter();
+    let mut remote = crate::tui::backend::RemoteConnection::dummy();
+    rt.block_on(super::remote::process_remote_followups(
+        &mut restored,
+        &mut remote,
+    ));
+    assert_eq!(restored.queued_messages(), &["sent interrupt"]);
+    assert!(!restored.is_processing);
+
+    remote.mark_history_loaded();
+    rt.block_on(super::remote::process_remote_followups(
+        &mut restored,
+        &mut remote,
+    ));
+
+    assert!(restored.queued_messages().is_empty());
     assert!(restored.is_processing);
     assert!(matches!(restored.status, ProcessingStatus::Sending));
+    assert!(
+        restored
+            .display_messages()
+            .iter()
+            .any(|message| message.role == "user" && message.content == "sent interrupt")
+    );
 }
 
 #[test]
@@ -25,12 +51,53 @@ fn test_new_for_remote_does_not_requeue_acked_pending_soft_interrupts() {
     app.queued_messages.push("queued later".to_string());
     app.save_input_for_reload(&session_id);
 
-    let restored = App::new_for_remote(Some(session_id));
+    let mut restored = App::new_for_remote(Some(session_id));
+    assert!(restored.interleave_message.is_none());
     assert_eq!(
-        restored.interleave_message.as_deref(),
-        Some("local interleave")
+        restored.queued_messages(),
+        &["local interleave", "queued later"]
+    );
+    assert!(
+        !restored
+            .queued_messages()
+            .iter()
+            .any(|message| message == "already queued on server")
+    );
+    assert!(!restored.pending_queued_dispatch);
+    assert!(!restored.is_processing);
+
+    let rt = tokio::runtime::Runtime::new().unwrap();
+    let _guard = rt.enter();
+    let mut remote = crate::tui::backend::RemoteConnection::dummy();
+    rt.block_on(super::remote::process_remote_followups(
+        &mut restored,
+        &mut remote,
+    ));
+    assert_eq!(
+        restored.queued_messages(),
+        &["local interleave", "queued later"]
+    );
+
+    remote.mark_history_loaded();
+    rt.block_on(super::remote::process_remote_followups(
+        &mut restored,
+        &mut remote,
+    ));
+
+    assert!(restored.queued_messages().is_empty());
+    assert!(restored.is_processing);
+    assert!(
+        restored
+            .display_messages()
+            .iter()
+            .any(|message| message.role == "user" && message.content == "local interleave")
+    );
+    assert!(
+        restored
+            .display_messages()
+            .iter()
+            .all(|message| message.content != "already queued on server")
     );
-    assert_eq!(restored.queued_messages(), &["queued later"]);
 }
 
 #[test]