code-puppy 0.0.154__py3-none-any.whl → 0.0.156__py3-none-any.whl

code_puppy/tui/tests/test_sidebar_history.py

@@ -1,153 +0,0 @@
-import unittest
-from unittest.mock import MagicMock, patch
-
-from textual.widgets import ListItem, ListView
-
-from code_puppy.tui.components.command_history_modal import CommandHistoryModal
-from code_puppy.tui.components.sidebar import Sidebar
-from code_puppy.tui.models.command_history import HistoryFileReader
-
-
-class TestSidebarHistory(unittest.TestCase):
-    def setUp(self):
-        # Create a sidebar
-        self.sidebar = Sidebar()
-
-        # Mock history_list
-        self.mock_history_list = MagicMock(spec=ListView)
-        self.mock_history_list.children = []
-        self.sidebar.query_one = MagicMock(return_value=self.mock_history_list)
-
-        # Mock the app's push_screen method without trying to set the app property
-        self.mock_push_screen = MagicMock()
-
-    @patch.object(HistoryFileReader, "read_history")
-    def test_load_command_history(self, mock_read_history):
-        # Mock the history entries
-        mock_entries = [
-            {"timestamp": "2023-01-01T12:34:56", "command": "First command"},
-            {"timestamp": "2023-01-01T13:45:00", "command": "Second command"},
-        ]
-        mock_read_history.return_value = mock_entries
-
-        # Call the method
-        self.sidebar.load_command_history()
-
-        # Check that ListView.append was called for each entry
-        self.assertEqual(self.mock_history_list.append.call_count, 2)
-
-        # Check that ListView.clear was called
-        self.mock_history_list.clear.assert_called_once()
-
-    @patch.object(HistoryFileReader, "read_history")
-    def test_load_command_history_empty(self, mock_read_history):
-        # Mock empty history
-        mock_read_history.return_value = []
-
-        # Call the method
-        self.sidebar.load_command_history()
-
-        # Check that an empty message was added
-        self.mock_history_list.append.assert_called_once()
-        # Just verify append was called, don't try to access complex children structure
-        self.assertTrue(self.mock_history_list.append.called)
-
-    @patch.object(HistoryFileReader, "read_history")
-    def test_load_command_history_exception(self, mock_read_history):
-        # Force an exception
-        mock_read_history.side_effect = Exception("Test error")
-
-        # Call the method
-        self.sidebar.load_command_history()
-
-        # Check that an error message was added
-        self.mock_history_list.append.assert_called_once()
-        # Just verify append was called, don't try to access complex children structure
-        self.assertTrue(self.mock_history_list.append.called)
-
-    @patch.object(HistoryFileReader, "read_history")
-    def test_load_command_history_filters_cli_commands(self, mock_read_history):
-        # Mock history with CLI commands mixed with regular commands
-        mock_read_history.return_value = [
-            {
-                "timestamp": "2024-01-01T10:00:00Z",
-                "command": "How do I create a function?",
-            },
-            {"timestamp": "2024-01-01T10:01:00Z", "command": "/help"},
-            {"timestamp": "2024-01-01T10:02:00Z", "command": "Write a Python script"},
-            {"timestamp": "2024-01-01T10:04:00Z", "command": "/exit"},
-            {"timestamp": "2024-01-01T10:05:00Z", "command": "Debug this error"},
-            {"timestamp": "2024-01-01T10:06:00Z", "command": "/m gpt-4"},
-            {"timestamp": "2024-01-01T10:07:00Z", "command": "Explain this code"},
-        ]
-
-        # Call the method
-        self.sidebar.load_command_history()
-
-        # Verify that CLI commands were filtered out
-        # Should have 4 non-CLI commands: "How do I create a function?", "Write a Python script", "Debug this error", "Explain this code"
-        self.assertEqual(len(self.sidebar.history_entries), 4)
-
-        # Verify the filtered commands are the correct ones
-        commands = [entry["command"] for entry in self.sidebar.history_entries]
-        expected_commands = [
-            "How do I create a function?",
-            "Write a Python script",
-            "Debug this error",
-            "Explain this code",
-        ]
-        self.assertEqual(commands, expected_commands)
-
-        # Verify CLI commands are not in the filtered list
-        for entry in self.sidebar.history_entries:
-            command = entry["command"]
-            self.assertFalse(
-                any(
-                    command.startswith(cli_cmd)
-                    for cli_cmd in {
-                        "/help",
-                        "/exit",
-                        "/m",
-                        "/motd",
-                        "/show",
-                        "/set",
-                        "/tools",
-                    }
-                )
-            )
-
-    @patch(
-        "code_puppy.tui.components.sidebar.Sidebar.app",
-        new_callable=lambda: MagicMock(),
-    )
-    def test_on_key_enter(self, mock_app_property):
-        # Create a mock highlighted child with a command entry
-        mock_item = MagicMock(spec=ListItem)
-        mock_item.command_entry = {
-            "timestamp": "2023-01-01T12:34:56",
-            "command": "Test command",
-        }
-
-        self.mock_history_list.highlighted_child = mock_item
-        self.mock_history_list.has_focus = True
-        self.mock_history_list.index = 0
-
-        # Create a mock Key event
-        mock_event = MagicMock()
-        mock_event.key = "enter"
-
-        # Call the method
-        self.sidebar.on_key(mock_event)
-
-        # Check that push_screen was called with CommandHistoryModal
-        mock_app_property.push_screen.assert_called_once()
-        args, kwargs = mock_app_property.push_screen.call_args
-        self.assertIsInstance(args[0], CommandHistoryModal)
-
-        # Check that event propagation was stopped
-        mock_event.stop.assert_called_once()
-        mock_event.prevent_default.assert_called_once()
-
-
-if __name__ == "__main__":
-    unittest.main()

