test(cli): add integration tests for /update command and startup check

Author: om-mapari

tests/test_startup_version_check.py

@@ -0,0 +1,162 @@
+"""
+Unit tests for startup version check integration.
+
+Feature: self-update-command
+Tests Requirements: 2.1, 2.2, 2.3, 2.6, 2.7
+"""
+import pytest
+from unittest.mock import Mock, patch, MagicMock
+from shello_cli.update.update_manager import UpdateCheckResult
+from shello_cli.settings.models import UserSettings, UpdateConfig
+
+
+class TestStartupVersionCheck:
+    """Test suite for startup version check."""
+    
+    @patch('shello_cli.update.update_manager.UpdateManager')
+    def test_startup_check_when_enabled(self, mock_manager_class):
+        """
+        Test that startup check runs when check_on_startup is True.
+        
+        Validates: Requirements 2.1, 2.7
+        """
+        mock_manager = Mock()
+        mock_manager_class.return_value = mock_manager
+        
+        # Simulate update available
+        mock_manager.check_for_updates_async.return_value = UpdateCheckResult(
+            update_available=True,
+            current_version="0.4.3",
+            latest_version="0.5.0"
+        )
+        
+        # Create settings with check_on_startup enabled
+        settings = UserSettings(
+            provider="openai",
+            update_config=UpdateConfig(check_on_startup=True)
+        )
+        
+        # Verify settings
+        assert settings.update_config.check_on_startup is True
+        
+        # Simulate the startup check logic
+        if settings.update_config and settings.update_config.check_on_startup:
+            from shello_cli.update.update_manager import UpdateManager
+            manager = UpdateManager()
+            result = manager.check_for_updates_async(timeout=2.0)
+            
+            # Verify the check was called
+            assert result is not None
+            assert result.update_available is True
+    
+    @patch('shello_cli.update.update_manager.UpdateManager')
+    def test_startup_check_when_disabled(self, mock_manager_class):
+        """
+        Test that startup check is skipped when check_on_startup is False.
+        
+        Validates: Requirements 2.7
+        """
+        mock_manager = Mock()
+        mock_manager_class.return_value = mock_manager
+        
+        # Create settings with check_on_startup disabled
+        settings = UserSettings(
+            provider="openai",
+            update_config=UpdateConfig(check_on_startup=False)
+        )
+        
+        # Verify settings
+        assert settings.update_config.check_on_startup is False
+        
+        # Simulate the startup check logic
+        check_performed = False
+        if settings.update_config and settings.update_config.check_on_startup:
+            check_performed = True
+        
+        # Verify the check was NOT performed
+        assert check_performed is False
+    
+    @patch('shello_cli.update.update_manager.UpdateManager')
+    def test_startup_check_silent_on_error(self, mock_manager_class):
+        """
+        Test that startup check fails silently on errors.
+        
+        Validates: Requirements 2.3, 2.6
+        """
+        mock_manager = Mock()
+        mock_manager_class.return_value = mock_manager
+        
+        # Simulate error (returns None)
+        mock_manager.check_for_updates_async.return_value = None
+        
+        # Create settings with check_on_startup enabled
+        settings = UserSettings(
+            provider="openai",
+            update_config=UpdateConfig(check_on_startup=True)
+        )
+        
+        # Simulate the startup check logic
+        if settings.update_config and settings.update_config.check_on_startup:
+            from shello_cli.update.update_manager import UpdateManager
+            manager = UpdateManager()
+            result = manager.check_for_updates_async(timeout=2.0)
+            
+            # Verify the check returned None (error case)
+            assert result is None
+            
+            # In the actual implementation, this would not display an error
+            # The check would just be skipped silently
+    
+    @patch('shello_cli.update.update_manager.UpdateManager')
+    def test_startup_check_no_update_available(self, mock_manager_class):
+        """
+        Test that startup check handles no update available case.
+        
+        Validates: Requirements 2.1
+        """
+        mock_manager = Mock()
+        mock_manager_class.return_value = mock_manager
+        
+        # Simulate no update available
+        mock_manager.check_for_updates_async.return_value = UpdateCheckResult(
+            update_available=False,
+            current_version="0.5.0",
+            latest_version="0.5.0"
+        )
+        
+        # Create settings with check_on_startup enabled
+        settings = UserSettings(
+            provider="openai",
+            update_config=UpdateConfig(check_on_startup=True)
+        )
+        
+        # Simulate the startup check logic
+        if settings.update_config and settings.update_config.check_on_startup:
+            from shello_cli.update.update_manager import UpdateManager
+            manager = UpdateManager()
+            result = manager.check_for_updates_async(timeout=2.0)
+            
+            # Verify the check was called
+            assert result is not None
+            assert result.update_available is False
+            
+            # In the actual implementation, no notification would be displayed
+    
+    def test_update_config_default_value(self):
+        """
+        Test that UpdateConfig defaults to check_on_startup=True.
+        
+        Validates: Requirements 2.7
+        """
+        config = UpdateConfig()
+        assert config.check_on_startup is True
+    
+    def test_user_settings_default_update_config(self):
+        """
+        Test that UserSettings has default UpdateConfig.
+        
+        Validates: Requirements 2.7
+        """
+        settings = UserSettings(provider="openai")
+        assert settings.update_config is not None
+        assert settings.update_config.check_on_startup is True

