symtest-cli 1.3.0__py3-none-any.whl

symtest/tui/widgets/steps_editor.py

@@ -0,0 +1,243 @@
+"""Widget for editing a test case's ``steps`` list (sequence mode).
+
+Uses an internal ``_steps`` list so that ``load()`` / ``to_steps()`` work
+even when the widget is not mounted.
+"""
+
+from __future__ import annotations
+
+import copy
+import json
+from typing import Any, List
+
+from textual.widgets import Input, TextArea, Static, Button
+from textual.containers import Vertical, Horizontal
+from textual.message import Message
+from textual.app import ComposeResult
+
+from ...core.test_case import TestCaseStep
+
+
+class StepsEditor(Vertical):
+    """Editor for the ``steps`` sequence of a test case."""
+
+    DEFAULT_CSS = """
+    StepsEditor {
+        height: auto;
+        border: solid $primary;
+        padding: 1;
+    }
+    StepsEditor #steps-list {
+        height: auto;
+        min-height: 3;
+    }
+    StepsEditor .step-row {
+        height: auto;
+        padding: 1 0;
+        border-bottom: solid $panel;
+    }
+    StepsEditor .step-row Static {
+        width: 1fr;
+    }
+    StepsEditor .step-header {
+        color: $accent;
+        padding-bottom: 1;
+    }
+    StepsEditor #step-editor {
+        height: auto;
+        margin-top: 1;
+        border: solid $surface;
+        padding: 1;
+    }
+    StepsEditor #step-confirm {
+        margin-top: 1;
+    }
+    """
+
+    class Changed(Message):
+        """Emitted whenever steps are modified."""
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._steps: List[TestCaseStep] = []
+        self._editing_idx: int = -1  # -1 = new step
+
+    def compose(self) -> ComposeResult:
+        yield Static("─ Steps ─", classes="label")
+        yield Vertical(id="steps-list")
+        yield Static("", id="step-editor-status")
+        yield Static("Command:", classes="label")
+        yield Input(placeholder="python", id="step-cmd")
+        yield Static("Args (space-separated):", classes="label")
+        yield Input(placeholder="./script.py --flag", id="step-args")
+        yield Static("Expected (JSON):", classes="label")
+        yield TextArea('{"return_code": 0}', id="step-expected")
+        yield Static("Timeout (seconds):", classes="label")
+        yield Input(placeholder="", id="step-timeout")
+        yield Static("Retry count:", classes="label")
+        yield Input(placeholder="0", id="step-retry-count")
+        yield Horizontal(
+            Button("Save Step", id="step-save", variant="primary"),
+            Button("Cancel", id="step-cancel"),
+            id="step-confirm",
+        )
+        yield Horizontal(
+            Button("+ Add Step", id="step-add", variant="success"),
+            id="step-actions",
+        )
+
+    def on_mount(self) -> None:
+        self._refresh_list()
+
+    # -- public API ----------------------------------------------------------
+
+    def load(self, steps: List[TestCaseStep]) -> None:
+        """Populate the editor with *steps*."""
+        self._steps = copy.deepcopy(steps)
+        self._editing_idx = -1
+        if self.is_mounted:
+            self._refresh_list()
+            self._clear_edit_form()
+
+    def to_steps(self) -> List[TestCaseStep]:
+        if self.is_mounted:
+            # Pull any in-progress edit from UI into steps before returning
+            pass  # edits are applied immediately via buttons
+        return copy.deepcopy(self._steps)
+
+    # -- internal -----------------------------------------------------------
+
+    def _refresh_list(self) -> None:
+        container = self.query_one("#steps-list", Vertical)
+        container.remove_children()
+        for i, step in enumerate(self._steps):
+            args_str = " ".join(step.args) if step.args else ""
+            exp_preview = json.dumps(step.expected, ensure_ascii=False)
+            if len(exp_preview) > 40:
+                exp_preview = exp_preview[:37] + "..."
+            timeout_str = f", timeout={step.timeout}s" if step.timeout else ""
+            retry_str = f", retry={step.retry_count}" if step.retry_count else ""
+
+            row = Horizontal(
+                Static(f"[Step {i+1}/{len(self._steps)}]"),
+                Static(f"cmd: {step.command}"),
+                Static(f"args: {args_str[:30]}"),
+                Static(f"exp: {exp_preview}"),
+                Button("Edit", id=f"step-edit-{i}"),
+                Button("Del", id=f"step-del-{i}"),
+                Button("↑", id=f"step-up-{i}"),
+                Button("↓", id=f"step-down-{i}"),
+                classes="step-row",
+            )
+            container.mount(row)
+
+    def _clear_edit_form(self) -> None:
+        self._editing_idx = -1
+        if not self.is_mounted:
+            return
+        self.query_one("#step-cmd", Input).value = ""
+        self.query_one("#step-args", Input).value = ""
+        self.query_one("#step-expected", TextArea).text = '{"return_code": 0}'
+        self.query_one("#step-timeout", Input).value = ""
+        self.query_one("#step-retry-count", Input).value = ""
+        status = self.query_one("#step-editor-status", Static)
+        status.update("")
+
+    def _edit_step(self, idx: int) -> None:
+        self._editing_idx = idx
+        step = self._steps[idx]
+        self.query_one("#step-cmd", Input).value = step.command
+        self.query_one("#step-args", Input).value = " ".join(step.args)
+        self.query_one("#step-expected", TextArea).text = json.dumps(
+            step.expected, ensure_ascii=False
+        )
+        self.query_one("#step-timeout", Input).value = str(step.timeout) if step.timeout else ""
+        self.query_one("#step-retry-count", Input).value = str(step.retry_count) if step.retry_count else ""
+        status = self.query_one("#step-editor-status", Static)
+        status.update(f"Editing Step {idx+1}")
+
+    def _save_current_step(self) -> None:
+        cmd = self.query_one("#step-cmd", Input).value.strip()
+        if not cmd:
+            self.notify("Command cannot be empty", severity="error")
+            return
+
+        args_text = self.query_one("#step-args", Input).value.strip()
+        args = args_text.split() if args_text else []
+
+        try:
+            expected = json.loads(self.query_one("#step-expected", TextArea).text)
+        except json.JSONDecodeError:
+            self.notify("Expected must be valid JSON", severity="error")
+            return
+
+        timeout_text = self.query_one("#step-timeout", Input).value.strip()
+        timeout = float(timeout_text) if timeout_text else None
+
+        retry_text = self.query_one("#step-retry-count", Input).value.strip()
+        retry_count = int(retry_text) if retry_text else 0
+
+        new_step = TestCaseStep(
+            command=cmd, args=args, expected=expected, timeout=timeout, retry_count=retry_count,
+        )
+
+        if self._editing_idx >= 0:
+            self._steps[self._editing_idx] = new_step
+        else:
+            self._steps.append(new_step)
+
+        self._clear_edit_form()
+        self._refresh_list()
+        self.post_message(self.Changed())
+
+    def _delete_step(self, idx: int) -> None:
+        del self._steps[idx]
+        if self._editing_idx == idx:
+            self._clear_edit_form()
+        elif self._editing_idx > idx:
+            self._editing_idx -= 1
+        self._refresh_list()
+        self.post_message(self.Changed())
+
+    def _move_step(self, idx: int, direction: int) -> None:
+        new_idx = idx + direction
+        if 0 <= new_idx < len(self._steps):
+            self._steps[idx], self._steps[new_idx] = self._steps[new_idx], self._steps[idx]
+            if self._editing_idx == idx:
+                self._editing_idx = new_idx
+            elif self._editing_idx == new_idx:
+                self._editing_idx = idx
+            self._refresh_list()
+            self.post_message(self.Changed())
+
+    # -- button handlers -----------------------------------------------------
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        bid = str(event.button.id)
+
+        if bid == "step-add":
+            self._clear_edit_form()
+
+        elif bid == "step-save":
+            self._save_current_step()
+
+        elif bid == "step-cancel":
+            self._clear_edit_form()
+
+        elif bid and bid.startswith("step-edit-"):
+            idx = int(bid.split("-")[-1])
+            if 0 <= idx < len(self._steps):
+                self._edit_step(idx)
+
+        elif bid and bid.startswith("step-del-"):
+            idx = int(bid.split("-")[-1])
+            if 0 <= idx < len(self._steps):
+                self._delete_step(idx)
+
+        elif bid and bid.startswith("step-up-"):
+            idx = int(bid.split("-")[-1])
+            self._move_step(idx, -1)
+
+        elif bid and bid.startswith("step-down-"):
+            idx = int(bid.split("-")[-1])
+            self._move_step(idx, 1)

