chore: more test coverage

Author: damassi

tests/components/test_chat_history.py

@@ -0,0 +1,79 @@
+import pytest
+from textual.app import App, ComposeResult
+
+from agent_chat_cli.components.chat_history import ChatHistory
+from agent_chat_cli.components.messages import (
+    Message,
+    SystemMessage,
+    UserMessage,
+    AgentMessage,
+    ToolMessage,
+)
+
+
+class ChatHistoryApp(App):
+    def compose(self) -> ComposeResult:
+        yield ChatHistory()
+
+
+class TestChatHistoryAddMessage:
+    @pytest.fixture
+    def app(self):
+        return ChatHistoryApp()
+
+    async def test_adds_system_message(self, app):
+        async with app.run_test():
+            chat_history = app.query_one(ChatHistory)
+            chat_history.add_message(Message.system("System alert"))
+
+            widgets = chat_history.query(SystemMessage)
+            assert len(widgets) == 1
+            assert widgets.first().message == "System alert"
+
+    async def test_adds_user_message(self, app):
+        async with app.run_test():
+            chat_history = app.query_one(ChatHistory)
+            chat_history.add_message(Message.user("Hello"))
+
+            widgets = chat_history.query(UserMessage)
+            assert len(widgets) == 1
+            assert widgets.first().message == "Hello"
+
+    async def test_adds_agent_message(self, app):
+        async with app.run_test():
+            chat_history = app.query_one(ChatHistory)
+            chat_history.add_message(Message.agent("I can help"))
+
+            widgets = chat_history.query(AgentMessage)
+            assert len(widgets) == 1
+            assert widgets.first().message == "I can help"
+
+    async def test_adds_tool_message_with_json_content(self, app):
+        async with app.run_test():
+            chat_history = app.query_one(ChatHistory)
+            chat_history.add_message(
+                Message.tool("read_file", '{"path": "/tmp/test.txt"}')
+            )
+
+            widgets = chat_history.query(ToolMessage)
+            assert len(widgets) == 1
+            assert widgets.first().tool_name == "read_file"
+            assert widgets.first().tool_input == {"path": "/tmp/test.txt"}
+
+    async def test_tool_message_handles_invalid_json(self, app):
+        async with app.run_test():
+            chat_history = app.query_one(ChatHistory)
+            chat_history.add_message(Message.tool("bash", "not valid json"))
+
+            widgets = chat_history.query(ToolMessage)
+            assert len(widgets) == 1
+            assert widgets.first().tool_input == {"raw": "not valid json"}
+
+    async def test_adds_multiple_messages(self, app):
+        async with app.run_test():
+            chat_history = app.query_one(ChatHistory)
+            chat_history.add_message(Message.user("First"))
+            chat_history.add_message(Message.agent("Second"))
+            chat_history.add_message(Message.user("Third"))
+
+            assert len(chat_history.children) == 3

tests/components/test_header.py

@@ -0,0 +1,60 @@
+import pytest
+from unittest.mock import MagicMock, patch
+
+from textual.app import App, ComposeResult
+from textual.widgets import Label
+
+from agent_chat_cli.components.header import Header
+from agent_chat_cli.utils.mcp_server_status import MCPServerStatus
+
+
+@pytest.fixture(autouse=True)
+def reset_mcp_status():
+    MCPServerStatus._mcp_servers = []
+    MCPServerStatus._callbacks = []
+    yield
+    MCPServerStatus._mcp_servers = []
+    MCPServerStatus._callbacks = []
+
+
+@pytest.fixture
+def mock_config():
+    with patch("agent_chat_cli.components.header.load_config") as mock:
+        mock.return_value = MagicMock(
+            mcp_servers={"filesystem": MagicMock(), "github": MagicMock()},
+            agents={"researcher": MagicMock()},
+        )
+        yield mock
+
+
+class HeaderApp(App):
+    def compose(self) -> ComposeResult:
+        yield Header()
+
+
+class TestHeaderMCPServerStatus:
+    async def test_subscribes_on_mount(self, mock_config):
+        app = HeaderApp()
+        async with app.run_test():
+            assert len(MCPServerStatus._callbacks) == 1
+
+    async def test_updates_label_on_status_change(self, mock_config):
+        app = HeaderApp()
+        async with app.run_test():
+            MCPServerStatus.update(
+                [
+                    {"name": "filesystem", "status": "connected"},
+                    {"name": "github", "status": "error"},
+                ]
+            )
+
+            header = app.query_one(Header)
+            header._handle_mcp_server_status()
+
+            label = app.query_one("#header-mcp-servers", Label)
+            # Label stores markup in _content or we can check via render
+            content = label.render()
+            rendered = str(content)
+
+            assert "filesystem" in rendered
+            assert "github" in rendered