tests/test_update_cli_integration.py

@@ -0,0 +1,205 @@
+"""
+Integration tests for /update command in CLI.
+
+Feature: self-update-command
+Tests Requirements: 7.1, 7.2, 7.3, 7.6
+"""
+import pytest
+from unittest.mock import Mock, patch, MagicMock
+from shello_cli.update.update_manager import UpdateResult
+
+
+class TestUpdateCommandIntegration:
+    """Test suite for /update command CLI integration."""
+    
+    @patch('shello_cli.update.update_manager.UpdateManager')
+    def test_update_command_routing(self, mock_manager_class):
+        """
+        Test that /update command is recognized and routed correctly.
+        
+        Validates: Requirements 7.1, 7.2
+        """
+        # This test verifies the command is detected and not sent to AI
+        # The actual CLI integration is tested manually, but we verify
+        # the UpdateManager is called correctly
+        
+        mock_manager = Mock()
+        mock_manager_class.return_value = mock_manager
+        
+        # Simulate successful update
+        mock_manager.perform_update.return_value = UpdateResult(
+            success=True,
+            message="Update completed successfully",
+            new_version="0.5.0"
+        )
+        
+        # Import here to trigger the mock
+        from shello_cli.update.update_manager import UpdateManager
+        
+        # Create manager and call perform_update
+        manager = UpdateManager()
+        result = manager.perform_update(force=False)
+        
+        # Verify the manager was called
+        assert result.success is True
+        assert result.new_version == "0.5.0"
+        mock_manager.perform_update.assert_called_once_with(force=False)
+    
+    @patch('shello_cli.update.update_manager.UpdateManager')
+    def test_update_command_with_force_flag(self, mock_manager_class):
+        """
+        Test that /update --force parses the flag correctly.
+        
+        Validates: Requirements 7.6
+        """
+        mock_manager = Mock()
+        mock_manager_class.return_value = mock_manager
+        
+        # Simulate successful forced update
+        mock_manager.perform_update.return_value = UpdateResult(
+            success=True,
+            message="Update completed successfully",
+            new_version="0.5.0"
+        )
+        
+        # Import here to trigger the mock
+        from shello_cli.update.update_manager import UpdateManager
+        
+        # Create manager and call perform_update with force=True
+        manager = UpdateManager()
+        result = manager.perform_update(force=True)
+        
+        # Verify the manager was called with force=True
+        assert result.success is True
+        mock_manager.perform_update.assert_called_once_with(force=True)
+    
+    @patch('shello_cli.update.update_manager.UpdateManager')
+    def test_update_command_displays_error(self, mock_manager_class):
+        """
+        Test that /update command displays errors appropriately.
+        
+        Validates: Requirements 7.3
+        """
+        mock_manager = Mock()
+        mock_manager_class.return_value = mock_manager
+        
+        # Simulate failed update
+        mock_manager.perform_update.return_value = UpdateResult(
+            success=False,
+            message="Update failed",
+            error="Network error: Could not connect to GitHub"
+        )
+        
+        # Import here to trigger the mock
+        from shello_cli.update.update_manager import UpdateManager
+        
+        # Create manager and call perform_update
+        manager = UpdateManager()
+        result = manager.perform_update(force=False)
+        
+        # Verify error information is available
+        assert result.success is False
+        assert result.error is not None
+        assert "Network error" in result.error
+    
+    def test_update_command_in_help(self):
+        """
+        Test that /update command is documented in help.
+        
+        Validates: Requirements 7.1
+        """
+        # Import the display_help function
+        from shello_cli.ui.ui_renderer import display_help
+        
+        # This is a smoke test - just verify the function can be called
+        # The actual help text is verified manually
+        # We can't easily test Rich output without complex mocking
+        try:
+            # Just verify the function exists and is callable
+            assert callable(display_help)
+        except Exception as e:
+            pytest.fail(f"display_help function should be callable: {e}")
+
+
+class TestUpdateCommandOutput:
+    """Test suite for /update command output formatting."""
+    
+    def test_output_when_already_on_latest(self):
+        """
+        Test that restart notification is NOT shown when already on latest version.
+        
+        Validates: Bug fix - no restart needed when already on latest
+        """
+        # Simulate the result when already on latest version
+        result = UpdateResult(
+            success=True,
+            message="You are already on the latest version (0.4.3)",
+            new_version="0.4.3"
+        )
+        
+        # Verify the message contains "already on the latest version"
+        assert "already on the latest version" in result.message.lower()
+        
+        # The CLI should check this condition and NOT show restart notification
+        should_show_restart = result.new_version and "already on the latest version" not in result.message.lower()
+        assert should_show_restart is False
+    
+    def test_output_when_update_successful(self):
+        """
+        Test that restart notification IS shown when update succeeds.
+        
+        Validates: Requirements 7.4, 7.5
+        """
+        # Simulate the result when update succeeds
+        result = UpdateResult(
+            success=True,
+            message="Update completed successfully",
+            new_version="0.5.0"
+        )
+        
+        # Verify the message does NOT contain "already on the latest version"
+        assert "already on the latest version" not in result.message.lower()
+        
+        # The CLI should show restart notification
+        should_show_restart = result.new_version and "already on the latest version" not in result.message.lower()
+        assert should_show_restart is True
+
+
+class TestUpdateCommandParsing:
+    """Test suite for /update command parsing."""
+    
+    def test_parse_update_command_no_flags(self):
+        """Test parsing /update with no flags."""
+        user_input = "/update"
+        
+        # Simulate the parsing logic from cli.py
+        force = "--force" in user_input.lower()
+        
+        assert force is False
+    
+    def test_parse_update_command_with_force(self):
+        """Test parsing /update --force."""
+        user_input = "/update --force"
+        
+        # Simulate the parsing logic from cli.py
+        force = "--force" in user_input.lower()
+        
+        assert force is True
+    
+    def test_parse_update_command_force_case_insensitive(self):
+        """Test parsing /update --FORCE (case insensitive)."""
+        user_input = "/update --FORCE"
+        
+        # Simulate the parsing logic from cli.py
+        force = "--force" in user_input.lower()
+        
+        assert force is True
+    
+    def test_parse_update_command_with_extra_text(self):
+        """Test parsing /update with extra text after --force."""
+        user_input = "/update --force now"
+        
+        # Simulate the parsing logic from cli.py
+        force = "--force" in user_input.lower()
+        
+        assert force is True