robotframework-request-reporter 0.3.0__py3-none-any.whl

APICaseReporter/__init__.py

@@ -0,0 +1,6 @@
+"""Compatibility import; use RequestReporter for new suites."""
+
+from request_reporter import RequestReporter, __version__
+
+APICaseReporter = RequestReporter
+__all__ = ["APICaseReporter", "__version__"]

RequestReporter.py

@@ -0,0 +1,5 @@
+"""Public Robot Framework import for RequestReporter."""
+
+from request_reporter import RequestReporter, __version__
+
+__all__ = ["RequestReporter", "__version__"]

request_reporter/__init__.py

@@ -0,0 +1,278 @@
+"""Generate an independent HTML API evidence report for each Robot Framework test.
+
+Import this library alongside RequestsLibrary. Capture each completed HTTP exchange
+and associate assertions with its returned identifier using [Assert]. The library
+registers its own listener and writes a report when the test finishes.
+
+```robotframework
+*** Settings ***
+Library    RequestsLibrary
+Library    RequestReporter
+
+*** Test Cases ***
+Example
+    ${response}=    GET    http://localhost:8000/health    expected_status=anything
+    ${id}=    Capture Response    Health    ${response}
+    Assert    ${id}    HTTP status
+    ...    Should Be Equal As Integers    ${response.status_code}    200
+```
+
+See [Importing] for configuration. This library does not execute requests or alter
+Robot's failure continuation policy. HTTP transport errors without a response appear
+in the test's final error message; they do not produce a fabricated exchange.
+"""
+
+from datetime import UTC, datetime
+from pathlib import Path
+from time import perf_counter
+from typing import Any
+
+from requests import Response
+from robot.api import logger
+from robot.api.deco import keyword, library
+from robot.libraries.BuiltIn import BuiltIn
+
+from .models import Case, Exchange, ExecutionError, Validation
+from .redaction import Redactor
+from .render import write_report
+
+__version__ = "0.3.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 RequestReporter:
+    """Robot library and listener for one self-contained HTML per test case."""
+
+    ROBOT_LISTENER_API_VERSION = 3
+
+    def __init__(
+        self,
+        output_dir: str | None = None,
+        language: str = "en",
+        redact_headers: str = _HEADERS,
+        redact_body_fields: str = _FIELDS,
+    ) -> None:
+        """Configure the reporter without creating files during import or Libdoc.
+
+        | Argument | Meaning |
+        | --- | --- |
+        | output_dir | Report directory; default is Robot's OUTPUT DIR/cases. |
+        | language | Interface language. Version 0.3 supports `en` only. |
+        | redact_headers | Comma-separated header names; matched case-insensitively. |
+        | redact_body_fields | Comma-separated JSON/form/query field names. |
+
+        ```robotframework
+        Library    RequestReporter    output_dir=${OUTPUT DIR}/cases
+        ```
+
+        Metadata and validation labels retain the language provided by the caller.
+        Redaction applies to this library's HTML only, not Robot/RequestsLibrary logs.
+        Binary responses are represented as a byte-count summary. Uploaded files and
+        multipart request bodies are summarized instead of embedded.
+        """
+        if language != "en":
+            raise ValueError("Only language=en is supported in version 0.3.")
+        self.ROBOT_LIBRARY_LISTENER = self
+        self.output_dir = output_dir
+        self.redact_headers = redact_headers
+        self.redact_body_fields = redact_body_fields
+        self.case: Case | None = None
+        self.redactor = Redactor(redact_headers, redact_body_fields)
+        self.started_at = 0.0
+        self._checking = 0
+        self._failure_keywords: list[Any] = []
+
+    def start_test(self, data: Any, result: Any) -> None:
+        self._checking = 0
+        self._failure_keywords = []
+        self.redactor = Redactor(self.redact_headers, self.redact_body_fields)
+        self.case = Case(
+            name=data.name,
+            source=str(data.source or ""),
+            test_id=result.id,
+            started=datetime.now(UTC).isoformat(),
+        )
+        self.started_at = perf_counter()
+
+    def end_keyword(self, data: Any, result: Any) -> None:
+        """Record leaf failures outside Check without parsing Robot's message."""
+        if self.case is None or self._checking or result.status != "FAIL":
+            return
+        if any(getattr(item, "status", "") == "FAIL" for item in result.body):
+            return
+        # Keep result references until parents reach their final status. A failed
+        # keyword caught by TRY/EXCEPT or an error-handling keyword is not an
+        # unhandled execution error, even when a later step fails the same case.
+        self._failure_keywords.append(result)
+
+    def end_test(self, data: Any, result: Any) -> None:
+        case = self._current()
+        case.status = result.status
+        if case.status == "FAIL":
+            for failed in self._failure_keywords:
+                parent = failed.parent
+                handled = False
+                while parent is not None and parent is not result:
+                    if getattr(parent, "status", "") == "PASS":
+                        handled = True
+                        break
+                    parent = parent.parent
+                if not handled:
+                    case.execution_errors.append(
+                        ExecutionError(
+                            keyword=self.redactor.text(failed.name),
+                            message=self.redactor.text(failed.message or "Keyword failed"),
+                        )
+                    )
+        case.message = self.redactor.text(result.message or "")
+        case.duration_ms = round((perf_counter() - self.started_at) * 1000, 2)
+        output = self.output_dir or str(
+            Path(BuiltIn().get_variable_value("${OUTPUT DIR}", ".")) / "cases"
+        )
+        try:
+            path = write_report(case, Path(output), self.redactor)
+            logger.info(f"API case report: {path}")
+        except (OSError, ValueError) as error:
+            result.status = "FAIL"
+            result.message = (
+                result.message + f"\nCould not write API case report: {error}"
+            ).strip()
+            logger.error(result.message)
+        finally:
+            self.case = None
+
+    def _current(self) -> Case:
+        if self.case is None:
+            raise RuntimeError("Reporter keywords must run inside an active Robot test case.")
+        return self.case
+
+    @keyword("Set Case Metadata")
+    def set_case_metadata(self, **metadata: Any) -> None:
+        """Add optional metadata to the current case, replacing matching keys.
+
+        Name, status, source and duration are captured automatically. Metadata is
+        optional; no case ID or data row is required to generate a report.
+
+        ```robotframework
+        Set Case Metadata    case_id=DIST-002    environment=QA    data_row=2
+        ```
+
+        Returns nothing. Raises an error outside an active test. Configured sensitive
+        field names are redacted. See [Capture Response].
+        """
+        self._current().metadata.update(self.redactor.clean(metadata))
+
+    @keyword("Capture Response")
+    def capture_response(self, name: str, response: Response) -> str:
+        """Capture one RequestsLibrary response and return its case-local request ID.
+
+        `response` must be a requests.Response with a prepared request. Captures the
+        method, URL, request/response headers and bodies, status code and elapsed time.
+        Capture before checking HTTP status so unsuccessful responses remain visible.
+
+        ```robotframework
+        ${response}=    GET    ${URL}    expected_status=anything
+        ${id}=    Capture Response    Consult distributor    ${response}
+        Assert    ${id}    Status
+        ...    Should Be Equal As Integers    ${response.status_code}    200
+        ```
+
+        Returns `request-1`, `request-2`, etc. IDs are valid only within the current
+        case. Raises an error for an invalid response. See [Assert] for assertions.
+        """
+        case = self._current()
+        if not isinstance(response, Response) or response.request is None:
+            raise TypeError("response must be a requests.Response with a prepared request.")
+        request = response.request
+        request_headers = self.redactor.headers(request.headers)
+        response_headers = self.redactor.headers(response.headers)
+        request_type = request.headers.get("Content-Type", "")
+        if "multipart/" in request_type:
+            request_body: Any = "[Multipart body omitted]"
+        else:
+            request_body = self.redactor.body(request.body, request_type)
+        response_type = response.headers.get("Content-Type", "").lower()
+        if any(x in response_type for x in ("json", "text/", "xml", "javascript")):
+            response_body = self.redactor.body(response.text, response_type)
+        else:
+            response_body = f"[Binary response: {len(response.content)} bytes]"
+        request_id = f"request-{len(case.exchanges) + 1}"
+        case.exchanges.append(
+            Exchange(
+                id=request_id,
+                name=name,
+                method=request.method or "",
+                url=self.redactor.url(request.url or ""),
+                status_code=response.status_code,
+                duration_ms=round(response.elapsed.total_seconds() * 1000, 2),
+                request_headers=request_headers,
+                response_headers=response_headers,
+                request_body=request_body,
+                response_body=response_body,
+            )
+        )
+        return request_id
+
+    @keyword("Assert")
+    def assert_that(self, request_id: str, label: str, assertion_keyword: str, *args: Any) -> Any:
+        """Run an assertion keyword, record its result, and propagate normal failures.
+
+        Associates the validation with `request_id`, not an implicit last request.
+        Supports Robot BuiltIn assertions and your own user keywords. Positional
+        arguments after `assertion_keyword` are forwarded unchanged.
+
+        ```robotframework
+        Assert    ${id}    Distributor type
+        ...    Should Be Equal As Strings    ${body}[tipoDistribuidor]    AGENTE
+        ```
+
+        Returns the assertion's return value on success. Re-raises its failure on
+        error, preserving Robot's FAIL status. Use `robot:continue-on-failure` on a
+        business validation group when independent checks should all run.
+
+        Standard equality assertions show Expected/Actual. Non-empty checks show
+        `non-empty value`; other custom keywords show arguments and the error message.
+        `Campo Debe Tener Contenido` is also recognized as a non-empty assertion.
+        Unexecuted checks are not counted. Unknown request IDs fail before execution.
+        """
+        case = self._current()
+        exchange = next((x for x in case.exchanges if x.id == request_id), None)
+        if exchange is None:
+            raise ValueError(f"Unknown request ID in current case: {request_id}")
+        normalized = assertion_keyword.rsplit(".", 1)[-1].replace(" ", "").replace("_", "").lower()
+        actual = args[0] if args else None
+        expected = None
+        if normalized.startswith("shouldbeequal") and len(args) > 1:
+            expected = args[1]
+        elif normalized in {"shouldnotbeempty", "campodebetenercontenido"}:
+            expected = "non-empty value"
+        validation = Validation(
+            label=label,
+            keyword=assertion_keyword,
+            status="PASS",
+            actual=self.redactor.clean(actual),
+            expected=self.redactor.clean(expected),
+            arguments=self.redactor.clean(args),
+        )
+        exchange.validations.append(validation)
+        self._checking += 1
+        try:
+            return BuiltIn().run_keyword(assertion_keyword, *args)
+        except Exception as error:
+            validation.status = "FAIL"
+            validation.error = self.redactor.text(str(error))
+            raise
+        finally:
+            self._checking -= 1
+
+    @keyword("Capture HTTP Exchange", tags=["deprecated"])
+    def capture_http_exchange(self, name: str, response: Response) -> str:
+        """Compatibility alias for [Capture Response]."""
+        return self.capture_response(name, response)
+
+    @keyword("Check", tags=["deprecated"])
+    def check(self, request_id: str, label: str, assertion_keyword: str, *args: Any) -> Any:
+        """Compatibility alias for [Assert]."""
+        return self.assert_that(request_id, label, assertion_keyword, *args)

