robotcode-runner 2.7.0__py3-none-any.whl → 2.8.0.dev548__py3-none-any.whl

robotcode/runner/__version__.py

@@ -1 +1 @@
-__version__ = "2.7.0"
+__version__ = "2.8.0-dev.548"

robotcode/runner/cli/_markdown.py

@@ -294,6 +294,19 @@ def highlight_md(text: str, highlight: Optional[Callable[[str], str]]) -> str:
     return highlight(text) if highlight else text
 
 
+def metadata_md(metadata: Dict[str, str], highlight: Optional[Callable[[str], str]] = None) -> str:
+    """Test metadata as `name: value, name: value`.
+
+    All pairs share one line, so the lines of a multi-line value are joined
+    with spaces.
+    """
+
+    def hi(text: str) -> str:
+        return highlight_md(md_escape(text), highlight)
+
+    return ", ".join(f"{hi(name)}: {hi(' '.join(value.splitlines()))}" for name, value in metadata.items())
+
+
 def make_md_highlighter(search_substring: Optional[str], search_regex: Optional[str]) -> Optional[Callable[[str], str]]:
     """Build a `text -> highlighted text` callback that wraps each
     regex/substring match in an inline-code span. Returns `None` when

robotcode/runner/cli/_robot_version.py

@@ -0,0 +1,28 @@
+"""Click options and commands that RobotCode offers only from a certain
+Robot Framework version on.
+
+The version is declared once, with `since`: before it, `--help` hides the
+option or command; `scripts/create_cmdline_doc.py` marks it with the version
+in the generated CLI reference. `--help` itself carries no note, since it only
+lists the option where the installed version has it.
+"""
+
+from typing import Any, Tuple
+
+import click
+
+from robotcode.robot.utils import RF_VERSION
+
+
+class RobotVersionOption(click.Option):
+    def __init__(self, *args: Any, since: Tuple[int, int], **kwargs: Any) -> None:
+        kwargs["hidden"] = RF_VERSION < since
+        super().__init__(*args, **kwargs)
+        self.since = since
+
+
+class RobotVersionCommand(click.Command):
+    def __init__(self, *args: Any, since: Tuple[int, int], **kwargs: Any) -> None:
+        kwargs["hidden"] = RF_VERSION < since
+        super().__init__(*args, **kwargs)
+        self.since = since

robotcode/runner/cli/_search.py

@@ -12,7 +12,7 @@ The `--search` / `--search-regex` semantics live here so both `results` and
 
 import re
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Callable, Iterable, Optional
+from typing import TYPE_CHECKING, Callable, Dict, Iterable, Mapping, Optional
 
 import click
 from robot.api import SuiteVisitor
@@ -21,6 +21,7 @@ from robot.model import TestCase as ModelTestCase
 from robot.model.control import For, IfBranch, Return, TryBranch, While
 from robot.model.message import Message
 from robot.result import Keyword as ResultKeyword
+from robot.result import TestCase as ResultTestCase
 from robot.result.model import StatusMixin
 from robot.running import TestCase as RunningTestCase
 from robot.running import TestSuite
@@ -51,6 +52,34 @@ else:
         return for_.variables  # type: ignore[attr-defined,no-any-return,unused-ignore]
 
 
+# RF 7.5 added `[Metadata]` to tests and tasks; `TestCase.metadata` does not
+# exist before.
+SUPPORTS_TEST_METADATA = RF_VERSION >= (7, 5)
+
+
+def named_metadata(metadata: Mapping[str, str]) -> Dict[str, str]:
+    """The entries of a suite's or test's metadata that have a name.
+
+    A `Metadata` setting with nothing after it gives an entry with an empty
+    name and an empty value in Robot's model. That is no metadata: Robot
+    itself leaves it out of `output.xml` (but not out of `output.json`).
+    """
+    return {name: value for name, value in metadata.items() if name}
+
+
+# Shared by `discover` and `results` so both emit the same name → value
+# mapping (author's spelling, RF's order).
+if SUPPORTS_TEST_METADATA:
+
+    def get_test_metadata(test: ModelTestCase) -> Dict[str, str]:
+        return named_metadata(test.metadata)  # type: ignore[attr-defined,unused-ignore]
+
+else:
+
+    def get_test_metadata(test: ModelTestCase) -> Dict[str, str]:
+        return {}
+
+
 @dataclass(frozen=True)
 class SearchMatcher:
     general: Callable[[Optional[str]], bool]
@@ -296,7 +325,9 @@ class SearchModifier(SuiteVisitor):
     A test matches if any of the following matches the predicate:
     - name, full name, source path
     - documentation, template name (running model only), timeout setting
+    - the test's own message, e.g. its failure message (result-tree only)
     - any of its tags (with Robot's tag normalisation)
+    - any of its `[Metadata]` names or values (Robot Framework 7.5+)
     - any keyword name, keyword argument, assigned variable, FOR/WHILE
       condition or VAR/RETURN/EXCEPT/GROUP element inside the test body,
       setup or teardown
@@ -328,10 +359,15 @@ class SearchModifier(SuiteVisitor):
         # don't preserve it, so guard with isinstance.
         if isinstance(test, RunningTestCase) and self.matcher.general(test.template):
             return True
+        if isinstance(test, ResultTestCase) and self.matcher.general(test.message):
+            return True
         if test.timeout is not None and self.matcher.general(str(test.timeout)):
             return True
         if any(self.matcher.tag(str(t)) for t in test.tags):
             return True
+        for name, value in get_test_metadata(test).items():
+            if self.matcher.general(name) or self.matcher.general(value):
+                return True
         if test.has_setup and self.matcher.matches_body([test.setup]):
             return True
         if test.has_teardown and self.matcher.matches_body([test.teardown]):

robotcode/runner/cli/discover/_models.py

@@ -1,7 +1,7 @@
 """Data models emitted by `robotcode discover`.
 
 All models inherit from `CamelSnakeMixin` so the JSON output uses
