robotframework-request-logger 0.1.0__tar.gz

robotframework_request_logger-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Angel Molina
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

robotframework_request_logger-0.1.0/PKG-INFO

@@ -0,0 +1,74 @@
+Metadata-Version: 2.4
+Name: robotframework-request-logger
+Version: 0.1.0
+Summary: Protected HTTP request and response console logging for Robot Framework with Rich.
+License-Expression: MIT
+License-File: LICENSE
+Keywords: robotframework,requests,console,rich
+Author: Angel Molina
+Requires-Python: >=3.12,<4
+Classifier: Framework :: Robot Framework :: Library
+Classifier: Programming Language :: Python :: 3
+Classifier: Development Status :: 3 - Alpha
+Requires-Dist: requests (>=2.32,<3)
+Requires-Dist: rich (>=14,<15)
+Requires-Dist: robotframework (>=7.5,<8)
+Project-URL: Documentation, https://angel-valdezzz.github.io/robotframework-request-logger/
+Project-URL: Repository, https://github.com/angel-valdezzz/robotframework-request-logger
+Description-Content-Type: text/markdown
+
+# Robot Framework Request Logger
+
+HTTP request/response logging in the console with Rich. Independent of RequestReporter:
+this library sends no HTTP requests and executes no assertions. Robot's console and
+exit code remain unchanged. Output is buffered until each test finishes.
+
+[Manual de usuario](https://angel-valdezzz.github.io/robotframework-request-logger/)
+· [Keywords](https://angel-valdezzz.github.io/robotframework-request-logger/keywords/)
+· [Ejemplos visuales](https://angel-valdezzz.github.io/robotframework-request-logger/console/)
+
+```bash
+poetry add robotframework-request-logger
+```
+
+```robotframework
+*** Settings ***
+Library    RequestsLibrary
+Library    RequestLogger    mode=summary
+
+*** Test Cases ***
+Health
+    ${response}=    GET    http://localhost:8000/health    expected_status=anything
+    ${id}=    Log Response    Health    ${response}
+    Should Be Equal As Integers    ${response.status_code}    200
+    Log Assertion Result    ${id}    HTTP status    PASS
+```
+
+`mode=summary` shows every exchange briefly; `failures` shows full details of explicitly
+failed assertions or request errors; `full` shows every exchange in detail. An HTTP
+4xx/5xx response alone does not make a test fail. Assertions accept PASS/FAIL only.
+
+Default operation complements Robot's normal console. For examples showing only this
+library, use `poetry run robot --console none tests/visual.robot`. `quiet` still permits
+Robot errors and warnings. Native `output.xml`, `log.html` and exit codes are preserved.
+
+## Development
+
+```bash
+poetry install
+poetry run python scripts/verify.py
+poetry run ruff check .
+poetry run ruff format .
+poetry run robocop check tests
+poetry run robocop format tests
+poetry run python scripts/build_docs.py
+poetry build
+```
+
+Known limits: buffering is in memory and output occurs at end_test. Abrupt termination
+may lose pending logs. Pabot workers can interleave output; no cross-process ordering
+is promised. JSON/text bodies are complete; binary/multipart bodies are summarized.
+XML field redaction is not supported. Protection affects this library's output only,
+not RequestsLibrary/Robot's own logs. Typer and pytest/unittest integration are outside
+this version. Unit tests of implementation use Python's standard test tools.
+

robotframework_request_logger-0.1.0/README.md

@@ -0,0 +1,54 @@
+# Robot Framework Request Logger
+
+HTTP request/response logging in the console with Rich. Independent of RequestReporter:
+this library sends no HTTP requests and executes no assertions. Robot's console and
+exit code remain unchanged. Output is buffered until each test finishes.
+
+[Manual de usuario](https://angel-valdezzz.github.io/robotframework-request-logger/)
+· [Keywords](https://angel-valdezzz.github.io/robotframework-request-logger/keywords/)
+· [Ejemplos visuales](https://angel-valdezzz.github.io/robotframework-request-logger/console/)
+
+```bash
+poetry add robotframework-request-logger
+```
+
+```robotframework
+*** Settings ***
+Library    RequestsLibrary
+Library    RequestLogger    mode=summary
+
+*** Test Cases ***
+Health
+    ${response}=    GET    http://localhost:8000/health    expected_status=anything
+    ${id}=    Log Response    Health    ${response}
+    Should Be Equal As Integers    ${response.status_code}    200
+    Log Assertion Result    ${id}    HTTP status    PASS
+```
+
+`mode=summary` shows every exchange briefly; `failures` shows full details of explicitly
+failed assertions or request errors; `full` shows every exchange in detail. An HTTP
+4xx/5xx response alone does not make a test fail. Assertions accept PASS/FAIL only.
+
+Default operation complements Robot's normal console. For examples showing only this
+library, use `poetry run robot --console none tests/visual.robot`. `quiet` still permits
+Robot errors and warnings. Native `output.xml`, `log.html` and exit codes are preserved.
+
+## Development
+
+```bash
+poetry install
+poetry run python scripts/verify.py
+poetry run ruff check .
+poetry run ruff format .
+poetry run robocop check tests
+poetry run robocop format tests
+poetry run python scripts/build_docs.py
+poetry build
+```
+
+Known limits: buffering is in memory and output occurs at end_test. Abrupt termination
+may lose pending logs. Pabot workers can interleave output; no cross-process ordering
+is promised. JSON/text bodies are complete; binary/multipart bodies are summarized.
+XML field redaction is not supported. Protection affects this library's output only,
+not RequestsLibrary/Robot's own logs. Typer and pytest/unittest integration are outside
+this version. Unit tests of implementation use Python's standard test tools.

robotframework_request_logger-0.1.0/pyproject.toml

@@ -0,0 +1,48 @@
+[project]
+name = "robotframework-request-logger"
+version = "0.1.0"
+description = "Protected HTTP request and response console logging for Robot Framework with Rich."
+authors = [{name = "Angel Molina"}]
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.12,<4"
+dependencies = ["robotframework>=7.5,<8", "requests>=2.32,<3", "rich>=14,<15"]
+keywords = ["robotframework", "requests", "console", "rich"]
+classifiers = ["Framework :: Robot Framework :: Library", "Programming Language :: Python :: 3", "Development Status :: 3 - Alpha"]
+
+[project.urls]
+Repository = "https://github.com/angel-valdezzz/robotframework-request-logger"
+Documentation = "https://angel-valdezzz.github.io/robotframework-request-logger/"
+
+[tool.poetry]
+packages = [{include = "request_logger", from = "src"}, {include = "RequestLogger.py", from = "src"}]
+requires-poetry = ">=2.5.1,<3"
+
+[tool.poetry.group.dev.dependencies]
+robotframework-requests = "0.9.7"
+robotframework-robocop = "^9.1.0"
+ruff = ">=0.16,<1"
+mypy = ">=1.15,<2"
+types-requests = "*"
+twine = ">=6,<7"
+
+[tool.poetry.group.docs.dependencies]
+mkdocs-material = ">=9.6,<10"
+
+[tool.ruff]
+line-length = 100
+target-version = "py312"
+[tool.ruff.lint]
+select = ["E", "F", "I", "B", "UP"]
+[tool.mypy]
+python_version = "3.12"
+disallow_untyped_defs = true
+check_untyped_defs = true
+ignore_missing_imports = true
+[tool.robocop]
+target-version = 7
+[tool.robocop.lint]
+threshold = "E"
+[build-system]
+requires = ["poetry-core>=2.0,<3"]
+build-backend = "poetry.core.masonry.api"

robotframework_request_logger-0.1.0/src/RequestLogger.py

@@ -0,0 +1,5 @@
+"""Public Robot Framework library import."""
+
+from request_logger import RequestLogger
+
+__all__ = ["RequestLogger"]

robotframework_request_logger-0.1.0/src/request_logger/__init__.py

@@ -0,0 +1,235 @@
+"""HTTP console logging for Robot Framework; does not execute requests or assertions.
+
+```robotframework
+*** Settings ***
+Library    RequestsLibrary
+Library    RequestLogger    mode=summary
+
+*** Test Cases ***
+Health
+    ${response}=    GET    ${URL}    expected_status=anything
+    ${id}=    Log Response    Health    ${response}
+    Should Be Equal As Integers    ${response.status_code}    200
+    Log Assertion Result    ${id}    HTTP status    PASS
+```
+
+Output is buffered until end_test so failures can be filtered and secrets learned
+later in a case can be hidden. Robot's native console and return code are unchanged.
+"""
+
+import sys
+from typing import Any
+
+from requests import PreparedRequest, Response
+from rich.console import Console, Group
+from rich.text import Text
+from robot.api import logger
+from robot.api.deco import keyword, library
+
+from .models import Assertion, Exchange
+from .protection import Protector
+from .render import exchange
+
+__version__ = "0.1.0"
+_HEADERS = "Authorization,Proxy-Authorization,Cookie,Set-Cookie,X-API-Key"
+_FIELDS = "access_token,refresh_token,client_secret,password,token,api_key"
+
+
+@library(scope="GLOBAL", version=__version__, doc_format="MARKDOWN", auto_keywords=False)
+class RequestLogger:
+    """Case-local HTTP console output with no dependency on RequestReporter."""
+
+    ROBOT_LISTENER_API_VERSION = 3
+
+    def __init__(
+        self,
+        mode: str = "summary",
+        redact_headers: str = _HEADERS,
+        redact_body_fields: str = _FIELDS,
+    ) -> None:
+        """Choose summary (default), failures or full.
+
+        summary prints all exchanges briefly; failures prints full details only for
+        explicitly failed assertions or request errors; full prints all details.
+        HTTP 4xx/5xx alone does not imply test failure. Assertions accept PASS/FAIL only.
+        No HTTP call or assertion is executed by this library. No console mode is
+        changed. In CI output is static, with Rich terminal detection and plain text
+        fallback. Full text/JSON bodies are kept; binary/multipart bodies are summarized.
+        XML field redaction is not supported. Redaction affects this console only.
+
+        ```robotframework
+        Library    RequestLogger    mode=full
+        ```
+        """
+        if mode not in {"summary", "failures", "full"}:
+            raise ValueError("mode must be summary, failures or full")
+        self.mode = mode
+        self.redact_headers = redact_headers
+        self.redact_body_fields = redact_body_fields
+        self.ROBOT_LIBRARY_LISTENER = self
+        self.records: list[Exchange] = []
+        self.protector = Protector(redact_headers, redact_body_fields)
+        self.active = False
+
+    def start_test(self, data: Any, result: Any) -> None:
+        self.records = []
+        self.protector = Protector(self.redact_headers, self.redact_body_fields)
+        self.active = True
+
+    def end_test(self, data: Any, result: Any) -> None:
+        try:
+            visible = [r for r in self.records if self.mode != "failures" or r.failed]
+            items = [exchange(r, self.mode != "summary", self.protector) for r in visible]
+            if result.status in {"FAIL", "SKIP"}:
+                items.append(
+                    Text(
+                        self.protector.text(f"Robot {result.status}: {result.message}"),
+                        style="red" if result.status == "FAIL" else "yellow",
+                    )
+                )
+            if items:
+                # Robot captures sys.stdout during keywords. Use its original stream,
+                # while retaining Rich's detection for redirected/non-interactive output.
+                console = Console(
+                    file=sys.__stdout__ or sys.stdout,
+                    force_interactive=False,
+                    markup=False,
+                    highlight=False,
+                    safe_box=True,
+                )
+                console.print(Group(*items))
+        except (OSError, UnicodeError) as error:
+            logger.warn(f"RequestLogger output unavailable: {type(error).__name__}")
+        finally:
+            self.active = False
+            self.records = []
+
+    def _require_case(self) -> None:
+        if not self.active:
+            raise RuntimeError("Logger keywords must run inside an active Robot test")
+
+    def _find(self, request_id: str) -> Exchange:
+        self._require_case()
+        for r in self.records:
+            if r.id == request_id:
+                return r
+        raise ValueError(f"Unknown request ID in current test: {request_id}")
+
+    @keyword("Log Request")
+    def log_request(self, name: str, request: PreparedRequest) -> str:
+        """Register an already prepared requests.PreparedRequest; return a case-local ID.
+
+        Does not send HTTP. Usually Log Response alone is sufficient. Passing the same
+        prepared request to Log Request and Log Response reuses the ID and one record.
+        A request without a response is not automatically classified as a failed test.
+
+        ```robotframework
+        ${id}=    Log Request    Health    ${response.request}
+        ```
+        """
+        self._require_case()
+        if not isinstance(request, PreparedRequest):
+            raise TypeError("request must be a requests.PreparedRequest")
+        found = next((r for r in self.records if r.original_request is request), None)
+        if found:
+            return found.id
+        headers = self.protector.header_values(request.headers)
+        url = self.protector.url(request.url or "")
+        request_body = self.protector.body(request.body, request.headers.get("Content-Type", ""))
+        record = Exchange(
+            id=f"request-{len(self.records) + 1}",
+            name=name,
+            method=request.method or "",
+            url=url,
+            request_headers=headers,
+            request_body=request_body,
+            original_request=request,
+        )
+        self.records.append(record)
+        return record.id
+
+    @keyword("Log Response")
+    def log_response(self, name: str, response: Response) -> str:
+        """Register an existing requests.Response and its prepared request; return its ID.
+
+        Does not execute HTTP. Capture before validating status or parsing JSON.
+        Headers, bodies, elapsed time and URL are shown according to mode at test end.
+        A repeated call for the same prepared request updates its existing record.
+
+        ```robotframework
+        ${response}=    GET    ${URL}    expected_status=anything
+        ${id}=    Log Response    Health    ${response}
+        ```
+        """
+        self._require_case()
+        if not isinstance(response, Response) or response.request is None:
+            raise TypeError("response must be a requests.Response with a prepared request")
+        request_id = self.log_request(name, response.request)
+        r = self._find(request_id)
+        r.response_headers = self.protector.header_values(response.headers)
+        r.response_body = self.protector.body(
+            response.content, response.headers.get("Content-Type", "")
+        )
+        r.status_code = response.status_code
+        r.duration_ms = round(response.elapsed.total_seconds() * 1000, 2)
+        return request_id
+
+    @keyword("Log Request Error")
+    def log_request_error(
+        self, name: str, method: str, url: str, message: str, request_id: str | None = None
+    ) -> str:
+        """Register an HTTP attempt without a response; return its ID.
+
+        No HTTP status or response body is fabricated. Optional request_id associates
+        the error with an earlier Log Request. This keyword does not fail the test:
+        propagate the original failure after logging it.
+
+        ```robotframework
+        TRY
+            ${response}=    GET    ${URL}    timeout=10
+        EXCEPT    AS    ${error}
+            Log Request Error    Health    GET    ${URL}    ${error}
+            Fail    ${error}
+        END
+        ```
+        """
+        self._require_case()
+        protected_url = self.protector.url(url)
+        if request_id:
+            r = self._find(request_id)
+            if r.status_code is not None:
+                raise ValueError("A received HTTP response is not a request transport error")
+        else:
+            r = Exchange(
+                id=f"request-{len(self.records) + 1}",
+                name=name,
+                method=method.upper(),
+                url=protected_url,
+            )
+            self.records.append(r)
+        r.error = self.protector.text(message) or "HTTP request failed without a response"
+        return r.id
+
+    @keyword("Log Assertion Result")
+    def log_assertion_result(
+        self, request_id: str, label: str, status: str, message: str = ""
+    ) -> None:
+        """Associate an already obtained PASS/FAIL result; does not execute assertions.
+
+        status must be PASS or FAIL. Unknown IDs and SKIP are rejected. This records
+        evidence only: a logged FAIL does not change Robot's native test result.
+        Use Robot's actual assertion and preserve its failure when obtaining status.
+
+        ```robotframework
+        ${status}    ${message}=    Run Keyword And Ignore Error
+        ...    Should Be Equal As Integers    ${response.status_code}    200
+        Log Assertion Result    ${id}    HTTP status    ${status}    ${message}
+        IF    $status == 'FAIL'
+            Fail    ${message}
+        END
+        ```
+        """
+        r = self._find(request_id)
+        if status not in {"PASS", "FAIL"}:
+            raise ValueError("Assertion status must be PASS or FAIL")
+        r.assertions.append(Assertion(label, status, message))

robotframework_request_logger-0.1.0/src/request_logger/models.py

@@ -0,0 +1,32 @@
+"""Case-local HTTP records; no Robot execution objects or reporter dependency."""
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class Assertion:
+    label: str
+    status: str
+    message: str = ""
+
+
+@dataclass
+class Exchange:
+    id: str
+    name: str
+    method: str
+    url: str
+    request_headers: dict[str, str] = field(default_factory=dict)
+    request_body: Any = None
+    response_headers: dict[str, str] = field(default_factory=dict)
+    response_body: Any = None
+    status_code: int | None = None
+    duration_ms: float | None = None
+    error: str = ""
+    assertions: list[Assertion] = field(default_factory=list)
+    original_request: Any = field(default=None, repr=False)
+
+    @property
+    def failed(self) -> bool:
+        return bool(self.error) or any(a.status == "FAIL" for a in self.assertions)

robotframework_request_logger-0.1.0/src/request_logger/protection.py

@@ -0,0 +1,114 @@
+"""Protect secrets and terminal output without depending on an HTML reporter."""
+
+import json
+import re
+from typing import Any
+from urllib.parse import parse_qsl, unquote, urlencode, urlsplit, urlunsplit
+
+MASK = "[REDACTED]"
+
+
+def safe_text(value: str) -> str:
+    """Remove terminal control sequences from untrusted HTTP and Robot text."""
+    value = re.sub(r"\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)", "", value)
+    value = re.sub(r"\x1b\[[0-?]*[ -/]*[@-~]", "", value)
+    return re.sub(r"[\x00-\x08\x0b-\x1f\x7f-\x9f]", "", value)
+
+
+class Protector:
+    def __init__(self, headers: str, fields: str) -> None:
+        self.headers = {v.strip().lower() for v in headers.split(",") if v.strip()}
+        self.fields = {v.strip().lower() for v in fields.split(",") if v.strip()}
+        self.secrets: set[str] = set()
+
+    def remember(self, value: Any) -> None:
+        if isinstance(value, str) and value:
+            self.secrets.add(value)
+            if value.lower().startswith("bearer "):
+                self.secrets.add(value[7:])
+        elif isinstance(value, dict):
+            for v in value.values():
+                self.remember(v)
+        elif isinstance(value, (list, tuple)):
+            for v in value:
+                self.remember(v)
+
+    def text(self, value: str) -> str:
+        for secret in sorted(self.secrets, key=len, reverse=True):
+            value = value.replace(secret, MASK)
+        return safe_text(value)
+
+    def clean(self, value: Any) -> Any:
+        if isinstance(value, dict):
+            out = {}
+            for k, v in value.items():
+                if str(k).lower() in self.fields:
+                    self.remember(v)
+                    out[str(k)] = MASK
+                else:
+                    out[str(k)] = self.clean(v)
+            return out
+        if isinstance(value, (list, tuple)):
+            return [self.clean(v) for v in value]
+        if isinstance(value, str):
+            return self.text(value)
+        if value is None or isinstance(value, (int, float, bool)):
+            return value
+        return self.text(str(value))
+
+    def header_values(self, headers: Any) -> dict[str, str]:
+        out = {}
+        for k, v in headers.items():
+            if k.lower() in self.headers:
+                self.remember(str(v))
+                out[str(k)] = MASK
+            else:
+                out[str(k)] = self.text(str(v))
+        return out
+
+    def url(self, url: str) -> str:
+        parts = urlsplit(url)
+        pairs = []
+        for k, v in parse_qsl(parts.query, keep_blank_values=True):
+            if k.lower() in self.fields:
+                self.remember(v)
+                v = MASK
+            pairs.append((k, v))
+        netloc = parts.netloc
+        if "@" in netloc:
+            credentials, host = netloc.rsplit("@", 1)
+            self.remember(credentials)
+            if parts.password:
+                self.remember(unquote(parts.password))
+            netloc = MASK + "@" + host
+        return self.text(
+            urlunsplit((parts.scheme, netloc, parts.path, urlencode(pairs), parts.fragment))
+        )
+
+    def body(self, value: Any, content_type: str) -> Any:
+        if value is None:
+            return None
+        if "multipart/" in content_type.lower():
+            return "[Multipart body omitted]"
+        if isinstance(value, bytes):
+            if not any(
+                v in content_type.lower() for v in ("json", "text/", "xml", "form", "javascript")
+            ):
+                return f"[Binary body: {len(value)} bytes]"
+            value = value.decode("utf-8", errors="replace")
+        if not isinstance(value, str):
+            return self.clean(value)
+        if "application/x-www-form-urlencoded" in content_type.lower():
+            # Preserve repeated field names and empty values.
+            pairs = parse_qsl(value, keep_blank_values=True)
+            for k, v in pairs:
+                if k.lower() in self.fields:
+                    self.remember(v)
+            return [
+                {"name": k, "value": MASK if k.lower() in self.fields else self.text(v)}
+                for k, v in pairs
+            ]
+        try:
+            return self.clean(json.loads(value))
+        except (ValueError, TypeError):
+            return self.text(value)

robotframework_request_logger-0.1.0/src/request_logger/render.py

@@ -0,0 +1,73 @@
+"""Static Rich rendering suitable for native terminals and redirected CI logs."""
+
+from typing import Any
+from urllib.parse import parse_qsl, urlsplit
+
+from rich.console import Group, RenderableType
+from rich.json import JSON
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+from .models import Exchange
+from .protection import Protector
+
+
+def body(value: Any, protector: Protector) -> RenderableType:
+    value = protector.clean(value)
+    if value is None or value == "":
+        return Text("Body is empty", style="dim")
+    if isinstance(value, (dict, list)):
+        return JSON.from_data(value, indent=2, ensure_ascii=False)
+    return Text(str(value))
+
+
+def exchange(record: Exchange, full: bool, protector: Protector) -> RenderableType:
+    title = protector.text(record.name)
+    status = "No response" if record.status_code is None else f"HTTP {record.status_code}"
+    color = (
+        "red"
+        if record.error
+        else ("green" if record.status_code and 200 <= record.status_code < 300 else "yellow")
+    )
+    facts = Text()
+    facts.append(record.method + " ", style="bold cyan")
+    facts.append(protector.text(record.url))
+    facts.append("\n" + status, style=color)
+    if record.duration_ms is not None:
+        facts.append(f" · {record.duration_ms:.2f} ms")
+    items: list[RenderableType] = [facts]
+    if record.error:
+        items.append(Text(protector.text(record.error), style="red"))
+    if full:
+        pairs = parse_qsl(urlsplit(record.url).query, keep_blank_values=True)
+        if pairs:
+            items += [
+                Text("Params", style="bold"),
+                JSON.from_data(
+                    protector.clean([{"name": k, "value": v} for k, v in pairs]), ensure_ascii=False
+                ),
+            ]
+        items += [
+            Text("Request headers", style="bold"),
+            JSON.from_data(protector.clean(record.request_headers), ensure_ascii=False),
+            Text("Request body", style="bold"),
+            body(record.request_body, protector),
+        ]
+        if record.status_code is not None:
+            items += [
+                Text("Response headers", style="bold"),
+                JSON.from_data(protector.clean(record.response_headers), ensure_ascii=False),
+                Text("Response body", style="bold"),
+                body(record.response_body, protector),
+            ]
+    if record.assertions:
+        table = Table("Assertion", "Result", "Message", box=None, expand=True)
+        for a in record.assertions:
+            table.add_row(
+                Text(protector.text(a.label)),
+                Text(a.status, style="green" if a.status == "PASS" else "red"),
+                Text(protector.text(a.message)),
+            )
+        items.append(table)
+    return Panel(Group(*items), title=Text(title), border_style="red" if record.failed else "cyan")