request_reporter/models.py

@@ -0,0 +1,50 @@
+"""Serializable report records, independent of Robot execution objects."""
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class Validation:
+    label: str
+    keyword: str
+    status: str
+    actual: Any = None
+    expected: Any = None
+    arguments: list[Any] = field(default_factory=list)
+    error: str = ""
+
+
+@dataclass
+class Exchange:
+    id: str
+    name: str
+    method: str
+    url: str
+    status_code: int
+    duration_ms: float
+    request_headers: dict[str, str]
+    response_headers: dict[str, str]
+    request_body: Any
+    response_body: Any
+    validations: list[Validation] = field(default_factory=list)
+
+
+@dataclass
+class ExecutionError:
+    keyword: str
+    message: str
+
+
+@dataclass
+class Case:
+    name: str
+    source: str
+    test_id: str
+    started: str
+    status: str = "RUNNING"
+    duration_ms: float = 0
+    message: str = ""
+    metadata: dict[str, Any] = field(default_factory=dict)
+    exchanges: list[Exchange] = field(default_factory=list)
+    execution_errors: list[ExecutionError] = field(default_factory=list)

request_reporter/redaction.py

@@ -0,0 +1,91 @@
+"""Redact configured fields before data reaches the template."""
+
+import json
+from typing import Any
+from urllib.parse import parse_qsl, urlencode, urlsplit, urlunsplit
+
+MASK = "[REDACTED]"
+
+
+class Redactor:
+    def __init__(self, headers: str, fields: str) -> None:
+        self.header_names = {x.strip().lower() for x in headers.split(",") if x.strip()}
+        self.field_names = {x.strip().lower() for x in fields.split(",") if x.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 item in value.values():
+                self.remember(item)
+        elif isinstance(value, list):
+            for item in value:
+                self.remember(item)
+
+    def text(self, value: str) -> str:
+        for secret in sorted(self.secrets, key=len, reverse=True):
+            value = value.replace(secret, MASK)
+        return value
+
+    def clean(self, value: Any) -> Any:
+        if isinstance(value, dict):
+            result = {}
+            for key, item in value.items():
+                if str(key).lower() in self.field_names:
+                    self.remember(item)
+                    result[str(key)] = MASK
+                else:
+                    result[str(key)] = self.clean(item)
+            return result
+        if isinstance(value, (list, tuple)):
+            return [self.clean(item) for item in value]
+        if isinstance(value, str):
+            return self.text(value)
+        if value is None or isinstance(value, (bool, int, float)):
+            return value
+        return self.text(str(value))
+
+    def headers(self, values: Any) -> dict[str, str]:
+        result = {}
+        for key, value in values.items():
+            if key.lower() in self.header_names:
+                self.remember(value)
+                result[key] = MASK
+            else:
+                result[key] = self.text(str(value))
+        return result
+
+    def url(self, value: str) -> str:
+        parts = urlsplit(value)
+        pairs = []
+        for key, item in parse_qsl(parts.query, keep_blank_values=True):
+            if key.lower() in self.field_names:
+                self.remember(item)
+                item = MASK
+            pairs.append((key, item))
+        # URL userinfo can contain credentials even when no header exists.
+        netloc = parts.netloc
+        if "@" in netloc:
+            credentials, host = netloc.rsplit("@", 1)
+            self.remember(credentials)
+            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 isinstance(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:
+            return self.clean(dict(parse_qsl(value, keep_blank_values=True)))
+        try:
+            return self.clean(json.loads(value))
+        except (ValueError, TypeError):
+            return self.text(value)

request_reporter/render.py

@@ -0,0 +1,29 @@
+"""Render standalone HTML, with a stable JSON payload and no external assets."""
+
+import re
+from dataclasses import asdict
+from importlib.resources import files
+from pathlib import Path
+
+from jinja2 import Environment, select_autoescape
+
+from .models import Case
+from .redaction import Redactor
+
+
+def write_report(case: Case, directory: Path, redactor: Redactor) -> Path:
+    directory.mkdir(parents=True, exist_ok=True)
+    stem = re.sub(r"[^\w.-]+", "_", case.name, flags=re.UNICODE).strip("._")[:130] or "case"
+    target = directory / f"{stem}.html"
+    counter = 2
+    while target.exists():
+        target = directory / f"{stem}_{counter}.html"
+        counter += 1
+    environment = Environment(autoescape=select_autoescape(["html"]))
+    template = environment.from_string(
+        files("request_reporter").joinpath("templates/report.html").read_text(encoding="utf-8")
+    )
+    # Final cleaning also removes secrets learned in subsequent requests.
+    payload = redactor.clean(asdict(case))
+    target.write_text(template.render(case=payload), encoding="utf-8")
+    return target

request_reporter/templates/report.html

@@ -0,0 +1,155 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1">
+<meta name="referrer" content="no-referrer">
+<title>{{ case.name }} — Test report</title>
+<style>
+ :root{color-scheme:light;--bg:#f5f7fb;--panel:#fff;--text:#1c293c;--muted:#52627a;--line:#dce3ef;--accent:#344bc0;--soft:#edf0ff;--pass:#146c38;--pass-bg:#e7f5eb;--fail:#b42332;--fail-bg:#ffeaec;--skip:#805b00;--skip-bg:#fff2c2}
+:root[data-theme=dark]{color-scheme:dark;--bg:#121923;--panel:#1d2736;--text:#eff3fa;--muted:#a8b8cd;--line:#354359;--accent:#a6b6ff;--soft:#2a3653;--pass:#97e4af;--pass-bg:#193d2b;--fail:#ff9eaa;--fail-bg:#4a2530;--skip:#f3d16e;--skip-bg:#423819}
+*{box-sizing:border-box}body{margin:0;background:var(--bg);color:var(--text);font:14px/1.55 system-ui,sans-serif}main{max-width:1100px;margin:auto;padding:24px}h1{font-size:24px;margin:0 0 6px}h2{font-size:17px;margin:0 0 12px}h3{font-size:14px;margin:0}button{font:inherit;min-height:42px;border:1px solid var(--line);border-radius:8px;padding:8px 12px;background:var(--panel);color:var(--text);cursor:pointer}button:hover{background:var(--soft)}button:focus-visible{outline:2px solid var(--accent);outline-offset:3px}button[aria-selected=true],button[aria-pressed=true]{background:var(--soft);border-color:var(--accent);color:var(--accent)}.small{color:var(--muted);font-size:12px}.row{display:flex;gap:10px;align-items:center;flex-wrap:wrap}.badge{background:var(--panel);padding:3px 8px;border-radius:5px;font-size:12px;font-weight:650}.pass{color:var(--pass)}.fail{color:var(--fail)}.skip{color:var(--skip)}.badge.pass{background:var(--pass-bg)}.badge.fail{background:var(--fail-bg)}.badge.skip{background:var(--skip-bg)}.stat.pass-stat{border-top:3px solid var(--pass)}.stat.fail-stat{border-top:3px solid var(--fail)}.case-message.skip{border-color:var(--skip);background:var(--skip-bg)}.requests small.pass{color:var(--pass)}.requests small.fail{color:var(--fail)}.requests button:has(.fail){border-left:3px solid var(--fail)}.requests button:has(.pass){border-left:3px solid var(--pass)}.theme-control{margin-left:auto}.stats{display:grid;grid-template-columns:repeat(4,1fr);gap:12px;margin:20px 0}.stat{padding:14px;background:var(--panel);border:1px solid var(--line);border-radius:10px}.stat strong{display:block;font-size:24px}.meta{display:flex;gap:8px 20px;flex-wrap:wrap;margin:12px 0;overflow-wrap:anywhere}.error{background:var(--panel);border-left:3px solid var(--fail);padding:12px;margin:14px 0;white-space:pre-wrap;overflow-wrap:anywhere}.layout{display:grid;grid-template-columns:220px minmax(0,1fr);gap:16px}.requests{display:flex;flex-direction:column;gap:8px}.requests button{text-align:left}.requests small{display:block;color:var(--muted)}.detail{min-width:0;background:var(--panel);border:1px solid var(--line);border-radius:10px;padding:20px}.url{background:var(--bg);padding:12px;border-radius:7px;overflow-wrap:anywhere}.url code{font-size:12px}.tabs{display:flex;gap:8px;flex-wrap:wrap;margin:16px 0}.code{background:var(--bg);padding:14px;border-radius:7px;white-space:pre-wrap;overflow-wrap:anywhere;font:13px/1.65 ui-monospace,monospace;margin:0}.key{color:var(--accent)}.string{color:var(--pass)}table{border-collapse:collapse;table-layout:fixed;width:100%;font-size:13px}th,td{padding:10px 5px;border-bottom:1px solid var(--line);text-align:left;overflow-wrap:anywhere;vertical-align:top}th{color:var(--muted);font-weight:500}.validation{padding:12px 0;border-bottom:1px solid var(--line)}.validation p{margin:5px 0 0 20px;white-space:pre-wrap;overflow-wrap:anywhere}textarea{width:100%;min-height:100px;font:inherit;background:var(--bg);color:var(--text)}footer{margin-top:20px}.empty{padding:16px;color:var(--muted)}@media(max-width:700px){main{padding:14px}.layout{grid-template-columns:1fr}.requests{flex-direction:row;flex-wrap:wrap}.requests button{flex:1;min-width:145px}.stats{grid-template-columns:repeat(2,1fr)}.detail{padding:14px}h1{font-size:20px}}
+
+[hidden]{display:none!important}.sections{display:flex;gap:8px;margin:20px 0}.sections button{font-weight:650}.summary-panel,.failure-panel{background:var(--panel);border:1px solid var(--line);border-radius:10px;padding:20px}.summary-panel p{margin:8px 0}.section-title{margin-top:20px}.method{font-weight:750;letter-spacing:.03em}.method-get{color:var(--pass);background:var(--pass-bg)}.method-post{color:var(--skip);background:var(--skip-bg)}.method-put,.method-head,.http-info{color:var(--accent);background:var(--soft)}.method-patch,.method-options{color:var(--skip);background:var(--skip-bg)}.method-delete{color:var(--fail);background:var(--fail-bg)}.http-success{color:var(--pass);background:var(--pass-bg)}.http-redirect{color:var(--skip);background:var(--skip-bg)}.http-error{color:var(--fail);background:var(--fail-bg)}.failure-table{overflow:auto}.failure-table table{min-width:540px}.failure-table button{border:0;padding:0;min-height:32px;background:none;color:var(--accent);text-align:left;text-decoration:underline}.technical{margin-top:18px}.technical summary{cursor:pointer;color:var(--muted)}.notice{padding:12px 16px;background:var(--fail-bg);border-left:3px solid var(--fail);border-radius:6px;margin-top:16px}.validation:focus{outline:2px solid var(--accent);outline-offset:5px}.summary-actions{margin-top:16px}.requests button .badge{display:inline-block}.stats{margin-top:0}
+.request-line{display:flex;align-items:center;gap:12px}.request-line code{flex:1;min-width:0;font-size:13px}.request-result{display:flex;align-items:center;gap:12px;margin-top:12px;padding-top:12px;border-top:1px solid var(--line)}.copy-url{flex-shrink:0;display:grid;place-items:center}.url-status{margin-top:8px}.params-heading{display:flex;align-items:center;gap:10px;margin-bottom:12px}@media(max-width:700px){.request-line{flex-wrap:wrap}.request-line code{flex-basis:70%}}
+</style>
+<script>
+(()=>{let theme=matchMedia('(prefers-color-scheme: dark)').matches?'dark':'light';try{const stored=localStorage.getItem('api-case-reporter-theme');if(stored==='light'||stored==='dark')theme=stored;}catch(error){}document.documentElement.dataset.theme=theme;})();
+</script>
+</head>
+<body>
+<main>
+<header><div class="row"><h1>{{ case.name }}</h1><span class="badge {{ case.status|lower }}">{{ case.status }}</span><button type="button" id="theme-toggle" class="theme-control" aria-label="Switch color theme">Light / Dark</button></div><div class="small"><time id="started" datetime="{{ case.started }}">{{ case.started }}</time></div></header>
+<nav class="sections" aria-label="Report sections"><button data-section="summary" aria-pressed="true">Summary</button><button data-section="requests" aria-pressed="false">Requests</button><button data-section="failures" aria-pressed="false">Failures <span id="failure-count"></span></button></nav>
+<section id="section-summary" aria-label="Summary">
+<div class="stats">
+<div class="stat"><span class="small">HTTP requests</span><strong id="request-count"></strong></div>
+<div class="stat"><span class="small">Total assertions</span><strong id="assertion-count"></strong></div>
+<div class="stat pass-stat"><span class="small">Passed assertions</span><strong class="pass" id="passed"></strong></div>
+<div class="stat fail-stat"><span class="small">Failed assertions</span><strong class="fail" id="failed"></strong></div>
+</div>
+<div class="summary-panel"><h2>Test case information</h2><p><span class="small">Test case duration</span> · <strong>{{ '%.2f'|format(case.duration_ms / 1000) }} s</strong></p><p class="small">Each request includes its HTTP response time. HTTP status and assertion results are independent.</p>
+{% if case.metadata %}<div class="meta" aria-label="Test case metadata">{% for key,value in case.metadata.items() %}<span><span class="small">{{ key }}:</span> {{ value }}</span>{% endfor %}</div>{% endif %}
+{% if case.status == 'SKIP' and case.message %}<div class="error case-message skip">{{ case.message }}</div>{% endif %}
+<div id="failure-notice"></div><div class="row summary-actions"><button data-section="requests">View requests</button></div></div>
+</section>
+<section id="section-requests" aria-label="Requests" hidden><div class="layout"><nav class="requests" id="requests" aria-label="Test case requests"></nav><section class="detail" aria-label="Selected request"><div id="url" class="url"></div><div class="tabs" role="tablist" aria-label="Request details">
+{% for name in ['Response','Request','Params','Headers','Assertions'] %}<button type="button" role="tab" id="tab-{{ name|lower }}" data-tab="{{ name|lower }}" tabindex="{{ '0' if loop.first else '-1' }}" aria-selected="{{ 'true' if loop.first else 'false' }}" aria-controls="content">{{ name }}</button>{% endfor %}
+</div><div id="content" role="tabpanel" aria-labelledby="tab-response" tabindex="0"></div></section></div></section>
+<section id="section-failures" class="failure-panel" aria-label="Failures" hidden><h2>Failed assertions</h2><div id="failure-table" class="failure-table"></div><h2 class="section-title">Execution errors</h2><div id="execution-errors"></div>{% if case.message %}<details class="technical"><summary>Original Robot Framework message</summary><pre class="code">{{ case.message }}</pre></details>{% endif %}</section>
+<footer class="small">One test case · {{ case.exchanges|length }} HTTP exchanges · Sensitive values are masked according to reporter configuration.</footer>
+<noscript><p>This interactive report requires JavaScript.</p><pre class="code">{{ case.message }}</pre></noscript>
+</main>
+<script type="application/json" id="case-data">{{ case|tojson }}</script>
+<script>
+(()=>{
+'use strict';
+const data=JSON.parse(document.getElementById('case-data').textContent);
+const q=id=>document.getElementById(id);
+const esc=v=>String(v??'').replace(/[&<>"']/g,c=>({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'}[c]));
+const format=v=>typeof v==='string'?v:JSON.stringify(v,null,2);
+const body=v=>v===null?'<div class="code">No body</div>':'<pre class="code">'+esc(format(v)).replace(/(&quot;[^\n]*?&quot;)(\s*:)?/g,(m,a,b)=>'<span class="'+(b?'key':'string')+'">'+a+'</span>'+(b||''))+'</pre>';
+const copyIcon='<svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" aria-hidden="true"><rect x="8" y="8" width="12" height="12" rx="2"/><path d="M16 8V4a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v10a2 2 0 0 0 2 2h4"/></svg>';
+let selected=0,tab='response',view='table';
+function updateThemeButton(){
+ const dark=document.documentElement.dataset.theme==='dark';
+ q('theme-toggle').textContent=dark?'☀ Light mode':'☾ Dark mode';
+ q('theme-toggle').setAttribute('aria-label',dark?'Switch to light mode':'Switch to dark mode');
+ q('theme-toggle').setAttribute('aria-pressed',String(dark));
+}
+q('theme-toggle').addEventListener('click',()=>{
+ const theme=document.documentElement.dataset.theme==='dark'?'light':'dark';
+ document.documentElement.dataset.theme=theme;
+ try{localStorage.setItem('api-case-reporter-theme',theme);}catch(error){}
+ updateThemeButton();
+});
+updateThemeButton();
+const started=new Date(data.started);
+if(!Number.isNaN(started.getTime()))q('started').textContent=new Intl.DateTimeFormat('en',{dateStyle:'medium',timeStyle:'long',timeZone:'UTC'}).format(started);
+const checks=data.exchanges.flatMap(r=>r.validations);
+const failed=data.exchanges.flatMap((r,ri)=>r.validations.map((c,ci)=>({r,c,ri,ci})).filter(x=>x.c.status==='FAIL'));
+const errors=data.execution_errors||[];
+q('request-count').textContent=data.exchanges.length;
+q('assertion-count').textContent=checks.length;
+q('passed').textContent=checks.filter(c=>c.status==='PASS').length;
+q('failed').textContent=failed.length;
+q('failure-count').textContent='('+ (failed.length+errors.length) +')';
+if(failed.length||errors.length||data.status==='FAIL'){
+ q('failure-notice').innerHTML='<div class="notice">'+failed.length+' failed assertions · '+errors.length+' execution errors <button data-section="failures">View failures</button></div>';
+}
+q('failure-table').innerHTML=failed.length?'<table><thead><tr><th>Request / Assertion</th><th>Expected</th><th>Actual</th></tr></thead><tbody>'+failed.map(({r,c,ri,ci})=>'<tr><td><span class="small">'+esc(r.name)+'</span><br><button data-failure-request="'+ri+'" data-assertion="'+ci+'">'+esc(c.label)+'</button></td><td>'+esc(c.expected===null?'See assertion details':format(c.expected))+'</td><td>'+esc(format(c.actual))+'</td></tr>').join('')+'</tbody></table>':'<p class="small">No failed assertions recorded.</p>';
+q('execution-errors').innerHTML=errors.length?errors.map(e=>'<article class="error"><strong>'+esc(e.keyword)+'</strong><div>'+esc(e.message)+'</div></article>').join(''):'<p class="small">No unhandled keyword errors recorded. For failures outside keyword execution, see the original Robot message.</p>';
+function showSection(name){
+ ['summary','requests','failures'].forEach(x=>q('section-'+x).hidden=x!==name);
+ document.querySelectorAll('.sections [data-section]').forEach(b=>b.setAttribute('aria-pressed',String(b.dataset.section===name)));
+}
+function methodBadge(method){
+ const known=['GET','POST','PUT','PATCH','DELETE','HEAD','OPTIONS'];
+ return '<span class="badge method '+(known.includes(method)?'method-'+method.toLowerCase():'')+'">'+esc(method)+'</span>';
+}
+function statusBadge(status){
+ const kind=status>=100&&status<200?'info':status>=200&&status<300?'success':status>=300&&status<400?'redirect':status>=400&&status<600?'error':'';
+ return '<span class="badge '+(kind?'http-'+kind:'')+'">HTTP '+esc(status)+'</span>';
+}
+function queryParams(url){try{return [...new URL(url).searchParams].map(([name,value])=>({name,value}));}catch(error){return [];}}
+function render(){
+ q('requests').innerHTML=data.exchanges.map((r,i)=>{
+  const failed=r.validations.some(c=>c.status==='FAIL');
+  const state=r.validations.length?(failed?'Assertions FAIL':'Assertions PASS'):'No assertions';
+  return '<button type="button" data-request="'+i+'" aria-pressed="'+(i===selected)+'">'+(i+1)+'. '+esc(r.name)+'<small>'+methodBadge(r.method)+' '+statusBadge(r.status_code)+' · '+r.duration_ms+' ms</small><small class="'+(r.validations.length?(failed?'fail':'pass'):'')+'">'+state+'</small></button>';
+ }).join('');
+ document.querySelectorAll('[data-tab]').forEach(b=>{
+  b.setAttribute('aria-selected',String(b.dataset.tab===tab));
+  b.tabIndex=b.dataset.tab===tab?0:-1;
+ });
+ q('content').setAttribute('aria-labelledby','tab-'+tab);
+ if(!data.exchanges.length){
+  q('url').textContent='No completed HTTP exchanges';
+  q('content').innerHTML='<div class="empty">No response was captured for this case. See Summary and Failures for its final outcome.</div>';return;
+ }
+ const r=data.exchanges[selected];
+ q('url').innerHTML='<div class="request-line">'+methodBadge(r.method)+'<code>'+esc(r.url)+'</code><button class="copy-url" data-copy="url" aria-label="Copy request URL" title="Copy request URL">'+copyIcon+'</button></div><div class="request-result"><span class="small">Response</span>'+statusBadge(r.status_code)+'<span class="small">'+r.duration_ms+' ms</span></div><div id="url-copy-status" class="small url-status" role="status"></div>';
+ if(tab==='params'){const params=queryParams(r.url);q('content').innerHTML='<div class="params-heading"><h2>Query parameters</h2><button data-copy="params" aria-label="Copy query parameters as JSON">'+copyIcon+'</button></div><p class="small">From the final request URL. Repeated names and empty values are preserved.</p>'+(params.length?'<table><thead><tr><th>Name</th><th>Value</th></tr></thead><tbody>'+params.map(p=>'<tr><td>'+esc(p.name)+'</td><td>'+esc(p.value)+'</td></tr>').join('')+'</tbody></table>':'<div class="empty">No query parameters</div>')+'<div id="copy-status" role="status" class="small"></div>';}
+ if(tab==='response'||tab==='request')q('content').innerHTML='<h2>'+(tab==='response'?'Response':'Request')+' body</h2>'+body(r[tab+'_body']);
+ if(tab==='assertions')q('content').innerHTML=r.validations.length?r.validations.map((c,i)=>'<article class="validation" id="assertion-'+i+'" tabindex="-1"><strong class="'+(c.status==='PASS'?'pass':'fail')+'">'+(c.status==='PASS'?'✓':'×')+' '+c.status+' · '+esc(c.label)+'</strong><p class="small">Keyword: '+esc(c.keyword)+(c.expected!==null?'<br>Expected: '+esc(format(c.expected)):'')+'<br>Actual: '+esc(format(c.actual))+(c.expected===null?'<br>Arguments: '+esc(format(c.arguments)):'')+'</p>'+(c.error?'<div class="error">'+esc(c.error)+'</div>':'')+'</article>').join(''):'<div class="empty">No assertions recorded for this request.</div>';
+ if(tab==='headers')q('content').innerHTML='<div class="row"><button data-view="table" aria-pressed="'+(view==='table')+'">Table</button><button data-view="raw" aria-pressed="'+(view==='raw')+'">JSON</button></div>'+['request','response'].map(side=>{
+  const entries=Object.entries(r[side+'_headers']);
+  return '<div class="row" style="margin:16px 0 8px"><h3>'+(side==='request'?'Request':'Response')+' headers</h3><button data-copy="'+side+'" aria-label="Copy '+side+' headers as JSON" title="Copy headers as JSON">'+copyIcon+'</button></div>'+(view==='raw'?body(r[side+'_headers']):'<table><thead><tr><th>Name</th><th>Value</th></tr></thead><tbody>'+entries.map(([k,v])=>'<tr><td>'+esc(k)+'</td><td>'+esc(v)+'</td></tr>').join('')+'</tbody></table>');
+ }).join('')+'<div id="copy-status" role="status" class="small" style="margin-top:10px"></div>';
+}
+document.addEventListener('click',async e=>{
+ const b=e.target.closest('button');if(!b)return;
+ if(b.dataset.section){showSection(b.dataset.section);}
+ else if(b.dataset.failureRequest!==undefined){
+  selected=Number(b.dataset.failureRequest);tab='assertions';showSection('requests');render();
+  const assertion=q('assertion-'+b.dataset.assertion);assertion.scrollIntoView({block:'center'});assertion.focus({preventScroll:true});
+ }
+ else if(b.dataset.request!==undefined){selected=Number(b.dataset.request);render();}
+ else if(b.dataset.tab){tab=b.dataset.tab;render();}
+ else if(b.dataset.view){view=b.dataset.view;render();}
+ else if(b.dataset.copy){
+  const r=data.exchanges[selected];
+  const type=b.dataset.copy;
+  const text=type==='url'?r.url:JSON.stringify(type==='params'?queryParams(r.url):r[type+'_headers'],null,2);
+  const status=type==='url'?q('url-copy-status'):q('copy-status');
+  try{
+   if(!navigator.clipboard)throw Error('Clipboard unavailable');
+   await navigator.clipboard.writeText(text);
+   if(status)status.textContent=type==='url'?'Request URL copied':type==='params'?'Query parameters copied as JSON':'Headers copied as JSON';
+  }catch(error){
+   if(status){
+    status.innerHTML='<label>Copy manually<textarea readonly>'+esc(text)+'</textarea></label>';
+    const field=status.querySelector('textarea');field.focus();field.select();
+   }
+  }
+ }
+});
+document.addEventListener('keydown',e=>{
+ const b=e.target.closest('[data-tab]');if(!b||!['ArrowLeft','ArrowRight','Home','End'].includes(e.key))return;
+ e.preventDefault();const tabs=[...document.querySelectorAll('[data-tab]')];let i=tabs.indexOf(b);
+ i=e.key==='Home'?0:e.key==='End'?tabs.length-1:(i+(e.key==='ArrowRight'?1:-1)+tabs.length)%tabs.length;
+ tab=tabs[i].dataset.tab;render();tabs[i].focus();
+});
+render();
+})();
+</script>
+</body></html>

robotframework_request_reporter-0.3.0.dist-info/METADATA

@@ -0,0 +1,103 @@
+Metadata-Version: 2.4
+Name: robotframework-request-reporter
+Version: 0.3.0
+Summary: Standalone HTML API evidence reports for each Robot Framework test case.
+Keywords: robotframework,api,report,requests
+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: jinja2 (>=3.1.6,<4)
+Requires-Dist: requests (>=2.32,<3)
+Requires-Dist: robotframework (>=7.5,<8)
+Project-URL: Documentation, https://angel-valdezzz.github.io/robotframework-request-reporter/
+Project-URL: Repository, https://github.com/angel-valdezzz/robotframework-request-reporter
+Description-Content-Type: text/markdown
+
+# Robot Framework Robot Framework Request Reporter
+
+One standalone HTML evidence report per Robot Framework test case. Supports
+RequestsLibrary responses, multiple HTTP requests, business assertions, metadata,
+JSON formatting, request/response headers, Table/JSON and Copy.
+
+Version 0.3.0 targets Python 3.12+ and Robot Framework 7.5+. No pytest adapter.
+
+## Install
+
+```bash
+pip install robotframework-request-reporter==0.3.0
+pip install robotframework-requests
+```
+
+RequestsLibrary is installed separately. The WHL can also be downloaded from PyPI.
+
+[Manual de usuario](https://angel-valdezzz.github.io/robotframework-request-reporter/) ·
+[Referencia de keywords](https://angel-valdezzz.github.io/robotframework-request-reporter/keywords/) ·
+[Ejemplo en vivo](https://angel-valdezzz.github.io/robotframework-request-reporter/examples/report.html) ·
+[Paquete en PyPI](https://pypi.org/project/robotframework-request-reporter/) ·
+[Ejemplo ejecutable](https://github.com/angel-valdezzz/robotframework-api-testing/tree/main)
+
+```robotframework
+*** Settings ***
+Library    RequestsLibrary
+Library    RequestReporter    
+
+*** Test Cases ***
+Example
+    ${response}=    GET    ${BASE_URL}/health    expected_status=anything
+    ${id}=    Capture Response    Health    ${response}
+    Assert    ${id}    HTTP status
+    ...    Should Be Equal As Integers    ${response.status_code}    200
+```
+
+The library registers its listener automatically and writes into Robot's
+`OUTPUT DIR/cases`. No separate listener option or generation keyword is needed.
+Each report contains only one test case and works offline.
+
+## Development
+
+```bash
+poetry install
+poetry run ruff check .
+poetry run ruff format --check .
+poetry run mypy src
+poetry run python scripts/verify.py
+poetry build
+poetry run python scripts/build_site.py
+```
+
+Acceptance tests use Robot Framework and a loopback HTTP fixture. Some cases
+intentionally fail; scripts/verify.py checks their exact results instead of
+ignoring the Robot exit code. No live credentials or external endpoints are used.
+
+## Scope and limitations
+
+- Metadata is optional. Name, status and duration come from Robot.
+- Only English UI is currently supported; business labels may use any language.
+- Configured JSON/form/query fields and headers are redacted in this reporter's HTML.
+  Robot and RequestsLibrary logs have their own independent logging behavior.
+- Binary responses and multipart uploads are summarized, not embedded.
+- HTTP transport errors without a Response appear in the final case error, with no
+  fabricated request. Keys missing before Assert executes appear as Robot errors.
+- Pabot processes are supported with distinct output directories per worker. Sharing
+  one physical report directory across concurrent writers is not supported in 0.2.
+- Light/Dark control follows the system initially and remembers your choice when storage is available.
+- PASS, FAIL and SKIP use green, red and amber with distinct shades in both themes.
+
+See the documentation for release workflow and Trusted Publisher configuration.
+
+Headers can be viewed as formatted JSON and copied with the copy icon. The clipboard
+and manual fallback both contain indented JSON with configured secrets masked.
+
+The report opens on Summary with request/assertion counters, a readable UTC date
+and case duration. Failures links each failed assertion to its request. Execution
+errors outside Assert are recorded automatically; handled keyword failures are excluded.
+HTTP status colors describe the response class independently of PASS/FAIL assertions.
+
+Changes are integrated into main through pull requests with required CI checks.
+
+## Migration from APICaseReporter
+
+Install `robotframework-request-reporter` and import `RequestReporter`. Do not install both distributions: the new wheel includes the legacy import. `Capture HTTP Exchange` and `Check` remain compatibility aliases; new suites use `Capture Response` and `Assert`. These keywords record an existing response and execute an assertion respectively; capturing does not send another request.
+

robotframework_request_reporter-0.3.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+APICaseReporter/__init__.py,sha256=9j--TXN9v5zcnzXSdnm3GdC9thODltZpg4PijSGDlXA,203
+RequestReporter.py,sha256=zuFlwQ16LW9RuNzCW9dpkcoeJy-873ADqt_xWLCfGfo,162
+request_reporter/__init__.py,sha256=ZSE4pJD1Mhj9EULBmoZKtf6HMJN9sGqoNm6-1kM0zKQ,12264
+request_reporter/models.py,sha256=9ZuYjfIwEfPUyEmngYNiPdZzBPl5mmPFy6j0_kbMCwQ,1079
+request_reporter/redaction.py,sha256=_Vk51Ob7K7uLEQ9DI08goa5wCOCFhNI1qXFGAvsf4qY,3387
+request_reporter/render.py,sha256=QZVX0eb5ucQYZNQl5UkYG5-IbCfK_itN3XHEWf-w0l0,1090
+request_reporter/templates/report.html,sha256=Ni3qUInZfe8r5xQ2S1shu6RvlszCx-SJhdihoXUB7TI,19306
+robotframework_request_reporter-0.3.0.dist-info/METADATA,sha256=KqJtNv8waS_s5oD4gRM9Kpc_CwsdkQF7O9fs835bn-M,4801
+robotframework_request_reporter-0.3.0.dist-info/WHEEL,sha256=L-WvLdSBvJWHXv5zrQxDvNRnIgoBzLUpcbuiw19KCuQ,88
+robotframework_request_reporter-0.3.0.dist-info/RECORD,,

robotframework_request_reporter-0.3.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.5.0
+Root-Is-Purelib: true
+Tag: py3-none-any