tests/components/test_thinking_indicator.py

@@ -0,0 +1,35 @@
+import pytest
+from textual.app import App, ComposeResult
+
+from agent_chat_cli.components.thinking_indicator import ThinkingIndicator
+
+
+class ThinkingIndicatorApp(App):
+    def compose(self) -> ComposeResult:
+        yield ThinkingIndicator()
+
+
+class TestThinkingIndicator:
+    @pytest.fixture
+    def app(self):
+        return ThinkingIndicatorApp()
+
+    async def test_hidden_by_default(self, app):
+        async with app.run_test():
+            indicator = app.query_one(ThinkingIndicator)
+            assert indicator.display is False
+
+    async def test_is_thinking_true_shows_indicator(self, app):
+        async with app.run_test():
+            indicator = app.query_one(ThinkingIndicator)
+            indicator.is_thinking = True
+
+            assert indicator.display is True
+
+    async def test_is_thinking_false_hides_indicator(self, app):
+        async with app.run_test():
+            indicator = app.query_one(ThinkingIndicator)
+            indicator.is_thinking = True
+            indicator.is_thinking = False
+
+            assert indicator.display is False

tests/components/test_tool_permission_prompt.py

@@ -0,0 +1,108 @@
+import pytest
+from unittest.mock import AsyncMock, MagicMock
+
+from textual.app import App, ComposeResult
+from textual.widgets import TextArea, Label
+
+from agent_chat_cli.components.tool_permission_prompt import ToolPermissionPrompt
+
+
+class ToolPermissionPromptApp(App):
+    def __init__(self):
+        super().__init__()
+        self.mock_actions = MagicMock()
+        self.mock_actions.respond_to_tool_permission = AsyncMock()
+
+    def compose(self) -> ComposeResult:
+        yield ToolPermissionPrompt(actions=self.mock_actions)
+
+
+class TestToolPermissionPromptVisibility:
+    @pytest.fixture
+    def app(self):
+        return ToolPermissionPromptApp()
+
+    async def test_hidden_by_default(self, app):
+        async with app.run_test():
+            prompt = app.query_one(ToolPermissionPrompt)
+            assert prompt.display is False
+
+    async def test_is_visible_true_shows_prompt(self, app):
+        async with app.run_test():
+            prompt = app.query_one(ToolPermissionPrompt)
+            prompt.is_visible = True
+
+            assert prompt.display is True
+
+    async def test_is_visible_clears_input_on_show(self, app):
+        async with app.run_test():
+            prompt = app.query_one(ToolPermissionPrompt)
+            input_widget = prompt.query_one("#permission-input", TextArea)
+            input_widget.insert("leftover text")
+
+            prompt.is_visible = True
+
+            assert input_widget.text == ""
+
+
+class TestToolPermissionPromptToolDisplay:
+    @pytest.fixture
+    def app(self):
+        return ToolPermissionPromptApp()
+
+    async def test_displays_mcp_tool_with_server_name(self, app):
+        async with app.run_test():
+            prompt = app.query_one(ToolPermissionPrompt)
+            prompt.tool_name = "mcp__filesystem__read_file"
+
+            label = prompt.query_one("#tool-display", Label)
+            rendered = str(label.render())
+
+            assert "filesystem" in rendered
+            assert "read_file" in rendered
+
+    async def test_displays_non_mcp_tool(self, app):
+        async with app.run_test():
+            prompt = app.query_one(ToolPermissionPrompt)
+            prompt.tool_name = "bash"
+
+            label = prompt.query_one("#tool-display", Label)
+            rendered = str(label.render())
+
+            assert "bash" in rendered
+
+
+class TestToolPermissionPromptSubmit:
+    @pytest.fixture
+    def app(self):
+        return ToolPermissionPromptApp()
+
+    async def test_empty_submit_defaults_to_yes(self, app):
+        async with app.run_test():
+            prompt = app.query_one(ToolPermissionPrompt)
+            prompt.is_visible = True
+
+            await prompt.action_submit()
+
+            app.mock_actions.respond_to_tool_permission.assert_called_with("yes")
+
+    async def test_submit_with_text(self, app):
+        async with app.run_test():
+            prompt = app.query_one(ToolPermissionPrompt)
+            prompt.is_visible = True
+
+            input_widget = prompt.query_one("#permission-input", TextArea)
+            input_widget.insert("no")
+
+            await prompt.action_submit()
+
+            app.mock_actions.respond_to_tool_permission.assert_called_with("no")
+
+    async def test_escape_submits_no(self, app):
+        async with app.run_test() as pilot:
+            prompt = app.query_one(ToolPermissionPrompt)
+            prompt.is_visible = True
+
+            await pilot.press("escape")
+
+            app.mock_actions.respond_to_tool_permission.assert_called_with("no")

