reporting-labs 0.1.0__py3-none-any.whl

reporting_labs/__init__.py

@@ -0,0 +1,163 @@
+"""reportingLabs for Python: one HTML report for pytest, Playwright, Selenium and Robot Framework.
+
+Helpers to call from a test:
+
+    from reporting_labs import meta, log, test_data, step, api, attach
+
+    meta(priority="P1", owner="asha", feature="checkout")
+    log("cart total before coupons: 99.00")
+    test_data({"username": "demo", "password": "x"}, "Login")
+    with step("Apply coupon"):
+        ...
+    api(method="GET", url="/v1/orders", status=200, duration=120, response_body=body)
+    attach("screenshot", png_bytes, "image/png")
+
+Secrets (password=..., Bearer ..., tokens) are masked in the report.
+"""
+from __future__ import annotations
+
+import functools
+import inspect
+import json
+from contextlib import contextmanager
+from typing import Any, Callable, Dict, Iterator, Optional, Union
+
+from ._version import __version__
+from .core import context
+from .core.model import ErrorInfo, now_ms
+
+__all__ = ["meta", "log", "test_data", "step", "api", "attach", "RobotListener", "__version__"]
+
+
+def __getattr__(name: str) -> Any:
+    # `robot --listener reporting_labs.RobotListener`: imported lazily so a pytest project never loads Robot code
+    if name == "RobotListener":
+        from .robot.listener import ReportingLabsListener
+        return ReportingLabsListener
+    raise AttributeError(name)
+
+
+def meta(**values: Any) -> None:
+    """Attach report metadata to the current test: priority, severity, owner, feature, epic, story, issue... or any key.
+    A value can be a list (one chip per value) or a dict (the fields of a multi-parameter link, see `links`)."""
+    a = context.current()
+    if a is None:
+        return
+    for k, v in values.items():
+        if v is not None:
+            a.meta[str(k).lower()] = v
+
+
+def log(message: Any, *rest: Any) -> None:
+    """Add a timestamped log line to the current test. Lines containing "error"/"fail" show red, "warn" amber."""
+    a = context.current()
+    if a is None:
+        return
+    parts = [str(message)] + [r if isinstance(r, str) else json.dumps(r, default=str) for r in rest]
+    a.log(" ".join(parts))
+
+
+def test_data(data: Any, name: str = "Test data") -> None:
+    """Attach the data this test uses: a dict (key/value block), a list of dicts (table) or a CSV string (table).
+    Sensitive keys are masked."""
+    a = context.current()
+    if a is not None:
+        a.test_data(data, name)
+
+
+def api(method: str, url: str, status: Optional[int] = None, duration: Optional[float] = None, name: Optional[str] = None,
+        request_headers: Optional[Dict[str, str]] = None, request_body: Any = None,
+        response_headers: Optional[Dict[str, str]] = None, response_body: Any = None) -> None:
+    """Record an API call by hand. requests and httpx calls are recorded automatically."""
+    a = context.current()
+    if a is None:
+        return
+    call: Dict[str, Any] = {"method": str(method).upper(), "url": str(url)}
+    if status is not None:
+        call["status"] = int(status)
+    if duration is not None:
+        call["duration"] = float(duration)
+    if name:
+        call["name"] = name
+    if request_headers:
+        call["requestHeaders"] = dict(request_headers)
+    if request_body is not None:
+        call["requestBody"] = request_body
+    if response_headers:
+        call["responseHeaders"] = dict(response_headers)
+    if response_body is not None:
+        call["responseBody"] = response_body
+    a.api_call(call)
+
+
+def attach(name: str, body: Union[bytes, str, None] = None, content_type: Optional[str] = None, path: Optional[str] = None) -> None:
+    """Attach a file or bytes to the current test: a screenshot, a downloaded PDF, a log. Images are shown inline."""
+    a = context.current()
+    if a is None:
+        return
+    if isinstance(body, str):
+        body = body.encode("utf-8")
+        content_type = content_type or "text/plain"
+    if content_type is None:
+        ext = (path or name).lower().rsplit(".", 1)[-1] if "." in (path or name) else ""
+        content_type = {"png": "image/png", "jpg": "image/jpeg", "jpeg": "image/jpeg", "webp": "image/webp", "gif": "image/gif", "webm": "video/webm",
+                        "mp4": "video/mp4", "txt": "text/plain", "log": "text/plain", "json": "application/json", "html": "text/html", "csv": "text/csv",
+                        "zip": "application/zip", "pdf": "application/pdf"}.get(ext, "application/octet-stream")
+    a.attach(name, body, content_type, path)
+
+
+test_data.__test__ = False   # pytest must not collect the helper when a test module imports it
+
+
+class _StepContext:
+    """`with step("title"):` and `@step("title")` on a function (sync or async)."""
+
+    def __init__(self, title: str, category: str = "test.step") -> None:
+        self.title, self.category = title, category
+        self._st = None
+        self._attempt = None
+
+    def __enter__(self) -> "_StepContext":
+        self._attempt = context.current()
+        if self._attempt is not None:
+            self._st = self._attempt.begin_step(self.title, self.category)
+        return self
+
+    def __exit__(self, et, ev, tb) -> bool:
+        if self._attempt is not None and self._st is not None:
+            self._attempt.end_step(self._st, f"{et.__name__}: {ev}" if et else None)
+        return False
+
+    async def __aenter__(self) -> "_StepContext":
+        return self.__enter__()
+
+    async def __aexit__(self, et, ev, tb) -> bool:
+        return self.__exit__(et, ev, tb)
+
+    def __call__(self, fn: Callable) -> Callable:
+        if inspect.iscoroutinefunction(fn):
+            @functools.wraps(fn)
+            async def aw(*args: Any, **kw: Any) -> Any:
+                async with _StepContext(self.title or fn.__name__, self.category):
+                    return await fn(*args, **kw)
+            return aw
+
+        @functools.wraps(fn)
+        def w(*args: Any, **kw: Any) -> Any:
+            with _StepContext(self.title or fn.__name__, self.category):
+                return fn(*args, **kw)
+        return w
+
+
+def step(title: Union[str, Callable, None] = None, category: str = "test.step") -> Any:
+    """A named step in the report. Use as a context manager or a decorator; steps nest.
+
+        with step("Log in as admin"):
+            page.fill("#user", "admin")
+
+        @step("Open the cart")
+        def open_cart(page): ...
+    """
+    if callable(title):
+        return _StepContext(title.__name__, category)(title)
+    return _StepContext(str(title or "step"), category)

