@pennyfarthing/core 11.2.0 → 11.2.2

package/pennyfarthing_scripts/tests/test_sprint_panel.py

@@ -6,13 +6,13 @@ Epic: 103 — BikeRack TUI (MSSCI-14951)
 Acceptance Criteria:
 - [AC1] SprintPanel subscribes to /ws/sprint channel
 - [AC2] Receives and parses JSON payloads: {type, currentStory, nextStory, epics, ...}
-- [AC3] Renders sprint status as Rich table: story ID, title, status, points, Jira status
+- [AC3] Renders sprint status with epic/story tree hierarchy
 - [AC4] Displays velocity and sprint metrics
 - [AC5] Default panel on TUI launch
 - [AC6] Updates in real-time when data changes on channel
 - [AC7] All tests GREEN (Dev phase)
 
-Tests should FAIL until sprint_panel.py is fully implemented.
+Migrated to Textual Tree widget from Rich Table rendering.
 """
 
 from __future__ import annotations
@@ -21,11 +21,17 @@ from typing import Any
 from unittest.mock import MagicMock, patch
 
 import pytest
-from rich.table import Table
 from rich.text import Text
 
-from pennyfarthing_scripts.bikerack.base_panel import BasePanel
-from pennyfarthing_scripts.bikerack.sprint_panel import SprintPanel
+from pennyfarthing_scripts.bikerack.sprint_panel import (
+    SprintPanel,
+    _build_epic_label,
+    _build_story_label,
+    _format_assignee,
+    _is_terminal,
+    _should_expand,
+    _status_badge,
+)
 
 # ---------------------------------------------------------------------------
 # Fixtures
@@ -177,19 +183,20 @@ class TestSprintPanelChannel:
         panel = SprintPanel()
         assert panel.channel == "sprint"
 
-    def test_inherits_base_panel(self) -> None:
-        """SprintPanel should be a BasePanel subclass."""
-        assert issubclass(SprintPanel, BasePanel)
+    def test_is_widget_subclass(self) -> None:
+        """SprintPanel should be a Widget subclass."""
+        from textual.widget import Widget
+
+        assert issubclass(SprintPanel, Widget)
 
     def test_subscribes_on_mount(self, panel: SprintPanel, mock_client: MagicMock) -> None:
         """SprintPanel should subscribe to 'sprint' channel on mount."""
         panel.on_mount()
-        mock_client.subscribe.assert_called_once_with("sprint", panel.handle_message)
+        mock_client.subscribe.assert_called_once_with("sprint", panel._handle_ws_message)
 
     def test_no_subscribe_without_client(self) -> None:
         """SprintPanel should not crash on mount without client."""
         panel = SprintPanel(client=None)
-        # Should not raise
         panel.on_mount()
 
 
@@ -201,117 +208,283 @@ class TestSprintPanelChannel:
 class TestSprintPanelParsing:
     """AC2: Receives and parses JSON payloads correctly."""
 
-    def test_handles_init_message_type(self, panel: SprintPanel) -> None:
-        """render_panel should handle 'init' type messages."""
-        result = panel.render_panel(SAMPLE_INIT_PAYLOAD)
-        # Should return something meaningful, not empty/None
-        assert result is not None
-        assert result != ""
-
-    def test_handles_update_message_type(self, panel: SprintPanel) -> None:
-        """render_panel should handle 'update' type messages."""
-        result = panel.render_panel(SAMPLE_UPDATE_PAYLOAD)
-        assert result is not None
-        assert result != ""
-
-    def test_handles_empty_epics(self, panel: SprintPanel) -> None:
-        """render_panel should handle payload with empty epics list."""
-        payload = {**SAMPLE_INIT_PAYLOAD, "epics": []}
-        result = panel.render_panel(payload)
-        assert result is not None
-        assert result != ""
-
-    def test_handles_null_current_story(self, panel: SprintPanel) -> None:
-        """render_panel should handle null currentStory."""
-        payload = {**SAMPLE_INIT_PAYLOAD, "currentStory": None}
-        result = panel.render_panel(payload)
-        assert result is not None
-        assert result != ""
-
-    def test_handles_multi_epic_payload(self, panel: SprintPanel) -> None:
-        """render_panel should handle payloads with multiple epics."""
-        result = panel.render_panel(SAMPLE_MULTI_EPIC_PAYLOAD)
-        assert result is not None
-        assert result != ""
+    def test_stores_payload(self, panel: SprintPanel) -> None:
+        """_handle_ws_message should store the payload."""
+        panel._mounted = True
+        with patch.object(panel, "post_message"):
+            panel._handle_ws_message(SAMPLE_INIT_PAYLOAD)
+            assert panel._last_payload == SAMPLE_INIT_PAYLOAD
+
+    def test_ignores_none(self, panel: SprintPanel) -> None:
+        """_handle_ws_message should ignore None messages."""
+        panel._mounted = True
+        with patch.object(panel, "post_message") as mock_post:
+            panel._handle_ws_message(None)
+            mock_post.assert_not_called()
+
+    def test_ignores_after_unmount(self, panel: SprintPanel) -> None:
+        """Messages after unmount should be ignored."""
+        panel._mounted = True
+        panel.on_unmount()
+        with patch.object(panel, "post_message") as mock_post:
+            panel._handle_ws_message(SAMPLE_INIT_PAYLOAD)
+            mock_post.assert_not_called()
 
 
 # ---------------------------------------------------------------------------
-# AC3: Renders sprint status as Rich table with columns
+# AC3: Renders sprint status with epic/story tree hierarchy
 # ---------------------------------------------------------------------------
 
 
-class TestSprintPanelRendering:
-    """AC3: Renders sprint status as Rich table with correct columns."""
-
-    def test_render_returns_rich_renderable(self, panel: SprintPanel) -> None:
-        """render_panel should return a Rich renderable (Table or Group)."""
-        result = panel.render_panel(SAMPLE_INIT_PAYLOAD)
-        # Must be a Rich renderable — at minimum, not a plain string
-        assert not isinstance(result, str), "render_panel should return Rich renderable, not str"
-
-    def test_render_contains_table(self, panel: SprintPanel) -> None:
-        """render_panel output should contain a Rich Table."""
-        result = panel.render_panel(SAMPLE_INIT_PAYLOAD)
-        # Result is either a Table directly or a Group containing a Table
-        if isinstance(result, Table):
-            table = result
-        else:
-            # Check if result contains a Table (for Group/renderables)
-            tables = [r for r in getattr(result, "renderables", [result]) if isinstance(r, Table)]
-            assert len(tables) > 0, "Output should contain at least one Rich Table"
-            table = tables[0]
-        assert isinstance(table, Table)
-
-    def test_table_has_id_column(self, panel: SprintPanel) -> None:
-        """Story table should have an ID column."""
-        result = panel.render_panel(SAMPLE_INIT_PAYLOAD)
-        table = _extract_table(result)
-        column_names = [col.header.plain if isinstance(col.header, Text) else str(col.header) for col in table.columns]
-        assert any("id" in name.lower() for name in column_names), f"Expected 'ID' column, got: {column_names}"
-
-    def test_table_has_title_column(self, panel: SprintPanel) -> None:
-        """Story table should have a Title column."""
-        result = panel.render_panel(SAMPLE_INIT_PAYLOAD)
-        table = _extract_table(result)
-        column_names = [col.header.plain if isinstance(col.header, Text) else str(col.header) for col in table.columns]
-        assert any("title" in name.lower() for name in column_names), f"Expected 'Title' column, got: {column_names}"
-
-    def test_table_has_status_column(self, panel: SprintPanel) -> None:
-        """Story table should have a Status column."""
-        result = panel.render_panel(SAMPLE_INIT_PAYLOAD)
-        table = _extract_table(result)
-        column_names = [col.header.plain if isinstance(col.header, Text) else str(col.header) for col in table.columns]
-        assert any("status" in name.lower() for name in column_names), f"Expected 'Status' column, got: {column_names}"
-
-    def test_table_has_points_column(self, panel: SprintPanel) -> None:
-        """Story table should have a Points column."""
-        result = panel.render_panel(SAMPLE_INIT_PAYLOAD)
-        table = _extract_table(result)
-        column_names = [col.header.plain if isinstance(col.header, Text) else str(col.header) for col in table.columns]
-        assert any("pts" in name.lower() or "points" in name.lower() for name in column_names), (
-            f"Expected 'Points' column, got: {column_names}"
-        )
+class TestStatusBadge:
+    """Status badge helper produces symbol-only Rich Text (no text word)."""
+
+    def test_done_badge(self) -> None:
+        badge = _status_badge("done")
+        assert "\u2713" in badge.plain
+        assert "done" not in badge.plain
+
+    def test_in_progress_badge(self) -> None:
+        badge = _status_badge("in-progress")
+        assert "\u27f3" in badge.plain
+        assert "in-progress" not in badge.plain
+
+    def test_in_progress_underscore(self) -> None:
+        """Handle both 'in-progress' and 'in_progress' status strings."""
+        badge = _status_badge("in_progress")
+        assert "\u27f3" in badge.plain
+
+    def test_backlog_badge(self) -> None:
+        badge = _status_badge("backlog")
+        assert "\u25ef" in badge.plain
+        assert "backlog" not in badge.plain
+
+    def test_blocked_badge(self) -> None:
+        badge = _status_badge("blocked")
+        assert "!" in badge.plain
+        assert "blocked" not in badge.plain
+
+    def test_review_badge(self) -> None:
+        badge = _status_badge("review")
+        assert "\u25ce" in badge.plain
+        assert "review" not in badge.plain
+
+    def test_canceled_badge(self) -> None:
+        badge = _status_badge("canceled")
+        assert "\u2715" in badge.plain
+
+    def test_cancelled_british_spelling(self) -> None:
+        badge = _status_badge("cancelled")
+        assert "\u2715" in badge.plain
+
+    def test_unknown_status(self) -> None:
+        badge = _status_badge("unknown-status")
+        assert "\u2014" in badge.plain
+
+
+class TestEpicLabel:
+    """Epic label builder produces correct Rich Text."""
+
+    def test_includes_epic_id_fallback(self) -> None:
+        label = _build_epic_label("103", "BikeRack TUI", 4, 6)
+        assert "103" in label.plain
+
+    def test_includes_jira_key_when_provided(self) -> None:
+        label = _build_epic_label("103", "BikeRack TUI", 4, 6, jira_key="MSSCI-14510")
+        assert "MSSCI-14510" in label.plain
+
+    def test_long_id_gets_ellipsed(self) -> None:
+        label = _build_epic_label("standalone", "Standalone Stories", 2, 7, jira_key="epic-standalone")
+        plain = label.plain
+        assert "\u2026" in plain, f"Long ID should be ellipsed, got: {plain}"
+        # Should not exceed 11 chars for the ID portion
+        id_part = plain.split("  ")[0]
+        assert len(id_part) <= 11
+
+    def test_includes_progress(self) -> None:
+        label = _build_epic_label("103", "BikeRack TUI", 4, 6)
+        assert "4/6 pts" in label.plain
+
+    def test_includes_title(self) -> None:
+        label = _build_epic_label("103", "BikeRack TUI", 4, 6)
+        assert "BikeRack TUI" in label.plain
+
+    def test_zero_points(self) -> None:
+        label = _build_epic_label("100", "Empty", 0, 0)
+        assert "0 pts" in label.plain
+
+
+class TestStoryLabel:
+    """Story label builder produces correct Rich Text."""
+
+    def test_includes_jira_key(self) -> None:
+        story = {"id": "103-1", "title": "Scaffold", "points": 2, "status": "done", "jiraKey": "MSSCI-14952"}
+        label = _build_story_label(story, "")
+        assert "MSSCI-14952" in label.plain
+
+    def test_includes_points(self) -> None:
+        story = {"id": "103-1", "title": "Scaffold", "points": 2, "status": "done", "jiraKey": "MSSCI-14952"}
+        label = _build_story_label(story, "")
+        assert "2" in label.plain
+
+    def test_includes_title(self) -> None:
+        story = {"id": "103-1", "title": "Scaffold", "points": 2, "status": "done", "jiraKey": "MSSCI-14952"}
+        label = _build_story_label(story, "")
+        assert "Scaffold" in label.plain
+
+    def test_null_jira_key_shows_dash(self) -> None:
+        story = {"id": "103-1", "title": "Test", "points": 1, "status": "backlog", "jiraKey": None}
+        label = _build_story_label(story, "")
+        assert "\u2014" in label.plain
+
+    def test_current_story_bolded(self) -> None:
+        story = {"id": "103-6", "title": "Current", "points": 2, "status": "in-progress", "jiraKey": "X"}
+        label = _build_story_label(story, "103-6")
+        has_bold = any("bold" in str(span.style) for span in label._spans)
+        assert has_bold, "Current story should have bold styling"
+
+    def test_done_story_is_dim(self) -> None:
+        story = {"id": "103-1", "title": "Done one", "points": 2, "status": "done", "jiraKey": "MSSCI-14952"}
+        label = _build_story_label(story, "")
+        # Overall dim styling applied to done stories
+        has_dim = any("dim" in str(span.style) for span in label._spans)
+        assert has_dim, "Done story should have dim styling"
+
+
+class TestFormatAssignee:
+    """Email to display name formatting."""
+
+    def test_standard_email(self) -> None:
+        assert _format_assignee("keith.avery@1898andco.io") == "K. Avery"
+
+    def test_underscore_email(self) -> None:
+        assert _format_assignee("john_doe@example.com") == "J. Doe"
+
+    def test_none_returns_empty(self) -> None:
+        assert _format_assignee(None) == ""
+
+    def test_empty_string_returns_empty(self) -> None:
+        assert _format_assignee("") == ""
+
+    def test_single_part_local(self) -> None:
+        result = _format_assignee("admin@example.com")
+        assert result == "Admin"
+
+
+class TestStoryLabelOwner:
+    """Owner shown for in-progress stories, hidden for done/backlog."""
+
+    def test_in_progress_shows_owner(self) -> None:
+        story = {
+            "id": "110-2", "title": "Drill", "points": 5,
+            "status": "in-progress", "jiraKey": "MSSCI-15186",
+            "assignee": "keith.avery@1898andco.io",
+        }
+        label = _build_story_label(story, "")
+        assert "K. Avery" in label.plain
+
+    def test_done_hides_owner(self) -> None:
+        story = {
+            "id": "110-1", "title": "Done", "points": 3,
+            "status": "done", "jiraKey": "MSSCI-15185",
+            "assignee": "keith.avery@1898andco.io",
+        }
+        label = _build_story_label(story, "")
+        assert "K. Avery" not in label.plain
+
+    def test_backlog_hides_owner(self) -> None:
+        story = {
+            "id": "110-3", "title": "Backlog", "points": 3,
+            "status": "backlog", "jiraKey": "MSSCI-15187",
+            "assignee": "keith.avery@1898andco.io",
+        }
+        label = _build_story_label(story, "")
+        assert "K. Avery" not in label.plain
+
+    def test_in_progress_no_assignee(self) -> None:
+        story = {
+            "id": "110-2", "title": "Drill", "points": 5,
+            "status": "in-progress", "jiraKey": "MSSCI-15186",
+        }
+        label = _build_story_label(story, "")
+        assert "[" not in label.plain or "[]" not in label.plain
+
+    def test_canceled_story_is_dim(self) -> None:
+        story = {
+            "id": "110-4", "title": "Canceled one", "points": 2,
+            "status": "canceled", "jiraKey": "MSSCI-15999",
+        }
+        label = _build_story_label(story, "")
+        has_dim = any("dim" in str(span.style) for span in label._spans)
+        assert has_dim, "Canceled story should have dim styling"
+
+
+class TestShouldExpand:
+    """Default expand logic for epics."""
+
+    def test_expands_with_incomplete_work(self) -> None:
+        epic = {"stories": [
+            {"points": 2, "status": "done"},
+            {"points": 3, "status": "in-progress"},
+        ]}
+        assert _should_expand(epic) is True
+
+    def test_collapses_when_all_done(self) -> None:
+        epic = {"stories": [
+            {"points": 2, "status": "done"},
+            {"points": 3, "status": "done"},
+        ]}
+        assert _should_expand(epic) is False
+
+    def test_expands_when_backlog_remains(self) -> None:
+        epic = {"stories": [
+            {"points": 2, "status": "done"},
+            {"points": 3, "status": "backlog"},
+        ]}
+        assert _should_expand(epic) is True
+
+    def test_expands_empty_epic(self) -> None:
+        epic = {"stories": []}
+        assert _should_expand(epic) is False
 
-    def test_table_has_jira_column(self, panel: SprintPanel) -> None:
-        """Story table should have a Jira column."""
-        result = panel.render_panel(SAMPLE_INIT_PAYLOAD)
-        table = _extract_table(result)
-        column_names = [col.header.plain if isinstance(col.header, Text) else str(col.header) for col in table.columns]
-        assert any("jira" in name.lower() for name in column_names), f"Expected 'Jira' column, got: {column_names}"
+    def test_collapses_canceled_epic(self) -> None:
+        epic = {"status": "canceled", "stories": [
+            {"points": 2, "status": "backlog"},
+        ]}
+        assert _should_expand(epic) is False
 
-    def test_table_contains_story_rows(self, panel: SprintPanel) -> None:
-        """Table should contain rows for stories from epics."""
-        result = panel.render_panel(SAMPLE_INIT_PAYLOAD)
-        table = _extract_table(result)
-        # SAMPLE_INIT_PAYLOAD has 3 stories in 1 epic
-        assert table.row_count >= 3, f"Expected at least 3 rows, got {table.row_count}"
+    def test_collapses_when_all_done_or_canceled(self) -> None:
+        epic = {"stories": [
+            {"points": 2, "status": "done"},
+            {"points": 3, "status": "canceled"},
+        ]}
+        assert _should_expand(epic) is False
 
-    def test_table_contains_stories_from_all_epics(self, panel: SprintPanel) -> None:
-        """Table should include stories from ALL epics, not just the first."""
-        result = panel.render_panel(SAMPLE_MULTI_EPIC_PAYLOAD)
-        table = _extract_table(result)
-        # 1 story from epic 101 + 2 from epic 103 = 3 total
-        assert table.row_count >= 3, f"Expected at least 3 rows from 2 epics, got {table.row_count}"
+    def test_expands_when_mix_of_canceled_and_backlog(self) -> None:
+        epic = {"stories": [
+            {"points": 2, "status": "canceled"},
+            {"points": 3, "status": "backlog"},
+        ]}
+        assert _should_expand(epic) is True
+
+
+class TestIsTerminal:
+    """Terminal status detection."""
+
+    def test_done_is_terminal(self) -> None:
+        assert _is_terminal("done") is True
+
+    def test_canceled_is_terminal(self) -> None:
+        assert _is_terminal("canceled") is True
+
+    def test_cancelled_british_is_terminal(self) -> None:
+        assert _is_terminal("cancelled") is True
+
+    def test_in_progress_is_not_terminal(self) -> None:
+        assert _is_terminal("in-progress") is False
+
+    def test_backlog_is_not_terminal(self) -> None:
+        assert _is_terminal("backlog") is False
 
 
 # ---------------------------------------------------------------------------
@@ -320,38 +493,25 @@ class TestSprintPanelRendering:
 
 
 class TestSprintPanelMetrics:
-    """AC4: Displays velocity and sprint metrics."""
-
-    def test_output_contains_velocity(self, panel: SprintPanel) -> None:
-        """Output should display velocity metric."""
-        result = panel.render_panel(SAMPLE_INIT_PAYLOAD)
-        rendered_str = _render_to_string(result)
-        assert "8" in rendered_str, "Velocity value (8) should appear in output"
-
-    def test_output_contains_sprint_name(self, panel: SprintPanel) -> None:
-        """Output should display sprint name."""
-        result = panel.render_panel(SAMPLE_INIT_PAYLOAD)
-        rendered_str = _render_to_string(result)
-        assert "2606" in rendered_str, "Sprint number (2606) should appear in output"
-
-    def test_output_contains_done_count(self, panel: SprintPanel) -> None:
-        """Output should display done points count."""
-        result = panel.render_panel(SAMPLE_INIT_PAYLOAD)
-        rendered_str = _render_to_string(result)
-        assert "71" in rendered_str, "Done count (71) should appear in output"
-
-    def test_output_contains_remaining_count(self, panel: SprintPanel) -> None:
-        """Output should display remaining points count."""
-        result = panel.render_panel(SAMPLE_INIT_PAYLOAD)
-        rendered_str = _render_to_string(result)
-        assert "128" in rendered_str, "Remaining count (128) should appear in output"
-
-    def test_metrics_update_with_new_data(self, panel: SprintPanel) -> None:
-        """Metrics should reflect updated payload values."""
-        result = panel.render_panel(SAMPLE_UPDATE_PAYLOAD)
-        rendered_str = _render_to_string(result)
-        assert "9" in rendered_str, "Updated velocity (9) should appear in output"
-        assert "73" in rendered_str, "Updated done count (73) should appear in output"
+    """AC4: Metrics are included in sprint header text."""
+
+    def test_header_format(self) -> None:
+        """Header text builder includes key metrics."""
+        # Test by checking the header text that _rebuild_tree would produce
+        sprint = SAMPLE_INIT_PAYLOAD["sprint"]
+        metrics = SAMPLE_INIT_PAYLOAD["metrics"]
+        header = Text.from_markup(
+            f"Sprint {sprint.get('number', '')}  "
+            f"[green]Done: {sprint.get('done', 0)}[/green] | "
+            f"Remaining: {sprint.get('remaining', 0)} | "
+            f"In Progress: {sprint.get('inProgress', 0)} | "
+            f"Velocity: {metrics.get('velocity', 0)}"
+        )
+        plain = header.plain
+        assert "2606" in plain
+        assert "71" in plain
+        assert "128" in plain
+        assert "8" in plain
 
 
 # ---------------------------------------------------------------------------
@@ -373,8 +533,6 @@ class TestDefaultPanel:
         async with app.run_test():
             panels = app.query(SprintPanel)
             assert len(panels) > 0, "SprintPanel should be mounted as default panel"
-            panel = panels.first()
-            assert panel.id == "sprint-panel"
 
 
 # ---------------------------------------------------------------------------
@@ -385,55 +543,30 @@ class TestDefaultPanel:
 class TestSprintPanelRealtime:
     """AC6: Updates in real-time when data changes on channel."""
 
-    def test_handle_message_calls_render_panel(self, panel: SprintPanel) -> None:
-        """handle_message should call render_panel with the payload."""
-        panel._mounted = True
-        with patch.object(panel, "render_panel", return_value="rendered") as mock_render:
-            with patch.object(panel, "update"):
-                panel.handle_message(SAMPLE_INIT_PAYLOAD)
-                mock_render.assert_called_once_with(SAMPLE_INIT_PAYLOAD)
-
-    def test_handle_message_updates_widget(self, panel: SprintPanel) -> None:
-        """handle_message should call self.update() with rendered output."""
-        panel._mounted = True
-        with patch.object(panel, "render_panel", return_value="rendered"):
-            with patch.object(panel, "update") as mock_update:
-                panel.handle_message(SAMPLE_INIT_PAYLOAD)
-                mock_update.assert_called_once_with("rendered")
-
-    def test_sequential_updates_re_render(self, panel: SprintPanel) -> None:
-        """Multiple messages should each trigger a re-render."""
-        panel._mounted = True
-        with patch.object(panel, "render_panel", return_value="rendered"):
-            with patch.object(panel, "update") as mock_update:
-                panel.handle_message(SAMPLE_INIT_PAYLOAD)
-                panel.handle_message(SAMPLE_UPDATE_PAYLOAD)
-                assert mock_update.call_count == 2
-
-    def test_ignores_none_messages(self, panel: SprintPanel) -> None:
-        """None messages should be silently ignored."""
+    def test_handle_message_posts_data_received(self, panel: SprintPanel) -> None:
+        """_handle_ws_message should post DataReceived message."""
         panel._mounted = True
-        with patch.object(panel, "render_panel") as mock_render:
-            with patch.object(panel, "update"):
-                panel.handle_message(None)
-                mock_render.assert_not_called()
-
-    def test_ignores_messages_after_unmount(self, panel: SprintPanel) -> None:
-        """Messages after unmount should be silently ignored."""
+        with patch.object(panel, "post_message") as mock_post:
+            panel._handle_ws_message(SAMPLE_INIT_PAYLOAD)
+            assert mock_post.call_count == 1
+            event = mock_post.call_args[0][0]
+            assert isinstance(event, SprintPanel.DataReceived)
+            assert event.payload == SAMPLE_INIT_PAYLOAD
+
+    def test_sequential_updates(self, panel: SprintPanel) -> None:
+        """Multiple messages should each trigger a post_message."""
         panel._mounted = True
-        panel.on_unmount()
-        with patch.object(panel, "render_panel") as mock_render:
-            with patch.object(panel, "update"):
-                panel.handle_message(SAMPLE_INIT_PAYLOAD)
-                mock_render.assert_not_called()
+        with patch.object(panel, "post_message") as mock_post:
+            panel._handle_ws_message(SAMPLE_INIT_PAYLOAD)
+            panel._handle_ws_message(SAMPLE_UPDATE_PAYLOAD)
+            assert mock_post.call_count == 2
 
     def test_stores_last_payload(self, panel: SprintPanel) -> None:
-        """handle_message should store the last payload."""
+        """_handle_ws_message should store the last payload."""
         panel._mounted = True
-        with patch.object(panel, "render_panel", return_value="rendered"):
-            with patch.object(panel, "update"):
-                panel.handle_message(SAMPLE_INIT_PAYLOAD)
-                assert panel._last_payload == SAMPLE_INIT_PAYLOAD
+        with patch.object(panel, "post_message"):
+            panel._handle_ws_message(SAMPLE_INIT_PAYLOAD)
+            assert panel._last_payload == SAMPLE_INIT_PAYLOAD
 
 
 # ---------------------------------------------------------------------------
@@ -444,46 +577,27 @@ class TestSprintPanelRealtime:
 class TestSprintPanelEdgeCases:
     """Edge cases and robustness tests."""
 
-    def test_handles_missing_metrics(self, panel: SprintPanel) -> None:
-        """render_panel should handle payload without metrics key."""
-        payload = {k: v for k, v in SAMPLE_INIT_PAYLOAD.items() if k != "metrics"}
-        # Should not raise
-        result = panel.render_panel(payload)
-        assert result is not None
-
-    def test_handles_missing_sprint(self, panel: SprintPanel) -> None:
-        """render_panel should handle payload without sprint key."""
-        payload = {k: v for k, v in SAMPLE_INIT_PAYLOAD.items() if k != "sprint"}
-        result = panel.render_panel(payload)
-        assert result is not None
-
-    def test_handles_empty_stories_in_epic(self, panel: SprintPanel) -> None:
-        """render_panel should handle epic with empty stories list."""
-        payload = {
-            **SAMPLE_INIT_PAYLOAD,
-            "epics": [{"id": "100", "title": "Empty Epic", "jiraKey": "MSSCI-10000", "stories": []}],
-        }
-        result = panel.render_panel(payload)
-        assert result is not None
-
-    def test_handles_story_with_null_jira_key(self, panel: SprintPanel) -> None:
-        """render_panel should handle story with null jiraKey."""
-        payload = {
-            **SAMPLE_INIT_PAYLOAD,
-            "epics": [
-                {
-                    "id": "103",
-                    "title": "Test",
-                    "jiraKey": None,
-                    "stories": [
-                        {"id": "103-99", "title": "No Jira", "points": 1, "status": "backlog", "jiraKey": None},
-                    ],
-                },
-            ],
-        }
-        # Should not raise
-        result = panel.render_panel(payload)
-        assert result is not None
+    def test_handles_missing_metrics(self) -> None:
+        """Label builder handles payload without metrics key."""
+        sprint = {"number": "2606", "done": 0, "remaining": 0, "inProgress": 0}
+        header = Text.from_markup(
+            f"Sprint {sprint.get('number', '')}  "
+            f"[green]Done: {sprint.get('done', 0)}[/green] | "
+            f"Remaining: {sprint.get('remaining', 0)} | "
+            f"Velocity: 0"
+        )
+        assert header.plain is not None
+
+    def test_status_badge_empty_string(self) -> None:
+        """Status badge handles empty string."""
+        badge = _status_badge("")
+        assert badge is not None
+
+    def test_story_label_missing_fields(self) -> None:
+        """Story label handles minimal story dict."""
+        story: dict[str, Any] = {"id": "X", "title": "", "points": 0, "status": "", "jiraKey": None}
+        label = _build_story_label(story, "")
+        assert label is not None
 
 
 # ---------------------------------------------------------------------------
@@ -491,41 +605,6 @@ class TestSprintPanelEdgeCases:
 # ---------------------------------------------------------------------------
 
 
-def _extract_table(result: Any) -> Table:
-    """Extract a Rich Table from render_panel output.
-
-    Handles both direct Table returns and Group/container returns.
-    Raises AssertionError if no Table found.
-    """
-    if isinstance(result, Table):
-        return result
-
-    # Check renderables in Group
-    renderables = getattr(result, "renderables", [])
-    for r in renderables:
-        if isinstance(r, Table):
-            return r
-
-    raise AssertionError(
-        f"Expected Rich Table in output, got {type(result).__name__}: {result!r}"
-    )
-
-
 async def _noop_coroutine() -> None:
     """No-op coroutine for mocking async client.connect()."""
     pass
-
-
-def _render_to_string(result: Any) -> str:
-    """Render a Rich renderable to plain string for content assertions.
-
-    Uses Rich Console with no color to get plain text output.
-    """
-    from io import StringIO
-
-    from rich.console import Console
-
-    buffer = StringIO()
-    console = Console(file=buffer, no_color=True, width=120)
-    console.print(result)
-    return buffer.getvalue()