symtest/utils/__init__.py

@@ -0,0 +1,21 @@
+# File: /python-test-framework/python-test-framework/src/utils/__init__.py
+
+"""
+Utility functions for the CLI Testing Framework
+"""
+
+from .path_resolver import (
+    PathResolver,
+    resolve_paths,
+    resolve_command,
+    split_command,
+)
+from .junit_xml_writer import write_junit_xml
+
+__all__ = [
+    'PathResolver',
+    'resolve_paths',
+    'resolve_command',
+    'split_command',
+    'write_junit_xml',
+]

symtest/utils/junit_xml_writer.py

@@ -0,0 +1,137 @@
+"""JUnit XML report writer for CLI Test Framework.
+
+Generates JUnit-format XML compatible with GitLab CI, Jenkins, CircleCI, etc.
+"""
+
+import socket
+import xml.etree.ElementTree as ET
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional
+
+
+def _xml_escape(text: str) -> str:
+    """Escape text for safe embedding in XML (handles control characters)."""
+    if text is None:
+        return ""
+    return "".join(
+        ch if ord(ch) >= 0x20 or ch in "\t\n\r" else "?"
+        for ch in str(text)
+    )
+
+
+def write_junit_xml(
+    results: Dict[str, Any],
+    filepath: str,
+    suite_name: Optional[str] = None,
+    classname: Optional[str] = None,
+) -> None:
+    """Write JUnit XML report for CI tools.
+
+    Args:
+        results: The ``BaseRunner.results`` dict after ``run_tests()``.
+        filepath: Output path for the XML file.
+        suite_name: Name of the testsuite element. Defaults to ``"cli_tests"``.
+        classname: ``classname`` attribute for each testcase. Defaults to suite_name.
+    """
+    details: List[Dict[str, Any]] = results.get("details", [])
+    total = len(details)
+    total_time = 0.0
+
+    suite_name = suite_name or "cli_tests"
+    classname = classname or suite_name
+
+    # First pass: count failures/errors/skipped and total time
+    failures_count = 0
+    errors_count = 0
+    skipped_count = 0
+    for detail in details:
+        duration = detail.get("duration", 0.0)
+        total_time += duration
+        status = detail.get("status", "failed")
+
+        if status in ("passed", "xfailed"):
+            pass
+        elif status == "xpassed":
+            failures_count += 1
+        elif status in ("timeout",):
+            errors_count += 1
+        elif status == "failed":
+            message = str(detail.get("message", ""))
+            if "Execution error" in message:
+                errors_count += 1
+            else:
+                failures_count += 1
+        else:
+            errors_count += 1
+
+        if status == "xfailed":
+            skipped_count += 1
+
+    # Build XML tree
+    root = ET.Element("testsuite", {
+        "name": suite_name,
+        "tests": str(total),
+        "failures": str(failures_count),
+        "errors": str(errors_count),
+        "skipped": str(skipped_count),
+        "time": f"{total_time:.3f}",
+        "timestamp": datetime.now(timezone.utc).isoformat(),
+        "hostname": socket.gethostname(),
+    })
+
+    for detail in details:
+        duration = detail.get("duration", 0.0)
+        tc = ET.SubElement(root, "testcase", {
+            "name": detail.get("name", "unknown"),
+            "classname": classname,
+            "time": f"{duration:.3f}",
+        })
+
+        status = detail.get("status", "failed")
+        message = str(detail.get("message", ""))
+        output = str(detail.get("output", ""))
+
+        if status in ("passed",):
+            # No child element = passed in JUnit convention
+            pass
+        elif status == "xfailed":
+            # Expected failure → skipped in JUnit
+            reason = detail.get("xfail_reason", "") or ""
+            ET.SubElement(tc, "skipped", {
+                "message": _xml_escape(reason or "Expected failure"),
+            })
+        elif status == "xpassed":
+            # Unexpected pass → failure
+            full_text = f"UNEXPECTED PASS: marked as expected_failure but passed.\n{message}\n\n--- Command Output ---\n{output}" if output else f"UNEXPECTED PASS: marked as expected_failure but passed.\n{message}"
+            ET.SubElement(tc, "failure", {
+                "message": _xml_escape(message or "UNEXPECTED PASS (xpassed)"),
+                "type": "AssertionError",
+            }).text = _xml_escape(full_text)
+        elif status in ("timeout",):
+            ET.SubElement(tc, "error", {
+                "message": _xml_escape(message or "Test timed out"),
+                "type": "TimeoutExpired",
+            }).text = _xml_escape(f"{message}\n\n--- Command Output ---\n{output}" if output else message)
+        elif status == "failed":
+            full_text = f"{message}\n\n--- Command Output ---\n{output}" if output else message
+            if "Execution error" in message:
+                ET.SubElement(tc, "error", {
+                    "message": _xml_escape(message),
+                    "type": "RuntimeError",
+                }).text = _xml_escape(full_text)
+            else:
+                ET.SubElement(tc, "failure", {
+                    "message": _xml_escape(message),
+                    "type": "AssertionError",
+                }).text = _xml_escape(full_text)
+        else:
+            ET.SubElement(tc, "error", {
+                "message": _xml_escape(message or f"Unknown status: {status}"),
+                "type": "UnknownStatus",
+            }).text = _xml_escape(output)
+
+    # Write
+    tree = ET.ElementTree(root)
+    with open(filepath, "w", encoding="utf-8") as f:
+        f.write('<?xml version="1.0" encoding="UTF-8"?>\n')
+        tree.write(f, encoding="unicode")

