symtest-cli 1.3.0__py3-none-any.whl

symtest/tui/screens/case_list.py

@@ -0,0 +1,255 @@
+"""Main screen: case table + search bar + status."""
+
+from __future__ import annotations
+
+from textual.screen import Screen
+from textual.widgets import Header, Footer, Static
+from textual.containers import Horizontal, Container
+from textual.binding import Binding
+
+from ..controllers.case_controller import CaseController
+from ..widgets.case_table import CaseTable
+from ..widgets.search_bar import SearchBar
+from .case_editor import CaseEditorScreen
+
+
+class CaseListScreen(Screen):
+    """Primary TUI screen showing the test case table."""
+
+    BINDINGS = [
+        Binding("/", "focus_search", "Search", show=True),
+        Binding("escape", "clear_search", "Clear search", show=True),
+        Binding("a", "add_case", "Add", show=True),
+        Binding("e", "edit_case", "Edit", show=True),
+        Binding("d", "delete_case", "Delete", show=True),
+        Binding("u", "duplicate_case", "Dup", show=True),
+        Binding("r", "run_case", "Run", show=True),
+        Binding("f6", "save_file", "Save", show=True),
+        Binding("ctrl+s", "save_file", "Save", show=False),
+        Binding("ctrl+q", "quit", "Quit", show=True),
+        Binding("q", "quit", "Quit", show=True),
+        Binding("n", "next_match", "Next", show=False),
+        Binding("shift+enter", "prev_match", "Prev", show=False),
+        Binding("up", "cursor_up", "", show=False),
+        Binding("down", "cursor_down", "", show=False),
+        Binding("alt+f", "toggle_fuzzy", "", show=False),
+        Binding("alt+r", "toggle_regex", "", show=False),
+        Binding("alt+s", "toggle_substring", "", show=False),
+    ]
+
+    DEFAULT_CSS = """
+    CaseListScreen {
+        align: center middle;
+    }
+    CaseListScreen #status-bar {
+        height: 1;
+        padding: 0 1;
+        background: $panel;
+    }
+    CaseListScreen #status-bar Static {
+        width: 1fr;
+    }
+    """
+
+    def __init__(self, controller: CaseController):
+        super().__init__()
+        self._ctrl = controller
+        self._filtered_indices: list[int] = list(range(len(controller.cases)))
+        self._cur_match: int = 0
+        self._current_tag: str | None = None
+
+    def compose(self):
+        yield Header()
+        yield SearchBar(id="main-search")
+        yield CaseTable(id="main-table")
+        yield Container(
+            Horizontal(
+                Static(f"File: {self._ctrl.file_name}", id="status-file"),
+                Static(f"{self._ctrl.case_count} cases", id="status-count"),
+                Static("Tag: All", id="status-tag"),
+                Static("", id="status-dirty"),
+                id="status-inner",
+            ),
+            id="status-bar",
+        )
+        yield Footer()
+
+    def on_mount(self) -> None:
+        self._refresh_table()
+        self._update_status()
+
+    # -- table refresh -------------------------------------------------------
+
+    def _refresh_table(self) -> None:
+        table = self.query_one("#main-table", CaseTable)
+        table.refresh_rows(self._ctrl.cases, self._filtered_indices)
+
+    def _update_status(self) -> None:
+        self.query_one("#status-count", Static).update(
+            f"{len(self._filtered_indices)}/{self._ctrl.case_count} cases"
+        )
+        tag_label = self.query_one("#status-tag", Static)
+        tag_label.update(f"Tag: {self._current_tag or 'All'}")
+        dirty = self._ctrl.dirty
+        self.query_one("#status-dirty", Static).update(
+            "[MODIFIED]" if dirty else ""
+        )
+
+    # -- search handling -----------------------------------------------------
+
+    def on_search_bar_search_changed(self, event: SearchBar.SearchChanged) -> None:
+        sb = self.query_one("#main-search", SearchBar)
+        self._filtered_indices = self._ctrl.search(
+            event.query, event.mode, self._current_tag
+        )
+        self._cur_match = 0
+        sb.set_match_count(len(self._filtered_indices), 0)
+        self._refresh_table()
+        self._update_status()
+        # Select first match
+        if self._filtered_indices:
+            table = self.query_one("#main-table", CaseTable)
+            table.select_row_by_index(self._filtered_indices[0])
+            self._cur_match = 1
+            sb.set_match_count(len(self._filtered_indices), 1)
+
+    def on_search_bar_search_navigated(self, event: SearchBar.SearchNavigated) -> None:
+        sb = self.query_one("#main-search", SearchBar)
+        table = self.query_one("#main-table", CaseTable)
+        if event.delta > 0:
+            table.select_next_match()
+        else:
+            table.select_prev_match()
+        # Update current match display
+        if self._filtered_indices and table.cursor_coordinate.row < len(self._filtered_indices):
+            self._cur_match = table.cursor_coordinate.row + 1
+            sb.set_match_count(len(self._filtered_indices), self._cur_match)
+
+    # -- actions -------------------------------------------------------------
+
+    def action_focus_search(self) -> None:
+        sb = self.query_one("#main-search", SearchBar)
+        sb.query_one("#search-input").focus()
+
+    def action_clear_search(self) -> None:
+        self.query_one("#main-search", SearchBar).clear()
+        self._filtered_indices = list(range(len(self._ctrl.cases)))
+        self._refresh_table()
+        self._update_status()
+
+    def action_add_case(self) -> None:
+        self.app.push_screen(
+            CaseEditorScreen(),
+            callback=self._on_editor_done,
+        )
+
+    def action_edit_case(self) -> None:
+        idx = self._get_current_case_index()
+        if idx is None:
+            self.notify("No case selected", severity="warning")
+            return
+        case = self._ctrl.get_case(idx)
+        self.app.push_screen(
+            CaseEditorScreen(case),
+            callback=lambda msg: self._on_editor_done(msg, original_idx=idx),
+        )
+
+    def action_delete_case(self) -> None:
+        idx = self._get_current_case_index()
+        if idx is None:
+            self.notify("No case selected", severity="warning")
+            return
+        case_name = self._ctrl.get_case(idx).name
+        self._ctrl.delete_case(idx)
+        self.notify(f"Deleted: {case_name}")
+        self._refresh_filtered()
+        self._update_status()
+
+    def action_duplicate_case(self) -> None:
+        idx = self._get_current_case_index()
+        if idx is None:
+            self.notify("No case selected", severity="warning")
+            return
+        new_idx = self._ctrl.duplicate_case(idx)
+        self.notify(f"Duplicated as: {self._ctrl.get_case(new_idx).name}")
+        self._refresh_filtered()
+        self._update_status()
+
+    def action_run_case(self) -> None:
+        idx = self._get_current_case_index()
+        if idx is None:
+            self.notify("No case selected", severity="warning")
+            return
+        case = self._ctrl.get_case(idx)
+        self.notify(f"Running: {case.name}...")
+        try:
+            result = self._ctrl.run_case(idx)
+            status_icon = "[OK]" if result["status"] == "passed" else "[FAIL]"
+            # Build rich status line with new result fields
+            parts = [f"{status_icon} {case.name}"]
+            parts.append(f"rc={result.get('return_code')}")
+            parts.append(f"{result.get('duration', 0):.2f}s")
+            # Failure kind
+            if result.get("failure_kind"):
+                parts.append(f"kind={result['failure_kind']}")
+            # Flaky / attempts
+            if result.get("flaky"):
+                parts.append(f"flaky ({result.get('attempts', 1)} attempts)")
+            elif result.get("attempts", 1) > 1:
+                parts.append(f"{result['attempts']} attempts")
+            # Failed step (sequence)
+            if result.get("failed_step"):
+                parts.append(f"step={result['failed_step']}")
+            self.notify(
+                " | ".join(parts),
+                severity="information" if result["status"] == "passed" else "error",
+            )
+            # Show error message separately for failed cases
+            if result["status"] != "passed" and result.get("message"):
+                self.notify(f"[ERROR] {result['message']}", severity="error")
+            # Show baseline updates
+            if result.get("baseline_updated"):
+                for bu in result["baseline_updated"]:
+                    self.notify(f"[BASELINE UPDATED] {bu}", severity="information")
+        except Exception as e:
+            self.notify(f"Run error: {e}", severity="error")
+
+    def action_save_file(self) -> None:
+        try:
+            self._ctrl.save()
+            self.notify(f"Saved to {self._ctrl.file_name}")
+            self._update_status()
+        except Exception as e:
+            self.notify(f"Save error: {e}", severity="error")
+
+    def action_toggle_fuzzy(self) -> None:
+        self.query_one("#main-search", SearchBar).action_toggle_fuzzy()
+
+    def action_toggle_regex(self) -> None:
+        self.query_one("#main-search", SearchBar).action_toggle_regex()
+
+    def action_toggle_substring(self) -> None:
+        self.query_one("#main-search", SearchBar).action_toggle_substring()
+
+    # -- helpers -------------------------------------------------------------
+
+    def _get_current_case_index(self) -> int | None:
+        table = self.query_one("#main-table", CaseTable)
+        return table.get_selected_index()
+
+    def _refresh_filtered(self) -> None:
+        sb = self.query_one("#main-search", SearchBar)
+        self._filtered_indices = self._ctrl.search(
+            sb.query, sb.mode, self._current_tag
+        )
+        self._refresh_table()
+        self._update_status()
+
+    def _on_editor_done(self, msg, original_idx=None) -> None:
+        if isinstance(msg, CaseEditorScreen.Saved):
+            if original_idx is not None:
+                self._ctrl.update_case(original_idx, msg.case)
+            else:
+                self._ctrl.add_case(msg.case)
+            self._refresh_filtered()
+            self._update_status()

