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

code_puppy/tui/tests/test_copy_button.py

@@ -1,191 +0,0 @@
-"""
-Tests for the copy button component.
-"""
-
-from unittest.mock import MagicMock, patch
-
-from code_puppy.tui.components.copy_button import CopyButton
-
-
-class TestCopyButton:
-    """Test cases for the CopyButton widget."""
-
-    def test_copy_button_creation(self):
-        """Test that a copy button can be created with text."""
-        test_text = "Hello, World!"
-        button = CopyButton(test_text)
-
-        assert button.text_to_copy == test_text
-        assert button.label == "📋 Copy"
-
-    def test_update_text_to_copy(self):
-        """Test updating the text to copy."""
-        button = CopyButton("Initial text")
-        new_text = "Updated text"
-
-        button.update_text_to_copy(new_text)
-
-        assert button.text_to_copy == new_text
-
-    @patch("subprocess.run")
-    def test_copy_to_clipboard_macos_success(self, mock_run):
-        """Test successful clipboard copy on macOS."""
-        mock_run.return_value = MagicMock(returncode=0)
-
-        with patch("sys.platform", "darwin"):
-            button = CopyButton("test content")
-            success, error = button.copy_to_clipboard("test content")
-
-            assert success is True
-            assert error is None
-            mock_run.assert_called_once_with(
-                ["pbcopy"],
-                input="test content",
-                text=True,
-                check=True,
-                capture_output=True,
-            )
-
-    @patch("subprocess.run")
-    def test_copy_to_clipboard_windows_success(self, mock_run):
-        """Test successful clipboard copy on Windows."""
-        mock_run.return_value = MagicMock(returncode=0)
-
-        with patch("sys.platform", "win32"):
-            button = CopyButton("test content")
-            success, error = button.copy_to_clipboard("test content")
-
-            assert success is True
-            assert error is None
-            mock_run.assert_called_once_with(
-                ["clip"],
-                input="test content",
-                text=True,
-                check=True,
-                capture_output=True,
-            )
-
-    @patch("subprocess.run")
-    def test_copy_to_clipboard_linux_success(self, mock_run):
-        """Test successful clipboard copy on Linux with xclip."""
-        mock_run.return_value = MagicMock(returncode=0)
-
-        with patch("sys.platform", "linux"):
-            button = CopyButton("test content")
-            success, error = button.copy_to_clipboard("test content")
-
-            assert success is True
-            assert error is None
-            mock_run.assert_called_once_with(
-                ["xclip", "-selection", "clipboard"],
-                input="test content",
-                text=True,
-                check=True,
-                capture_output=True,
-            )
-
-    @patch("subprocess.run")
-    def test_copy_to_clipboard_linux_xsel_fallback(self, mock_run):
-        """Test Linux clipboard copy falls back to xsel when xclip fails."""
-        # First call (xclip) fails, second call (xsel) succeeds
-        mock_run.side_effect = [
-            FileNotFoundError("xclip not found"),
-            MagicMock(returncode=0),
-        ]
-
-        with patch("sys.platform", "linux"):
-            button = CopyButton("test content")
-            success, error = button.copy_to_clipboard("test content")
-
-            assert success is True
-            assert error is None
-            assert mock_run.call_count == 2
-            # Check that xsel was called as fallback
-            mock_run.assert_any_call(
-                ["xsel", "--clipboard", "--input"],
-                input="test content",
-                text=True,
-                check=True,
-                capture_output=True,
-            )
-
-    @patch("subprocess.run")
-    def test_copy_to_clipboard_failure(self, mock_run):
-        """Test clipboard copy failure handling."""
-        from subprocess import CalledProcessError
-
-        mock_run.side_effect = CalledProcessError(1, "pbcopy", "Command failed")
-
-        with patch("sys.platform", "darwin"):
-            button = CopyButton("test content")
-            success, error = button.copy_to_clipboard("test content")
-
-            assert success is False
-            assert "Clipboard command failed" in error
-
-    @patch("subprocess.run")
-    def test_copy_to_clipboard_no_utility(self, mock_run):
-        """Test clipboard copy when utility is not found."""
-        mock_run.side_effect = FileNotFoundError("Command not found")
-
-        with patch("sys.platform", "linux"):
-            button = CopyButton("test content")
-            success, error = button.copy_to_clipboard("test content")
-
-            assert success is False
-            assert "Clipboard utilities not found" in error
-
-    def test_copy_button_labels(self):
-        """Test that copy button has correct labels."""
-        button = CopyButton("test")
-
-        assert button._original_label == "📋 Copy"
-        assert button._copied_label == "✅ Copied!"
-
-    def test_copy_completed_message(self):
-        """Test CopyCompleted message creation."""
-        # Test success message
-        success_msg = CopyButton.CopyCompleted(True)
-        assert success_msg.success is True
-        assert success_msg.error is None
-
-        # Test error message
-        error_msg = CopyButton.CopyCompleted(False, "Test error")
-        assert error_msg.success is False
-        assert error_msg.error == "Test error"
-
-    @patch.object(CopyButton, "copy_to_clipboard")
-    @patch.object(CopyButton, "post_message")
-    def test_action_press_success(self, mock_post_message, mock_copy):
-        """Test action_press method with successful copy."""
-        mock_copy.return_value = (True, None)
-
-        button = CopyButton("test content")
-        button.action_press()
-
-        mock_copy.assert_called_once_with("test content")
-        mock_post_message.assert_called_once()
-        # Note: timer is currently commented out in implementation
-
-        # Check that the message posted is a CopyCompleted with success=True
-        call_args = mock_post_message.call_args[0][0]
-        assert isinstance(call_args, CopyButton.CopyCompleted)
-        assert call_args.success is True
-
-    @patch.object(CopyButton, "copy_to_clipboard")
-    @patch.object(CopyButton, "post_message")
-    def test_action_press_failure(self, mock_post_message, mock_copy):
-        """Test action_press method with failed copy."""
-        mock_copy.return_value = (False, "Test error")
-
-        button = CopyButton("test content")
-        button.action_press()
-
-        mock_copy.assert_called_once_with("test content")
-        mock_post_message.assert_called_once()
-
-        # Check that the message posted is a CopyCompleted with success=False
-        call_args = mock_post_message.call_args[0][0]
-        assert isinstance(call_args, CopyButton.CopyCompleted)
-        assert call_args.success is False
-        assert call_args.error == "Test error"