reporting_labs/_version.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

reporting_labs/capture/http.py

@@ -0,0 +1,181 @@
+"""Records every requests / httpx call made while a test runs, into the current attempt's API list.
+
+Installed once per process by the pytest plugin and the Robot listener. Nothing is recorded outside a test.
+"""
+from __future__ import annotations
+
+import json
+import time
+from typing import Any, Dict, Optional
+
+from ..core import context
+
+_installed: Dict[str, Any] = {}
+_max_body = 64 * 1024
+
+
+def _headers(h: Any) -> Dict[str, str]:
+    try:
+        return {str(k): str(v) for k, v in dict(h).items()}
+    except Exception:
+        return {}
+
+
+def _body(raw: Any, content_type: str = "") -> Any:
+    if raw is None:
+        return None
+    if isinstance(raw, (dict, list)):
+        return raw
+    if isinstance(raw, (bytes, bytearray)):
+        if len(raw) > _max_body:
+            return f"<{len(raw)} bytes, first {_max_body} shown>\n" + bytes(raw[:_max_body]).decode("utf-8", "replace")
+        if "json" in content_type or raw[:1] in (b"{", b"["):
+            try:
+                return json.loads(raw.decode("utf-8"))
+            except Exception:
+                pass
+        if any(t in content_type for t in ("image/", "video/", "audio/", "octet-stream", "pdf", "zip")):
+            return f"<{len(raw)} bytes {content_type}>"
+        return raw.decode("utf-8", "replace")
+    if isinstance(raw, str):
+        if len(raw) > _max_body:
+            return raw[:_max_body] + f"… ({len(raw)} chars)"
+        if raw[:1] in "{[":
+            try:
+                return json.loads(raw)
+            except Exception:
+                pass
+        return raw
+    try:
+        return json.loads(json.dumps(raw, default=str))
+    except Exception:
+        return str(raw)
+
+
+def record(method: str, url: str, status: Optional[int], start: float, req_headers: Any, req_body: Any,
+           res_headers: Any = None, res_body: Any = None, error: Optional[str] = None) -> None:
+    a = context.current()
+    if a is None:
+        return
+    rh = _headers(req_headers)
+    call: Dict[str, Any] = {"method": str(method).upper(), "url": str(url), "duration": round((time.time() - start) * 1000, 1), "requestHeaders": rh}
+    if status is not None:
+        call["status"] = int(status)
+    if req_body is not None:
+        call["requestBody"] = _body(req_body, rh.get("Content-Type") or rh.get("content-type") or "")
+    if res_headers is not None:
+        sh = _headers(res_headers)
+        call["responseHeaders"] = sh
+        call["responseBody"] = _body(res_body, sh.get("Content-Type") or sh.get("content-type") or "")
+    if error:
+        call["responseBody"] = error
+    a.api_call(call)
+
+
+def install(max_body: int = 64 * 1024) -> None:
+    global _max_body
+    _max_body = max_body
+    _install_requests()
+    _install_httpx()
+
+
+def uninstall() -> None:
+    for name, (owner, attr, original) in list(_installed.items()):
+        setattr(owner, attr, original)
+        _installed.pop(name, None)
+
+
+def _install_requests() -> None:
+    if "requests" in _installed:
+        return
+    try:
+        import requests
+    except ImportError:
+        return
+    original = requests.Session.send
+
+    def send(self, request, **kwargs):  # type: ignore[no-untyped-def]
+        if context.current() is None:
+            return original(self, request, **kwargs)
+        start = time.time()
+        try:
+            resp = original(self, request, **kwargs)
+        except Exception as e:
+            record(request.method, request.url, None, start, request.headers, request.body, error=f"{type(e).__name__}: {e}")
+            raise
+        body: Any = None
+        try:
+            if not kwargs.get("stream"):
+                body = resp.content
+        except Exception:
+            body = None
+        record(request.method, request.url, resp.status_code, start, request.headers, request.body, resp.headers, body)
+        return resp
+
+    requests.Session.send = send  # type: ignore[assignment]
+    _installed["requests"] = (requests.Session, "send", original)
+
+
+def _install_httpx() -> None:
+    if "httpx" in _installed:
+        return
+    try:
+        import httpx
+    except ImportError:
+        return
+
+    def req_body(request: Any) -> Any:
+        try:
+            return request.content or None
+        except Exception:
+            return None
+
+    def res_body(resp: Any) -> Any:
+        try:
+            return resp.content if not resp.is_stream_consumed and hasattr(resp, "_content") else resp.content
+        except Exception:
+            return None
+
+    original = httpx.Client.send
+
+    def send(self, request, **kwargs):  # type: ignore[no-untyped-def]
+        if context.current() is None:
+            return original(self, request, **kwargs)
+        start = time.time()
+        try:
+            resp = original(self, request, **kwargs)
+        except Exception as e:
+            record(request.method, str(request.url), None, start, request.headers, req_body(request), error=f"{type(e).__name__}: {e}")
+            raise
+        try:
+            if not kwargs.get("stream"):
+                resp.read()
+        except Exception:
+            pass
+        record(request.method, str(request.url), resp.status_code, start, request.headers, req_body(request), resp.headers, res_body(resp) if not kwargs.get("stream") else None)
+        return resp
+
+    httpx.Client.send = send  # type: ignore[assignment]
+    _installed["httpx"] = (httpx.Client, "send", original)
+
+    aoriginal = httpx.AsyncClient.send
+
+    async def asend(self, request, **kwargs):  # type: ignore[no-untyped-def]
+        if context.current() is None:
+            return await aoriginal(self, request, **kwargs)
+        start = time.time()
+        try:
+            resp = await aoriginal(self, request, **kwargs)
+        except Exception as e:
+            record(request.method, str(request.url), None, start, request.headers, req_body(request), error=f"{type(e).__name__}: {e}")
+            raise
+        try:
+            if not kwargs.get("stream"):
+                await resp.aread()
+        except Exception:
+            pass
+        record(request.method, str(request.url), resp.status_code, start, request.headers, req_body(request), resp.headers, res_body(resp) if not kwargs.get("stream") else None)
+        return resp
+
+    httpx.AsyncClient.send = asend  # type: ignore[assignment]
+    _installed["httpx_async"] = (httpx.AsyncClient, "send", aoriginal)