ensure hitl works

lib/crewai/tests/utilities/test_console_formatter_pause_resume.py

@@ -1,116 +1,107 @@
 from unittest.mock import MagicMock, patch
-from rich.tree import Tree
 from rich.live import Live
 from crewai.events.utils.console_formatter import ConsoleFormatter
 
 
 class TestConsoleFormatterPauseResume:
-    """Test ConsoleFormatter pause/resume functionality."""
+    """Test ConsoleFormatter pause/resume functionality for HITL features."""
 
-    def test_pause_live_updates_with_active_session(self):
-        """Test pausing when Live session is active."""
+    def test_pause_stops_active_streaming_session(self):
+        """Test pausing stops an active streaming Live session."""
         formatter = ConsoleFormatter()
 
         mock_live = MagicMock(spec=Live)
-        formatter._live = mock_live
-        formatter._live_paused = False
+        formatter._streaming_live = mock_live
 
         formatter.pause_live_updates()
 
         mock_live.stop.assert_called_once()
-        assert formatter._live_paused
+        assert formatter._streaming_live is None
 
-    def test_pause_live_updates_when_already_paused(self):
-        """Test pausing when already paused does nothing."""
+    def test_pause_is_safe_when_no_session(self):
+        """Test pausing when no streaming session exists doesn't error."""
+        formatter = ConsoleFormatter()
+        formatter._streaming_live = None
+
+        # Should not raise
+        formatter.pause_live_updates()
+
+        assert formatter._streaming_live is None
+
+    def test_multiple_pauses_are_safe(self):
+        """Test calling pause multiple times is safe."""
         formatter = ConsoleFormatter()
 
         mock_live = MagicMock(spec=Live)
-        formatter._live = mock_live
-        formatter._live_paused = True
+        formatter._streaming_live = mock_live
 
         formatter.pause_live_updates()
+        mock_live.stop.assert_called_once()
+        assert formatter._streaming_live is None
 
-        mock_live.stop.assert_not_called()
-        assert formatter._live_paused
-
-    def test_pause_live_updates_with_no_session(self):
-        """Test pausing when no Live session exists."""
-        formatter = ConsoleFormatter()
-
-        formatter._live = None
-        formatter._live_paused = False
-
+        # Second pause should not error (no session to stop)
         formatter.pause_live_updates()
 
-        assert formatter._live_paused
-
-    def test_resume_live_updates_when_paused(self):
-        """Test resuming when paused."""
+    def test_resume_is_safe(self):
+        """Test resume method exists and doesn't error."""
         formatter = ConsoleFormatter()
 
-        formatter._live_paused = True
-
+        # Should not raise
         formatter.resume_live_updates()
 
-        assert not formatter._live_paused
-
-    def test_resume_live_updates_when_not_paused(self):
-        """Test resuming when not paused does nothing."""
+    def test_streaming_after_pause_resume_creates_new_session(self):
+        """Test that streaming after pause/resume creates new Live session."""
         formatter = ConsoleFormatter()
+        formatter.verbose = True
 
-        formatter._live_paused = False
+        # Simulate having an active session
+        mock_live = MagicMock(spec=Live)
+        formatter._streaming_live = mock_live
 
+        # Pause stops the session
+        formatter.pause_live_updates()
+        assert formatter._streaming_live is None
+
+        # Resume (no-op, sessions created on demand)
         formatter.resume_live_updates()
 
-        assert not formatter._live_paused
+        # After resume, streaming should be able to start a new session
+        with patch("crewai.events.utils.console_formatter.Live") as mock_live_class:
+            mock_live_instance = MagicMock()
+            mock_live_class.return_value = mock_live_instance
 
-    def test_print_after_resume_restarts_live_session(self):
-        """Test that printing a Tree after resume creates new Live session."""
+            # Simulate streaming chunk (this creates a new Live session)
+            formatter.handle_llm_stream_chunk("test chunk", call_type=None)
+
+            mock_live_class.assert_called_once()
+            mock_live_instance.start.assert_called_once()
+            assert formatter._streaming_live == mock_live_instance
+
+    def test_pause_resume_cycle_with_streaming(self):
+        """Test full pause/resume cycle during streaming."""
         formatter = ConsoleFormatter()
-
-        formatter._live_paused = True
-        formatter._live = None
-
-        formatter.resume_live_updates()
-        assert not formatter._live_paused
-
-        tree = Tree("Test")
+        formatter.verbose = True
 
         with patch("crewai.events.utils.console_formatter.Live") as mock_live_class:
             mock_live_instance = MagicMock()
             mock_live_class.return_value = mock_live_instance
 
-            formatter.print(tree)
+            # Start streaming
+            formatter.handle_llm_stream_chunk("chunk 1", call_type=None)
+            assert formatter._streaming_live == mock_live_instance
 
-            mock_live_class.assert_called_once()
-            mock_live_instance.start.assert_called_once()
-            assert formatter._live == mock_live_instance
+            # Pause should stop the session
+            formatter.pause_live_updates()
+            mock_live_instance.stop.assert_called_once()
+            assert formatter._streaming_live is None
 
-    def test_multiple_pause_resume_cycles(self):
-        """Test multiple pause/resume cycles work correctly."""
-        formatter = ConsoleFormatter()
+            # Resume (no-op)
+            formatter.resume_live_updates()
 
-        mock_live = MagicMock(spec=Live)
-        formatter._live = mock_live
-        formatter._live_paused = False
+            # Create a new mock for the next session
+            mock_live_instance_2 = MagicMock()
+            mock_live_class.return_value = mock_live_instance_2
 
-        formatter.pause_live_updates()
-        assert formatter._live_paused
-        mock_live.stop.assert_called_once()
-        assert formatter._live is None  # Live session should be cleared
-
-        formatter.resume_live_updates()
-        assert not formatter._live_paused
-
-        formatter.pause_live_updates()
-        assert formatter._live_paused
-
-        formatter.resume_live_updates()
-        assert not formatter._live_paused
-
-    def test_pause_resume_state_initialization(self):
-        """Test that _live_paused is properly initialized."""
-        formatter = ConsoleFormatter()
-
-        assert hasattr(formatter, "_live_paused")
-        assert not formatter._live_paused
+            # Streaming again creates new session
+            formatter.handle_llm_stream_chunk("chunk 2", call_type=None)
+            assert formatter._streaming_live == mock_live_instance_2