code_puppy/tui/tests/test_custom_widgets.py

@@ -1,27 +0,0 @@
-import unittest
-
-from code_puppy.tui.components.custom_widgets import CustomTextArea
-
-
-class DummyEvent:
-    def __init__(self, key):
-        self.key = key
-
-
-class TestCustomTextArea(unittest.TestCase):
-    def setUp(self):
-        self.text_area = CustomTextArea()
-
-    def test_message_sent_on_enter(self):
-        # Simulate pressing Enter
-        event = DummyEvent("enter")
-        # Should not raise
-        self.text_area._on_key(event)
-
-    def test_message_sent_class(self):
-        msg = CustomTextArea.MessageSent()
-        self.assertIsInstance(msg, CustomTextArea.MessageSent)
-
-
-if __name__ == "__main__":
-    unittest.main()

code_puppy/tui/tests/test_disclaimer.py

@@ -1,27 +0,0 @@
-import unittest
-from unittest.mock import MagicMock
-
-# Skip importing the non-existent module
-# Commenting out: from code_puppy.tui.screens.disclaimer import DisclaimerScreen
-
-
-# We'll use unittest.skip to skip the entire test class
-@unittest.skip("DisclaimerScreen has been removed from the codebase")
-class TestDisclaimerScreen(unittest.TestCase):
-    def setUp(self):
-        # Create a mock screen instead of the real one
-        self.screen = MagicMock()
-        self.screen.get_disclaimer_content.return_value = "Prompt responsibly"
-        self.screen.compose.return_value = [MagicMock()]
-
-    def test_get_disclaimer_content(self):
-        content = self.screen.get_disclaimer_content()
-        self.assertIn("Prompt responsibly", content)
-
-    def test_compose(self):
-        widgets = list(self.screen.compose())
-        self.assertGreaterEqual(len(widgets), 1)
-
-
-if __name__ == "__main__":
-    unittest.main()

code_puppy/tui/tests/test_enums.py

@@ -1,15 +0,0 @@
-import unittest
-
-from code_puppy.tui.models.enums import MessageType
-
-
-class TestMessageType(unittest.TestCase):
-    def test_enum_values(self):
-        self.assertEqual(MessageType.USER.value, "user")
-        self.assertEqual(MessageType.AGENT.value, "agent")
-        self.assertEqual(MessageType.SYSTEM.value, "system")
-        self.assertEqual(MessageType.ERROR.value, "error")
-
-
-if __name__ == "__main__":
-    unittest.main()

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