symtest/tui/widgets/case_table.py

@@ -0,0 +1,113 @@
+"""DataTable wrapper for displaying test cases."""
+
+from __future__ import annotations
+
+from textual.widgets import DataTable
+from textual.coordinate import Coordinate
+
+from ...core.test_case import TestCase
+
+
+class CaseTable(DataTable):
+    """DataTable pre-configured for test case display."""
+
+    DEFAULT_CSS = """
+    CaseTable {
+        height: 1fr;
+        min-height: 5;
+    }
+    """
+
+    COLUMNS = ("#", "Name", "Command", "Tags", "Timeout", "Mode")
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(cursor_type="row", zebra_stripes=True, *args, **kwargs)
+        self._case_indices: list[int] = []
+        self._all_tags: list[str] = []
+        self._filtered_tag: str | None = None
+
+    def on_mount(self) -> None:
+        for col in self.COLUMNS:
+            self.add_column(col, key=col.lower())
+
+    # -- public API ----------------------------------------------------------
+
+    def refresh_rows(self, cases: list[TestCase], indices: list[int]) -> None:
+        """Clear table and repopulate with the cases at *indices*."""
+        self.clear()
+        self._case_indices = list(indices)
+        for i, ci in enumerate(indices):
+            tc = cases[ci]
+            mode = "seq" if tc.steps else "cmd"
+            tags = ",".join(tc.tags) if tc.tags else "-"
+            timeout = str(tc.timeout) if tc.timeout else "-"
+            self.add_row(
+                str(i + 1),
+                tc.name,
+                self._truncate(tc.command, 30),
+                tags,
+                timeout,
+                mode,
+                key=str(ci),
+            )
+
+    def get_selected_index(self) -> int | None:
+        """Return the case index of the currently selected row."""
+        if self.row_count == 0:
+            return None
+        row_key = self.coordinate_to_cell_key(self.cursor_coordinate)
+        if row_key is not None:
+            return int(str(row_key.row_key.value))
+        return None
+
+    def select_row_by_index(self, case_index: int) -> None:
+        """Move cursor to the row corresponding to *case_index*."""
+        try:
+            row_key = self._row_key_for_case(case_index)
+            if row_key is not None:
+                self.move_cursor(row=row_key)
+        except Exception:
+            pass
+
+    def select_next_match(self) -> int | None:
+        """Move down one row; return new selected case index."""
+        if self.row_count == 0:
+            return None
+        cr = self.cursor_coordinate
+        new_row = min(cr.row + 1, self.row_count - 1)
+        self.move_cursor(row=new_row)
+        return self.get_selected_index()
+
+    def select_prev_match(self) -> int | None:
+        """Move up one row; return new selected case index."""
+        if self.row_count == 0:
+            return None
+        cr = self.cursor_coordinate
+        new_row = max(cr.row - 1, 0)
+        self.move_cursor(row=new_row)
+        return self.get_selected_index()
+
+    # -- tag filter ----------------------------------------------------------
+
+    def set_all_tags(self, tags: list[str]) -> None:
+        self._all_tags = list(tags)
+
+    @property
+    def filtered_tag(self) -> str | None:
+        return self._filtered_tag
+
+    # -- helpers -------------------------------------------------------------
+
+    @staticmethod
+    def _truncate(text: str, max_len: int) -> str:
+        if len(text) <= max_len:
+            return text
+        return text[: max_len - 2] + ".."
+
+    def _row_key_for_case(self, case_index: int) -> object | None:
+        """Find the row key for a given *case_index*."""
+        for i in range(self.row_count):
+            key = self.coordinate_to_cell_key(Coordinate(i, 0))
+            if key is not None and str(key.row_key.value) == str(case_index):
+                return key.row_key
+        return None