code_puppy/tui/tests/test_sidebar_history_navigation.py

@@ -1,132 +0,0 @@
-"""
-Tests for the history navigation in the sidebar component.
-"""
-
-import pytest
-from textual.app import App
-
-from code_puppy.tui.components.command_history_modal import CommandHistoryModal
-from code_puppy.tui.components.sidebar import Sidebar
-
-
-class TestSidebarHistoryNavigation:
-    """Tests for the history navigation functionality in the sidebar."""
-
-    @pytest.fixture
-    def sidebar(self):
-        """Create a sidebar instance for testing."""
-        sidebar = Sidebar()
-        return sidebar
-
-    async def test_navigation_index_tracking(self, sidebar):
-        """Test that the index tracking works correctly for navigation."""
-        # Setup test data
-        sidebar.history_entries = [
-            {"command": "command1", "timestamp": "2023-01-01T10:00:00Z"},
-            {"command": "command2", "timestamp": "2023-01-01T11:00:00Z"},
-            {"command": "command3", "timestamp": "2023-01-01T12:00:00Z"},
-        ]
-        sidebar.current_history_index = 0
-
-        # Test navigation to next command
-        assert sidebar.navigate_to_next_command() is True
-        assert sidebar.current_history_index == 1
-
-        # Test navigation to next command again
-        assert sidebar.navigate_to_next_command() is True
-        assert sidebar.current_history_index == 2
-
-        # Test navigation at the end of the list
-        assert sidebar.navigate_to_next_command() is False
-        assert sidebar.current_history_index == 2  # Index shouldn't change
-
-        # Test navigation to previous command
-        assert sidebar.navigate_to_previous_command() is True
-        assert sidebar.current_history_index == 1
-
-        # Test navigation to previous command again
-        assert sidebar.navigate_to_previous_command() is True
-        assert sidebar.current_history_index == 0
-
-        # Test navigation at the beginning of the list
-        assert sidebar.navigate_to_previous_command() is False
-        assert sidebar.current_history_index == 0  # Index shouldn't change
-
-    async def test_get_current_command_entry(self, sidebar):
-        """Test that the current command entry is retrieved correctly."""
-        # Setup test data
-        sidebar.history_entries = [
-            {"command": "command1", "timestamp": "2023-01-01T10:00:00Z"},
-            {"command": "command2", "timestamp": "2023-01-01T11:00:00Z"},
-        ]
-
-        # Test getting entry at index 0
-        sidebar.current_history_index = 0
-        entry = sidebar.get_current_command_entry()
-        assert entry["command"] == "command1"
-        assert entry["timestamp"] == "2023-01-01T10:00:00Z"
-
-        # Test getting entry at index 1
-        sidebar.current_history_index = 1
-        entry = sidebar.get_current_command_entry()
-        assert entry["command"] == "command2"
-        assert entry["timestamp"] == "2023-01-01T11:00:00Z"
-
-        # Test getting entry with invalid index
-        sidebar.current_history_index = 99
-        entry = sidebar.get_current_command_entry()
-        assert entry == {"command": "", "timestamp": ""}
-
-        # Test getting entry with empty history entries
-        sidebar.history_entries = []
-        sidebar.current_history_index = 0
-        entry = sidebar.get_current_command_entry()
-        assert entry == {"command": "", "timestamp": ""}
-
-    class TestApp(App):
-        """Test app for simulating modal and sidebar interaction."""
-
-        def compose(self):
-            """Create the app layout."""
-            self.sidebar = Sidebar()
-            yield self.sidebar
-
-    async def test_modal_navigation_integration(self, monkeypatch):
-        """Test that the modal uses the sidebar's navigation methods."""
-        app = self.TestApp()
-        async with app.run_test() as pilot:
-            # Setup test data in sidebar
-            app.sidebar.history_entries = [
-                {"command": "command1", "timestamp": "2023-01-01T10:00:00Z"},
-                {"command": "command2", "timestamp": "2023-01-01T11:00:00Z"},
-                {"command": "command3", "timestamp": "2023-01-01T12:00:00Z"},
-            ]
-            app.sidebar.current_history_index = 0
-
-            # Create and mount the modal
-            modal = CommandHistoryModal()
-            modal.sidebar = app.sidebar
-            app.push_screen(modal)
-            await pilot.pause()
-
-            # Test initial state
-            assert modal.command == "command1"
-            assert modal.timestamp == "2023-01-01T10:00:00Z"
-
-            # Test navigation down
-            await pilot.press("down")
-            assert app.sidebar.current_history_index == 1
-            assert modal.command == "command2"
-            assert modal.timestamp == "2023-01-01T11:00:00Z"
-
-            # Test navigation down again
-            await pilot.press("down")
-            assert app.sidebar.current_history_index == 2
-            assert modal.command == "command3"
-            assert modal.timestamp == "2023-01-01T12:00:00Z"
-
-            # Test navigation up
-            await pilot.press("up")
-            assert app.sidebar.current_history_index == 1
-            assert modal.command == "command2"
-            assert modal.timestamp == "2023-01-01T11:00:00Z"