symtest/utils/path_resolver.py

@@ -0,0 +1,124 @@
+import os
+import shlex
+from pathlib import Path
+from typing import List, Tuple, Union
+import shutil
+
+
+WorkspaceLike = Union[str, Path]
+
+# Commands that are shell builtins (not real executables).
+# Recognised here so they pass through as-is rather than being treated
+# as workspace-relative paths.  Wrapping (cmd /d /c …) happens later
+# in execution._normalize_cmd_list.
+if os.name == 'nt':
+    _SHELL_BUILTINS = frozenset(['echo', 'dir', 'type', 'copy', 'del', 'ren',
+                                  'cd', 'md', 'rd', 'set', 'cls', 'move'])
+else:
+    _SHELL_BUILTINS = frozenset(['echo', 'cd', 'pwd', 'export', 'source'])
+
+
+def _as_workspace_path(workspace: WorkspaceLike) -> Path:
+    return workspace if isinstance(workspace, Path) else Path(workspace)
+
+
+def resolve_command(command: str, workspace: WorkspaceLike) -> str:
+    """
+    Resolve command path:
+    - absolute path: keep
+    - available in PATH: keep
+    - otherwise treat as relative to workspace
+    """
+    workspace_path = _as_workspace_path(workspace)
+
+    if Path(command).is_absolute():
+        return command
+
+    if shutil.which(command) is not None:
+        return command
+
+    return str(workspace_path / command)
+
+
+def _looks_like_relative_path(arg: str) -> bool:
+    """Check if arg explicitly starts with a relative path prefix."""
+    return (arg.startswith("./") or arg.startswith(".\\") or
+            arg.startswith("../") or arg.startswith("..\\"))
+
+
+def resolve_paths(args: List[str], workspace: WorkspaceLike) -> List[str]:
+    """Resolve explicitly relative paths (starting with ./ or ../) against workspace."""
+    workspace_path = _as_workspace_path(workspace)
+    resolved: List[str] = []
+    for arg in args:
+        if _looks_like_relative_path(arg):
+            resolved.append(str(workspace_path / arg))
+        else:
+            resolved.append(arg)
+    return resolved
+
+
+def split_command(command_string: str, workspace: WorkspaceLike) -> Tuple[str, List[str]]:
+    """
+    Split a potentially multi-word command string into its executable and leading arguments.
+    Uses shlex to correctly handle quoted executables (e.g. ''"C:\\Program Files\\app.exe" -v'').
+
+    Example:
+        ''"C:\\Python\\python.exe" -c "print('hi')"'' -> ("C:\\Python\\python.exe", ["-c", "print('hi')"])
+        "python ./script.py"                           -> ("python", ["./script.py"])
+        "echo hello world"                             -> ("echo", ["hello", "world"])
+    """
+    s = command_string.strip()
+    if not s:
+        return "", []
+
+    # Use shlex to properly handle quoted segments.
+    # posix=False preserves Windows backslash-paths but leaves quotes intact.
+    # On Windows we strip quotes manually; on Unix posix=True strips them natively.
+    try:
+        parts = shlex.split(s, posix=(os.name != 'nt'))
+    except ValueError:
+        parts = s.split()
+    if os.name == 'nt':
+        parts = [p.strip('"') for p in parts]
+
+    cmd = parts[0]
+    remaining = parts[1:]
+
+    # Real executable: absolute path or found in PATH
+    if os.path.isabs(cmd) or shutil.which(cmd) is not None:
+        return cmd, remaining
+
+    # Shell builtin -> pass through as-is; wrapping happens at execution time
+    if cmd.lower() in _SHELL_BUILTINS:
+        return cmd, remaining
+
+    # Otherwise treat as workspace-relative path
+    return str(Path(workspace) / cmd), remaining
+
+
+class PathResolver:
+    """
+    Backwards-compatible wrapper; delegates to pure functions.
+    """
+
+    def __init__(self, workspace: Path):
+        self.workspace = workspace
+
+    def resolve_paths(self, args: List[str]) -> List[str]:
+        return resolve_paths(args, self.workspace)
+
+    def resolve_command(self, command: str) -> str:
+        return resolve_command(command, self.workspace)
+
+    def split_command(self, command_string: str) -> Tuple[str, List[str]]:
+        """Split and resolve a command string. Returns (executable, leading_args)."""
+        return split_command(command_string, self.workspace)
+
+    def parse_command_string(self, command_string: str) -> str:
+        """
+        Backward-compatible: resolves and returns the executable name only.
+        Prefer split_command() for new code.
+        """
+        executable, _ = split_command(command_string, self.workspace)
+        return executable