symtest/tui/widgets/expected_editor.py

@@ -0,0 +1,159 @@
+"""Widget for editing a test case's ``expected`` dict.
+
+Provides structured inputs for known keys (return_code, output_contains,
+output_matches, compare_files) and a free-form area for custom key-value pairs.
+
+Uses an internal ``_data`` dict so that ``load()`` / ``to_dict()`` work
+even when the widget is not mounted (e.g. in tests).
+"""
+
+from __future__ import annotations
+
+import copy
+import json
+from typing import Any, Dict
+
+from textual.widgets import Input, TextArea, Static
+from textual.containers import Vertical
+from textual.message import Message
+
+
+class ExpectedEditor(Vertical):
+    """Nested-dict editor for the ``expected`` field of a test case."""
+
+    DEFAULT_CSS = """
+    ExpectedEditor {
+        height: auto;
+        border: solid $primary;
+        padding: 1;
+    }
+    ExpectedEditor Static.label {
+        color: $text-muted;
+        height: 1;
+        margin-top: 1;
+    }
+    ExpectedEditor #expected-return-code {
+        width: 10;
+    }
+    ExpectedEditor #expected-output-contains {
+        height: 3;
+    }
+    ExpectedEditor #expected-custom {
+        height: 4;
+    }
+    """
+
+    class Changed(Message):
+        """Emitted whenever the expected dict is modified."""
+
+    _KNOWN_KEYS = {"return_code", "output_contains", "output_matches", "compare_files"}
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._data: Dict[str, Any] = {}
+
+    def compose(self):
+        yield Static("─ Expected ─", classes="label")
+        yield Static("return_code:", classes="label")
+        yield Input(placeholder="0", id="expected-return-code")
+        yield Static("output_contains (one per line):", classes="label")
+        yield TextArea("", id="expected-output-contains")
+        yield Static("output_matches (regex):", classes="label")
+        yield Input(placeholder=".*", id="expected-output-matches")
+        yield Static(
+            "compare_files (one JSON per line: {actual, baseline, type, start_line?, end_line?, start_column?, end_column?}):",
+            classes="label",
+        )
+        yield TextArea("", id="expected-compare-files")
+        yield Static("Custom key-value pairs (key=value, one per line):", classes="label")
+        yield TextArea("", id="expected-custom")
+
+    def on_mount(self) -> None:
+        """Populate UI from internal data on mount."""
+        self._sync_to_ui()
+
+    # -- public API ----------------------------------------------------------
+
+    def load(self, expected: Dict[str, Any]) -> None:
+        """Populate the editor from an *expected* dict."""
+        self._data = copy.deepcopy(expected)
+        if self.is_mounted:
+            self._sync_to_ui()
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Reconstruct the expected dict from the current widget values."""
+        if self.is_mounted:
+            self._sync_from_ui()
+        return copy.deepcopy(self._data)
+
+    # -- internal sync -------------------------------------------------------
+
+    def _sync_to_ui(self) -> None:
+        """Push internal ``_data`` into the widget children."""
+        rc = self._data.get("return_code")
+        self.query_one("#expected-return-code", Input).value = str(rc) if rc is not None else ""
+
+        oc = self._data.get("output_contains", [])
+        self.query_one("#expected-output-contains", TextArea).text = "\n".join(oc)
+
+        om = self._data.get("output_matches", "")
+        self.query_one("#expected-output-matches", Input).value = om
+
+        cf = self._data.get("compare_files", [])
+        cf_lines = [json.dumps(item, ensure_ascii=False) for item in cf]
+        self.query_one("#expected-compare-files", TextArea).text = "\n".join(cf_lines)
+
+        custom_lines = [
+            f"{k}={json.dumps(v, ensure_ascii=False)}"
+            for k, v in self._data.items()
+            if k not in self._KNOWN_KEYS
+        ]
+        self.query_one("#expected-custom", TextArea).text = "\n".join(custom_lines)
+
+    def _sync_from_ui(self) -> None:
+        """Pull widget children values into ``_data``."""
+        self._data = {}
+
+        rc_text = self.query_one("#expected-return-code", Input).value.strip()
+        if rc_text:
+            try:
+                self._data["return_code"] = int(rc_text)
+            except ValueError:
+                self._data["return_code"] = rc_text
+
+        oc_text = self.query_one("#expected-output-contains", TextArea).text.strip()
+        if oc_text:
+            self._data["output_contains"] = [
+                line for line in oc_text.splitlines() if line.strip()
+            ]
+
+        om_text = self.query_one("#expected-output-matches", Input).value.strip()
+        if om_text:
+            self._data["output_matches"] = om_text
+
+        cf_text = self.query_one("#expected-compare-files", TextArea).text.strip()
+        if cf_text:
+            cf_list = []
+            for line in cf_text.splitlines():
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    cf_list.append(json.loads(line))
+                except json.JSONDecodeError:
+                    pass
+            if cf_list:
+                self._data["compare_files"] = cf_list
+
+        custom_text = self.query_one("#expected-custom", TextArea).text.strip()
+        if custom_text:
+            for line in custom_text.splitlines():
+                line = line.strip()
+                if "=" not in line:
+                    continue
+                key, _, value = line.partition("=")
+                key = key.strip()
+                try:
+                    self._data[key] = json.loads(value.strip())
+                except (json.JSONDecodeError, ValueError):
+                    self._data[key] = value.strip()

symtest/tui/widgets/search_bar.py

@@ -0,0 +1,160 @@
+"""Search bar widget with multi-mode search (substring / fuzzy / regex).
+
+Emits :class:`SearchChanged` when the query text or mode changes, and
+:class:`SearchNavigated` when the user cycles through matches.
+"""
+
+from __future__ import annotations
+
+from textual import on
+from textual.widgets import Input, Static
+from textual.containers import Horizontal
+from textual.message import Message
+
+
+class SearchBar(Horizontal):
+    """A search bar with mode toggle and result count."""
+
+    DEFAULT_CSS = """
+    SearchBar {
+        height: auto;
+        padding: 0 1;
+        margin-bottom: 1;
+    }
+    SearchBar #search-input {
+        width: 40;
+    }
+    SearchBar #search-mode {
+        width: 12;
+        padding: 0 1;
+        color: $text-muted;
+    }
+    SearchBar #search-count {
+        width: auto;
+        padding: 0 1;
+        color: $text-muted;
+    }
+    """
+
+    # Maps keyboard modifiers to modes
+    _MODES = {
+        0: "substring",
+        2: "regex",   # Alt pressed
+        4: "fuzzy",   # Ctrl pressed → fuzzy mode
+    }
+
+    class SearchChanged(Message):
+        """Emitted when search query or mode changes."""
+
+        def __init__(self, query: str, mode: str):
+            super().__init__()
+            self.query = query
+            self.mode = mode
+
+    class SearchNavigated(Message):
+        """Emitted to jump to match N."""
+
+        def __init__(self, delta: int):
+            super().__init__()
+            self.delta = delta
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._query = ""
+        self._mode: str = "substring"
+        self._match_count = 0
+        self._history: list[str] = []
+        self._history_idx = -1
+
+    def compose(self):
+        yield Input(placeholder="Search...", id="search-input")
+        yield Static("[子串]", id="search-mode")
+        yield Static("", id="search-count")
+
+    # -- mode toggle via key bindings ----------------------------------------
+
+    def _handle_mode_toggle(self, mode: str, label: str) -> None:
+        if self._mode != mode:
+            self._mode = mode
+            self.query_one("#search-mode", Static).update(label)
+            self.post_message(self.SearchChanged(self._query, self._mode))
+
+    def action_toggle_substring(self) -> None:
+        self._handle_mode_toggle("substring", "[子串]")
+
+    def action_toggle_fuzzy(self) -> None:
+        self._handle_mode_toggle("fuzzy", "[模糊]")
+
+    def action_toggle_regex(self) -> None:
+        self._handle_mode_toggle("regex", "[正则]")
+
+    # -- input handling ------------------------------------------------------
+
+    @on(Input.Changed, "#search-input")
+    def _on_input_changed(self, event: Input.Changed) -> None:
+        self._query = event.value.strip()
+        self.post_message(self.SearchChanged(self._query, self._mode))
+
+    @on(Input.Submitted, "#search-input")
+    def _on_input_submitted(self, _event: Input.Submitted) -> None:
+        # Add to history (dedup, keep last 10)
+        if self._query and (not self._history or self._history[-1] != self._query):
+            self._history.append(self._query)
+            if len(self._history) > 10:
+                self._history.pop(0)
+        self._history_idx = -1
+        self.post_message(self.SearchNavigated(1))
+
+    # -- public API ----------------------------------------------------------
+
+    def set_match_count(self, total: int, current: int = 0) -> None:
+        """Update the match counter display."""
+        self._match_count = total
+        label = f"{current}/{total}" if total > 0 else ""
+        self.query_one("#search-count", Static).update(label)
+
+    def clear(self) -> None:
+        """Reset search bar."""
+        inp = self.query_one("#search-input", Input)
+        inp.clear()
+        self._query = ""
+        self._match_count = 0
+        self.query_one("#search-count", Static).update("")
+
+    def history_previous(self) -> None:
+        """Cycle to previous history entry."""
+        if not self._history:
+            return
+        if self._history_idx == -1:
+            self._history_idx = len(self._history) - 1
+        elif self._history_idx > 0:
+            self._history_idx -= 1
+        text = self._history[self._history_idx]
+        inp = self.query_one("#search-input", Input)
+        inp.value = text
+        self._query = text
+        self.post_message(self.SearchChanged(self._query, self._mode))
+
+    def history_next(self) -> None:
+        if not self._history or self._history_idx == -1:
+            return
+        self._history_idx += 1
+        if self._history_idx >= len(self._history):
+            self._history_idx = -1
+            inp = self.query_one("#search-input", Input)
+            inp.value = ""
+            self._query = ""
+        else:
+            text = self._history[self._history_idx]
+            inp = self.query_one("#search-input", Input)
+            inp.value = text
+            self._query = text
+        self.post_message(self.SearchChanged(self._query, self._mode))
+
+    @property
+    def query(self) -> str:
+        return self._query
+
+    @property
+    def mode(self) -> str:
+        return self._mode