code_puppy/tui/tests/test_status_bar.py

@@ -1,54 +0,0 @@
-import unittest
-from unittest.mock import MagicMock, patch
-
-from code_puppy.tui.components.status_bar import StatusBar
-
-
-class TestStatusBar(unittest.TestCase):
-    def setUp(self):
-        self.status_bar = StatusBar()
-
-    def test_compose(self):
-        widgets = list(self.status_bar.compose())
-        self.assertGreaterEqual(len(widgets), 1)
-
-    @patch(
-        "code_puppy.tui.components.status_bar.StatusBar.app",
-        new_callable=lambda: MagicMock(),
-    )
-    def test_update_status(self, mock_app_property):
-        # Mock the query_one method to avoid DOM dependency
-        mock_status_widget = MagicMock()
-        self.status_bar.query_one = MagicMock(return_value=mock_status_widget)
-
-        # Mock the app.size to avoid app dependency
-        mock_app_property.size.width = 80
-
-        # Should not raise
-        self.status_bar.update_status()
-
-        # Verify that update was called on the status widget (may be called multiple times)
-        self.assertTrue(mock_status_widget.update.called)
-
-    @patch(
-        "code_puppy.tui.components.status_bar.StatusBar.app",
-        new_callable=lambda: MagicMock(),
-    )
-    def test_watchers(self, mock_app_property):
-        # Mock the query_one method to avoid DOM dependency
-        mock_status_widget = MagicMock()
-        self.status_bar.query_one = MagicMock(return_value=mock_status_widget)
-
-        # Mock the app.size to avoid app dependency
-        mock_app_property.size.width = 80
-
-        # Should call update_status without error
-        self.status_bar.watch_current_model()
-        self.status_bar.watch_puppy_name()
-        self.status_bar.watch_connection_status()
-        self.status_bar.watch_agent_status()
-        self.status_bar.watch_progress_visible()
-
-
-if __name__ == "__main__":
-    unittest.main()

code_puppy/tui/tests/test_timestamped_history.py