tests/components/test_user_input.py

@@ -0,0 +1,96 @@
+import pytest
+from unittest.mock import AsyncMock, MagicMock
+
+from textual.app import App, ComposeResult
+from textual.widgets import TextArea
+
+from agent_chat_cli.components.user_input import UserInput
+
+
+class UserInputApp(App):
+    def __init__(self):
+        super().__init__()
+        self.mock_actions = MagicMock()
+        self.mock_actions.quit = MagicMock()
+        self.mock_actions.interrupt = AsyncMock()
+        self.mock_actions.new = AsyncMock()
+        self.mock_actions.submit_user_message = AsyncMock()
+
+    def compose(self) -> ComposeResult:
+        yield UserInput(actions=self.mock_actions)
+
+
+class TestUserInputSubmit:
+    @pytest.fixture
+    def app(self):
+        return UserInputApp()
+
+    async def test_empty_submit_does_nothing(self, app):
+        async with app.run_test() as pilot:
+            await pilot.press("enter")
+
+            app.mock_actions.submit_user_message.assert_not_called()
+
+    async def test_submits_message(self, app):
+        async with app.run_test() as pilot:
+            user_input = app.query_one(UserInput)
+            text_area = user_input.query_one(TextArea)
+            text_area.insert("Hello agent")
+
+            await pilot.press("enter")
+
+            app.mock_actions.submit_user_message.assert_called_with("Hello agent")
+
+    async def test_clears_input_after_submit(self, app):
+        async with app.run_test() as pilot:
+            user_input = app.query_one(UserInput)
+            text_area = user_input.query_one(TextArea)
+            text_area.insert("Hello agent")
+
+            await pilot.press("enter")
+
+            assert text_area.text == ""
+
+
+class TestUserInputControlCommands:
+    @pytest.fixture
+    def app(self):
+        return UserInputApp()
+
+    async def test_exit_command_quits(self, app):
+        async with app.run_test() as pilot:
+            user_input = app.query_one(UserInput)
+            text_area = user_input.query_one(TextArea)
+            text_area.insert("exit")
+
+            await pilot.press("enter")
+
+            app.mock_actions.quit.assert_called_once()
+
+    async def test_clear_command_resets_conversation(self, app):
+        async with app.run_test() as pilot:
+            user_input = app.query_one(UserInput)
+            text_area = user_input.query_one(TextArea)
+            text_area.insert("clear")
+
+            await pilot.press("enter")
+
+            app.mock_actions.interrupt.assert_called_once()
+            app.mock_actions.new.assert_called_once()
+
+
+class TestUserInputNewlines:
+    @pytest.fixture
+    def app(self):
+        return UserInputApp()
+
+    async def test_ctrl_j_inserts_newline(self, app):
+        async with app.run_test() as pilot:
+            user_input = app.query_one(UserInput)
+            text_area = user_input.query_one(TextArea)
+            text_area.insert("line1")
+
+            await pilot.press("ctrl+j")
+            text_area.insert("line2")
+
+            assert "line1\nline2" in text_area.text