-camelCase keys (`fullName`, `relSource`, `supportsParseInclude`, …)
+camelCase keys (`relSource`, `supportsParseInclude`, `robotVersionString`, …)
 consistent with the `results` family. Editor integrations and CI
 recipes rely on that shape.
 """
@@ -27,6 +27,7 @@ class TestItem(CamelSnakeMixin):
     description: Optional[str] = None
     range: Optional[Range] = None
     tags: Optional[List[str]] = None
+    metadata: Optional[Dict[str, str]] = None
     error: Optional[str] = None
     rpa: Optional[bool] = None
 
@@ -54,6 +55,15 @@ class TagsResult(CamelSnakeMixin):
     filters_applied: Optional[Dict[str, str]] = None
 
 
+@dataclass
+class MetadataResult(CamelSnakeMixin):
+    """`discover metadata`: name → value → items, for tests/tasks and for suites."""
+
+    metadata: Dict[str, Dict[str, List[TestItem]]]
+    suite_metadata: Dict[str, Dict[str, List[TestItem]]]
+    filters_applied: Optional[Dict[str, str]] = None
+
+
 @dataclass
 class Info(CamelSnakeMixin):
     robot_version_string: str

robotcode/runner/cli/discover/_render.py

@@ -25,6 +25,7 @@ from .._markdown import (
     filters_footer_md,
     highlight_md,
     md_escape,
+    metadata_md,
     path_paren,
 )
 from ._models import Info, Statistics, TestItem
@@ -301,6 +302,7 @@ def render_tests_or_tasks(
     *,
     selected_type: str,
     show_tags: bool,
+    show_metadata: bool = False,
     full_paths: bool,
     highlight: Optional[Callable[[str], str]] = None,
     search_substring: Optional[str] = None,
@@ -325,6 +327,8 @@ def render_tests_or_tasks(
             if show_tags and item.tags:
                 tags = ", ".join(f"`{_hi(str(tag), highlight)}`" for tag in sorted(item.tags))
                 lines.append(f"  - _Tags:_ {tags}")
+            if show_metadata and item.metadata:
+                lines.append(f"  - _Metadata:_ {metadata_md(item.metadata, highlight)}")
         body_md = "\n".join(lines)
 
     return _block_md(
@@ -391,6 +395,88 @@ def render_tags(
     )
 
 
+# ---------------------------------------------------------------------------
+# `discover metadata`
+# ---------------------------------------------------------------------------
+
+
+def _metadata_section_md(
+    index: Dict[str, Dict[str, List[TestItem]]],
+    *,
+    show_values: bool,
+    show_item: Callable[[TestItem], bool],
+    full_paths: bool,
+    highlight: Optional[Callable[[str], str]],
+) -> List[str]:
+    def item_md(item: TestItem) -> str:
+        paren = _item_paren(item, full_paths=full_paths, with_line=item.type != "suite")
+        return f"**{_hi(item.longname, highlight)}**{paren}"
+
+    lines: List[str] = []
+    for name, values in index.items():
+        lines.append(f"- **{_hi(name, highlight)}**")
+        if show_values:
+            for value, items in values.items():
+                lines.append(f"  - {_hi(value, highlight) if value else '_(no value)_'}")
+                lines.extend(f"    - {item_md(item)}" for item in items if show_item(item))
+        else:
+            # Each item once under its name, even when it has several values.
+            listed: List[TestItem] = []
+            for items in values.values():
+                listed.extend(item for item in items if show_item(item) and all(item is not i for i in listed))
+            lines.extend(f"  - {item_md(item)}" for item in listed)
+    return lines
+
+
+def render_metadata(
+    test_metadata: Dict[str, Dict[str, List[TestItem]]],
+    suite_metadata: Dict[str, Dict[str, List[TestItem]]],
+    statistics: Statistics,
+    *,
+    show_values: bool,
+    show_tests: bool,
+    show_tasks: bool,
+    show_suites: bool,
+    full_paths: bool,
+    highlight: Optional[Callable[[str], str]] = None,
+    search_substring: Optional[str] = None,
+    search_regex: Optional[str] = None,
+    diagnostics: Optional[Dict[str, List[Diagnostic]]] = None,
+    show_diagnostics: bool = False,
+    root_folder: Optional[Path] = None,
+) -> str:
+    def show_test_or_task(item: TestItem) -> bool:
+        if show_tests == show_tasks:
+            return show_tests
+        return item.type == ("test" if show_tests else "task")
+
+    parts: List[str] = []
+    for heading, index, show_item in (
+        ("Tests and Tasks", test_metadata, show_test_or_task),
+        ("Suites", suite_metadata, lambda _item: show_suites),
+    ):
+        if not index:
+            continue
+        if parts:
+            parts.append("")
+        parts += [f"## {heading}", ""]
+        parts += _metadata_section_md(
+            index, show_values=show_values, show_item=show_item, full_paths=full_paths, highlight=highlight
+        )
+
+    return _block_md(
+        heading="Metadata",
+        body_md="\n".join(parts) if parts else "_(no metadata matched)_",
+        statistics=statistics,
+        diagnostics=diagnostics,
+        show_diagnostics=show_diagnostics,
+        full_paths=full_paths,
+        root_folder=root_folder,
+        search_substring=search_substring,
+        search_regex=search_regex,
+    )
+
+
 # ---------------------------------------------------------------------------
 # `discover all` — workspace → suites → tests/tasks tree as nested list
 # ---------------------------------------------------------------------------
@@ -401,6 +487,7 @@ def render_all(
     statistics: Statistics,
     *,
     show_tags: bool,
+    show_metadata: bool = False,
     full_paths: bool,
     highlight: Optional[Callable[[str], str]] = None,
     search_substring: Optional[str] = None,
@@ -412,7 +499,15 @@ def render_all(
     """The full discovery tree: workspace at depth 0, suites at
     increasing depth, tests/tasks as leaves with their line number."""
     tree_lines: List[str] = []
-    _emit_tree(root, tree_lines, depth=0, show_tags=show_tags, full_paths=full_paths, highlight=highlight)
+    _emit_tree(
+        root,
+        tree_lines,
+        depth=0,
+        show_tags=show_tags,
+        show_metadata=show_metadata,
+        full_paths=full_paths,
+        highlight=highlight,
+    )
     return _block_md(
         heading="All",
         body_md="\n".join(tree_lines),
@@ -432,6 +527,7 @@ def _emit_tree(
     *,
     depth: int,
     show_tags: bool,
+    show_metadata: bool,
     full_paths: bool,
     highlight: Optional[Callable[[str], str]] = None,
 ) -> None:
@@ -443,5 +539,15 @@ def _emit_tree(
     if is_leaf and show_tags and item.tags:
         tags = ", ".join(f"`{_hi(str(tag), highlight)}`" for tag in sorted(item.tags))
         out.append(f"{indent}  - _Tags:_ {tags}")
+    if is_leaf and show_metadata and item.metadata:
+        out.append(f"{indent}  - _Metadata:_ {metadata_md(item.metadata, highlight)}")
     for child in item.children or []:
-        _emit_tree(child, out, depth=depth + 1, show_tags=show_tags, full_paths=full_paths, highlight=highlight)
+        _emit_tree(
+            child,
+            out,
+            depth=depth + 1,
+            show_tags=show_tags,
+            show_metadata=show_metadata,
+            full_paths=full_paths,
+            highlight=highlight,
+        )