code-puppy 0.0.153__py3-none-any.whl → 0.0.155__py3-none-any.whl

code_puppy/tui/tests/test_file_browser.py

@@ -1,60 +0,0 @@
-"""Tests for the FileBrowser component."""
-
-from unittest.mock import MagicMock
-
-import pytest
-
-# Import only Sidebar which exists, and skip FileBrowser
-from code_puppy.tui.components import Sidebar
-
-
-# Use pytest.skip for skipping the FileBrowser tests
-@pytest.mark.skip(reason="FileBrowser component has been removed from the codebase")
-class TestFileBrowser:
-    """Test the FileBrowser component."""
-
-    def test_file_browser_creation(self):
-        """Test that FileBrowser can be created."""
-        # Create a mock instead of the real component
-        browser = MagicMock()
-        assert browser is not None
-
-    def test_file_browser_has_directory_tree(self):
-        """Test that FileBrowser contains a DirectoryTree widget."""
-        browser = MagicMock()
-        browser.compose = MagicMock()
-        # This is a basic structure test - in a real app test we'd mount it
-        assert hasattr(browser, "compose")
-
-    def test_file_browser_message_type(self):
-        """Test that FileBrowser.FileSelected message works."""
-
-        # Create a mock message class
-        class MockFileSelected:
-            def __init__(self, file_path):
-                self.file_path = file_path
-
-        message = MockFileSelected("/test/path/file.py")
-        assert message.file_path == "/test/path/file.py"
-
-
-class TestSidebarTabs:
-    """Test the enhanced Sidebar with tabs."""
-
-    def test_sidebar_creation(self):
-        """Test that enhanced Sidebar can be created."""
-        sidebar = Sidebar()
-        assert sidebar is not None
-
-    def test_sidebar_has_compose_method(self):
-        """Test that Sidebar has the compose method for tab layout."""
-        sidebar = Sidebar()
-        assert hasattr(sidebar, "compose")
-        # Skip checking methods that may have been removed
-        # Comment out removed methods:
-        # assert hasattr(sidebar, "load_models_list")
-        # assert hasattr(sidebar, "on_file_browser_file_selected")
-
-
-if __name__ == "__main__":
-    pytest.main([__file__])

code_puppy/tui/tests/test_help.py

@@ -1,38 +0,0 @@
-import unittest
-
-from textual.app import App
-
-from code_puppy.tui.screens.help import HelpScreen
-
-
-class TestHelpScreen(unittest.TestCase):
-    def setUp(self):
-        self.screen = HelpScreen()
-
-    def test_get_help_content(self):
-        content = self.screen.get_help_content()
-        self.assertIn("Code Puppy TUI", content)
-
-    def test_compose(self):
-        # Create a minimal app context for testing
-        class TestApp(App):
-            def compose(self):
-                yield self.screen
-
-        app = TestApp()
-        self.screen = HelpScreen()
-
-        # Test that compose returns widgets without error
-        try:
-            # Use app.run_test() context to provide proper app context
-            with app:
-                widgets = list(self.screen.compose())
-                self.assertGreaterEqual(len(widgets), 1)
-        except Exception:
-            # If compose still fails, just verify the method exists
-            self.assertTrue(hasattr(self.screen, "compose"))
-            self.assertTrue(callable(getattr(self.screen, "compose")))
-
-
-if __name__ == "__main__":
-    unittest.main()

code_puppy/tui/tests/test_history_file_reader.py

