fix(ui): prevent spinner cycling causing early exit in model selection (#2086)

Co-authored-by: ForgeCode <noreply@forgecode.dev>
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>

Author: 3 people

Cargo.lock

@@ -9,3 +9,6 @@ colored.workspace = true
 tokio.workspace = true
 indicatif = "0.18.0"
 rand = "0.9.2"
+
+[dev-dependencies]
+pretty_assertions.workspace = true

crates/forge_spinner/Cargo.toml

@@ -16,13 +16,22 @@ pub struct SpinnerManager {
     start_time: Option<Instant>,
     message: Option<String>,
     tracker: Option<JoinHandle<()>>,
+    #[cfg(test)]
+    tick_counter: Option<std::sync::Arc<std::sync::atomic::AtomicU64>>,
 }
 
 impl SpinnerManager {
     pub fn new() -> Self {
         Self::default()
     }
 
+    #[cfg(test)]
+    pub fn test_with_tick_counter(
+        tick_counter: std::sync::Arc<std::sync::atomic::AtomicU64>,
+    ) -> Self {
+        Self { tick_counter: Some(tick_counter), ..Self::default() }
+    }
+
     /// Start the spinner with a message
     pub fn start(&mut self, message: Option<&str>) -> Result<()> {
         self.stop(None)?;
@@ -80,12 +89,18 @@ impl SpinnerManager {
         let spinner_clone = self.spinner.clone();
         let start_time_clone = self.start_time;
         let message_clone = self.message.clone();
+        #[cfg(test)]
+        let tick_counter_clone = self.tick_counter.clone();
 
         // Spwan tracker to keep the track of time in sec.
         self.tracker = Some(tokio::spawn(async move {
             let mut interval = tokio::time::interval(tokio::time::Duration::from_millis(500));
             loop {
                 interval.tick().await;
+                #[cfg(test)]
+                if let Some(counter) = &tick_counter_clone {
+                    counter.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
+                }
                 // Update the spinner with the current elapsed time
                 if let (Some(spinner), Some(start_time), Some(message)) =
                     (&spinner_clone, start_time_clone, &message_clone)
@@ -135,6 +150,7 @@ impl SpinnerManager {
 
         // Tracker task will be dropped here.
         if let Some(a) = self.tracker.take() {
+            a.abort();
             drop(a)
         }
         self.tracker = None;
@@ -164,3 +180,31 @@ impl SpinnerManager {
         self.write_with_restart(message, |msg| eprintln!("{msg}"))
     }
 }
+#[cfg(test)]
+mod tests {
+    use std::sync::Arc;
+    use std::sync::atomic::{AtomicU64, Ordering};
+
+    use pretty_assertions::assert_eq;
+
+    use super::SpinnerManager;
+
+    #[tokio::test]
+    async fn test_spinner_tracker_task_is_stopped_on_stop() {
+        let fixture_counter = Arc::new(AtomicU64::new(0));
+        let mut fixture_spinner = SpinnerManager::test_with_tick_counter(fixture_counter.clone());
+
+        fixture_spinner.start(Some("Test")).unwrap();
+        tokio::time::sleep(std::time::Duration::from_millis(1100)).await;
+
+        let actual_before_stop = fixture_counter.load(Ordering::SeqCst);
+        assert!(actual_before_stop > 0);
+
+        fixture_spinner.stop(None).unwrap();
+        tokio::time::sleep(std::time::Duration::from_millis(1100)).await;
+
+        let actual_after_stop = fixture_counter.load(Ordering::SeqCst);
+        let expected = actual_before_stop;
+        assert_eq!(actual_after_stop, expected);
+    }
+}