@@ -1,52 +0,0 @@
-import unittest
-from unittest.mock import MagicMock, patch
-
-from code_puppy.config import save_command_to_history
-from code_puppy.tui.app import CodePuppyTUI
-from code_puppy.tui.components.custom_widgets import CustomTextArea
-
-
-class TestTimestampedHistory(unittest.TestCase):
-    def setUp(self):
-        self.app = CodePuppyTUI()
-
-    @patch("code_puppy.tui.app.save_command_to_history")
-    def test_action_send_message_uses_timestamp_function(self, mock_save_command):
-        # Setup test mocks
-        self.app.query_one = MagicMock()
-        input_field_mock = MagicMock(spec=CustomTextArea)
-        input_field_mock.text = "test command"
-        self.app.query_one.return_value = input_field_mock
-
-        # Mock other methods to prevent full execution
-        self.app.add_user_message = MagicMock()
-        self.app._update_submit_cancel_button = MagicMock()
-        self.app.run_worker = MagicMock()
-
-        # Execute
-        self.app.action_send_message()
-
-        # Assertions
-        mock_save_command.assert_called_once_with("test command")
-        self.app.add_user_message.assert_called_once_with("test command")
-
-    @patch("datetime.datetime")
-    @patch("builtins.open", new_callable=unittest.mock.mock_open)
-    def test_save_command_uses_iso_timestamp(self, mock_file, mock_datetime):
-        # Setup
-        mock_now = MagicMock()
-        mock_now.isoformat.return_value = "2023-01-01T12:34:56"
-        mock_datetime.now.return_value = mock_now
-
-        # Call function
-        save_command_to_history("test command")
-
-        # Assertions
-        mock_file().write.assert_called_once_with(
-            "\n# 2023-01-01T12:34:56\ntest command\n"
-        )
-        mock_now.isoformat.assert_called_once_with(timespec="seconds")
-
-
-if __name__ == "__main__":
-    unittest.main()

code_puppy/tui/tests/test_tools.py

@@ -1,82 +0,0 @@
-"""
-Tests for ToolsScreen TUI component.
-"""
-
-from unittest.mock import patch
-
-from code_puppy.tools.tools_content import tools_content
-from code_puppy.tui.screens.tools import ToolsScreen
-
-
-class TestToolsScreen:
-    """Test cases for ToolsScreen functionality."""
-
-    def test_tools_screen_initialization(self):
-        """Test that ToolsScreen can be initialized."""
-        screen = ToolsScreen()
-        assert screen is not None
-        assert isinstance(screen, ToolsScreen)
-
-    def test_tools_content_import(self):
-        """Test that tools_content is imported correctly."""
-        # Verify that tools_content is a non-empty string
-        assert isinstance(tools_content, str)
-        assert len(tools_content) > 0
-        assert "File Operations" in tools_content
-        assert "Search & Analysis" in tools_content
-
-    def test_screen_composition(self):
-        """Test that screen has compose method and can be called."""
-        screen = ToolsScreen()
-
-        # Verify the compose method exists and is callable
-        assert hasattr(screen, "compose")
-        assert callable(screen.compose)
-
-    def test_markdown_widget_receives_tools_content(self):
-        """Test that Markdown widget receives tools_content."""
-        # Instead of actually executing compose, verify the tools.py implementation
-        # directly by examining the source code
-        import inspect
-
-        source = inspect.getsource(ToolsScreen.compose)
-
-        # Check that the compose method references tools_content
-        assert "tools_content" in source
-        # Check that Markdown is created with tools_content
-        assert "yield Markdown(tools_content" in source
-
-    def test_dismiss_functionality(self):
-        """Test that dismiss button works correctly."""
-        screen = ToolsScreen()
-
-        # Mock the dismiss method
-        with patch.object(screen, "dismiss") as mock_dismiss:
-            screen.dismiss_tools()
-
-        mock_dismiss.assert_called_once()
-
-    def test_escape_key_dismisses(self):
-        """Test that escape key dismisses the screen."""
-        screen = ToolsScreen()
-
-        # Create a mock key event
-        class MockKeyEvent:
-            key = "escape"
-
-        with patch.object(screen, "dismiss") as mock_dismiss:
-            screen.on_key(MockKeyEvent())
-
-        mock_dismiss.assert_called_once()
-
-    def test_non_escape_key_ignored(self):
-        """Test that non-escape keys don't dismiss the screen."""
-        screen = ToolsScreen()
-
-        class MockKeyEvent:
-            key = "enter"
-
-        with patch.object(screen, "dismiss") as mock_dismiss:
-            screen.on_key(MockKeyEvent())
-
-        mock_dismiss.assert_not_called()