@@ -1,107 +0,0 @@
-import os
-import tempfile
-import unittest
-
-from code_puppy.tui.models.command_history import HistoryFileReader
-
-
-class TestHistoryFileReader(unittest.TestCase):
-    def setUp(self):
-        # Create a temporary file for testing
-        self.temp_file = tempfile.NamedTemporaryFile(delete=False)
-        self.temp_file_path = self.temp_file.name
-
-        # Sample content with multiple commands
-        sample_content = """
-# 2023-01-01T12:00:00
-First command
-
-# 2023-01-01T13:00:00
-Second command
-with multiple lines
-
-# 2023-01-01T14:00:00
-Third command
-"""
-        # Write sample content to the temporary file
-        with open(self.temp_file_path, "w") as f:
-            f.write(sample_content)
-
-        # Initialize reader with the temp file
-        self.reader = HistoryFileReader(self.temp_file_path)
-
-    def tearDown(self):
-        # Clean up the temporary file
-        if os.path.exists(self.temp_file_path):
-            os.unlink(self.temp_file_path)
-
-    def test_read_history(self):
-        # Test reading history entries
-        entries = self.reader.read_history()
-
-        # Check that we have the correct number of entries
-        self.assertEqual(len(entries), 3)
-
-        # Check that entries are in reverse chronological order (newest first)
-        self.assertEqual(entries[0]["timestamp"], "2023-01-01T14:00:00")
-        self.assertEqual(entries[0]["command"], "Third command")
-
-        self.assertEqual(entries[1]["timestamp"], "2023-01-01T13:00:00")
-        self.assertEqual(entries[1]["command"], "Second command\nwith multiple lines")
-
-        self.assertEqual(entries[2]["timestamp"], "2023-01-01T12:00:00")
-        self.assertEqual(entries[2]["command"], "First command")
-
-    def test_read_history_with_limit(self):
-        # Test reading history with a limit
-        entries = self.reader.read_history(max_entries=2)
-
-        # Check that we only get the specified number of entries
-        self.assertEqual(len(entries), 2)
-
-        # Check that we get the most recent entries
-        self.assertEqual(entries[0]["timestamp"], "2023-01-01T14:00:00")
-        self.assertEqual(entries[1]["timestamp"], "2023-01-01T13:00:00")
-
-    def test_read_history_empty_file(self):
-        # Create an empty file
-        empty_file = tempfile.NamedTemporaryFile(delete=False)
-        empty_file_path = empty_file.name
-        empty_file.close()
-
-        try:
-            # Create reader with empty file
-            empty_reader = HistoryFileReader(empty_file_path)
-
-            # Should return empty list
-            entries = empty_reader.read_history()
-            self.assertEqual(len(entries), 0)
-        finally:
-            # Clean up
-            if os.path.exists(empty_file_path):
-                os.unlink(empty_file_path)
-
-    def test_read_history_nonexistent_file(self):
-        # Create reader with non-existent file
-        nonexistent_reader = HistoryFileReader("/nonexistent/file/path")
-
-        # Should return empty list, not raise an exception
-        entries = nonexistent_reader.read_history()
-        self.assertEqual(len(entries), 0)
-
-    def test_format_timestamp(self):
-        # Test default formatting
-        formatted = self.reader.format_timestamp("2023-01-01T12:34:56")
-        self.assertEqual(formatted, "12:34:56")
-
-        # Test custom format
-        formatted = self.reader.format_timestamp("2023-01-01T12:34:56", "%H:%M")
-        self.assertEqual(formatted, "12:34")
-
-        # Test invalid timestamp
-        formatted = self.reader.format_timestamp("invalid")
-        self.assertEqual(formatted, "invalid")
-
-
-if __name__ == "__main__":
-    unittest.main()

code_puppy/tui/tests/test_input_area.py

@@ -1,33 +0,0 @@
-import unittest
-
-from textual.app import App
-
-from code_puppy.tui.components.input_area import InputArea
-
-
-class TestInputArea(unittest.TestCase):
-    def setUp(self):
-        self.input_area = InputArea()
-
-    def test_compose(self):
-        # Create a minimal app context for testing
-        class TestApp(App):
-            def compose(self):
-                yield self.input_area
-
-        app = TestApp()
-        self.input_area = InputArea()
-
-        # Test that compose returns widgets without error
-        try:
-            with app:
-                widgets = list(self.input_area.compose())
-                self.assertGreaterEqual(len(widgets), 3)
-        except Exception:
-            # If compose still fails, just verify the method exists
-            self.assertTrue(hasattr(self.input_area, "compose"))
-            self.assertTrue(callable(getattr(self.input_area, "compose")))
-
-
-if __name__ == "__main__":
-    unittest.main()

code_puppy/tui/tests/test_settings.py

@@ -1,44 +0,0 @@
-import unittest
-
-from textual.app import App
-
-from code_puppy.tui.screens.settings import SettingsScreen
-
-
-class TestSettingsScreen(unittest.TestCase):
-    def setUp(self):
-        self.screen = SettingsScreen()
-
-    def test_compose(self):
-        # Create a minimal app context for testing
-        class TestApp(App):
-            def compose(self):
-                yield self.screen
-
-        app = TestApp()
-        self.screen = SettingsScreen()
-
-        # Test that compose returns widgets without error
-        try:
-            with app:
-                widgets = list(self.screen.compose())
-                self.assertGreaterEqual(len(widgets), 1)
-        except Exception:
-            # If compose still fails, just verify the method exists
-            self.assertTrue(hasattr(self.screen, "compose"))
-            self.assertTrue(callable(getattr(self.screen, "compose")))
-
-    def test_load_model_options_fallback(self):
-        class DummySelect:
-            def set_options(self, options):
-                self.options = options
-
-        select = DummySelect()
-        # Should fallback to default if file not found
-        self.screen.load_model_options(select)
-        self.assertTrue(hasattr(select, "options"))
-        self.assertGreaterEqual(len(select.options), 1)
-
-
-if __name__ == "__main__":
-    unittest.main()

code_puppy/tui/tests/test_sidebar.py

@@ -1,33 +0,0 @@
-import unittest
-
-from textual.app import App
-
-from code_puppy.tui.components.sidebar import Sidebar
-
-
-class TestSidebar(unittest.TestCase):
-    def setUp(self):
-        self.sidebar = Sidebar()
-
-    def test_compose(self):
-        # Create a minimal app context for testing
-        class TestApp(App):
-            def compose(self):
-                yield self.sidebar
-
-        app = TestApp()
-        self.sidebar = Sidebar()
-
-        # Test that compose returns widgets without error
-        try:
-            with app:
-                widgets = list(self.sidebar.compose())
-                self.assertGreaterEqual(len(widgets), 1)
-        except Exception:
-            # If compose still fails, just verify the method exists
-            self.assertTrue(hasattr(self.sidebar, "compose"))
-            self.assertTrue(callable(getattr(self.sidebar, "compose")))
-
-
-if __name__ == "__main__":
-    unittest.main()

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()