tracereports 0.2.0__py3-none-any.whl

tracereports/network.py

@@ -0,0 +1,291 @@
+"""
+Captura de red (backend) con Playwright para TraceReports.
+
+Adaptado de Utils/network_capture.py del framework de automatización:
+  - mismos nombres y mismo estado en el page (page._network_evidence), así que
+    guardar_evidencia_red() del framework sigue funcionando encima de esta captura;
+  - mismo enmascarado de datos sensibles (RUT, tokens, passwords, cookies...);
+  - mismo fallback CDP para recuperar el post_data de ciertos POST.
+
+Novedades:
+  - duration_ms y resource_type por conexión;
+  - reportar_red(page, cr): envía a TraceReports SOLO las conexiones nuevas desde el
+    último envío (por test, no acumulado) y espera brevemente las que siguen en vuelo.
+
+Uso:
+    page = context.new_page()
+    attach_listeners(page, logger=logger)        # ANTES del primer page.goto()
+    ...
+    resumen = reportar_red(page, cr, guardar_en="output/network", nombre_evento="test_001_login")
+    # -> {"total": 42, "ok": 40, "errores": 2, "fallidas": 1, "archivo": "C:/.../network_test_001_login_1790.json"}
+"""
+
+import json
+import os
+import re
+import time
+
+_SENSITIVE_HEADER_NAMES = {"authorization", "cookie", "set-cookie", "x-auth-token"}
+_BODY_RESOURCE_TYPES = {"xhr", "fetch"}
+
+
+def _mask_sensitive(text):
+    if not isinstance(text, str):
+        return text
+    text = re.sub(r'\b\d{7,8}-[\dkK]\b', '<rut>', text)
+    text = re.sub(
+        r'"(token|sig|session|auth|password|pwd|clave)"\s*:\s*"[^"]*"',
+        r'"\1": "<masked>"',
+        text,
+        flags=re.IGNORECASE,
+    )
+    text = re.sub(
+        r'\b(token|sig|session|auth|password|pwd|clave)=[^&\s"]+',
+        r'\1=<masked>',
+        text,
+        flags=re.IGNORECASE,
+    )
+    return text
+
+
+def _mask_headers(headers):
+    if not headers:
+        return {}
+    return {
+        key: "<masked>" if key.lower() in _SENSITIVE_HEADER_NAMES else _mask_sensitive(value)
+        for key, value in headers.items()
+    }
+
+
+def attach_listeners(
+    page,
+    logger=None,
+    incluir_bodies_api=True,
+    incluir_bodies_error=True,
+    patrones_api=("/api/",),
+    max_body_chars=None,
+):
+    """
+    Registra los listeners de red en el page. Debe llamarse INMEDIATAMENTE después de
+    crear el page, antes de cualquier page.goto() (Playwright no tiene buffer retroactivo).
+
+    El body de la response se lee en el momento en que llega (después el navegador puede
+    descartarlo). Se guarda el body de: URLs que contienen algún `patrones_api`, requests
+    XHR/fetch, y respuestas con status >= 400. Por defecto el body se conserva COMPLETO
+    (como network_capture.py) para que reportar_red(..., guardar_en=...) lo deje entero en
+    disco; `max_body_chars` permite acotarlo si la memoria importa más que la evidencia.
+    """
+    page._network_evidence = []
+    page._network_by_request = {}
+    page._network_reported_idx = 0
+    page._network_postdata_cdp_pendientes = {}
+    page._network_conexiones_esperando_postdata = []
+
+    def _on_request(request):
+        try:
+            conexion = {
+                "requestId": id(request),
+                "url": _mask_sensitive(request.url),
+                "method": request.method,
+                "resource_type": request.resource_type,
+                "request_headers": _mask_headers(request.headers),
+                "post_data": _mask_sensitive(request.post_data or ""),
+                "has_post_data": bool(request.post_data),
+                "wall_time": time.time(),
+            }
+            page._network_evidence.append(conexion)
+            page._network_by_request[request] = conexion
+
+            if not conexion["has_post_data"]:
+                clave = (request.method, request.url)
+                cola = page._network_postdata_cdp_pendientes.get(clave)
+                if cola:
+                    conexion["post_data"] = _mask_sensitive(cola.pop(0))
+                    conexion["has_post_data"] = True
+                    conexion["post_data_via_cdp"] = True
+                else:
+                    page._network_conexiones_esperando_postdata.append((request.method, request.url, conexion))
+        except Exception as e:
+            if logger:
+                logger.debug(f"No se pudo registrar request: {e}")
+
+    def _on_response(response):
+        try:
+            conexion = page._network_by_request.get(response.request)
+            if conexion is None:
+                return
+            conexion["status"] = response.status
+            conexion["status_text"] = response.status_text
+            conexion["mime_type"] = (response.headers or {}).get("content-type", "")
+            conexion["response_headers"] = _mask_headers(response.headers)
+            conexion["response_url"] = _mask_sensitive(response.url)
+        except Exception as e:
+            if logger:
+                logger.debug(f"No se pudo registrar response: {e}")
+            return
+
+        url = (conexion.get("url") or "").lower()
+        es_api = any(p in url for p in patrones_api) or conexion.get("resource_type") in _BODY_RESOURCE_TYPES
+        if (incluir_bodies_api and es_api) or (incluir_bodies_error and response.status >= 400):
+            try:
+                body = response.text()
+                conexion["body_size"] = len(body)
+                conexion["response_body"] = _mask_sensitive(body if max_body_chars is None else body[:max_body_chars])
+            except Exception as e:
+                if logger:
+                    logger.debug(f"No se pudo leer el body de {conexion.get('url')}: {e}")
+
+    def _duracion(request, conexion):
+        try:
+            timing = request.timing or {}
+            if timing.get("responseEnd", -1) > 0:
+                return int(timing["responseEnd"])
+        except Exception:
+            pass
+        return int((time.time() - conexion["wall_time"]) * 1000)
+
+    def _on_request_finished(request):
+        conexion = page._network_by_request.get(request)
+        if conexion is not None:
+            conexion["duration_ms"] = _duracion(request, conexion)
+
+    def _on_request_failed(request):
+        try:
+            conexion = page._network_by_request.get(request)
+            if conexion is None:
+                return
+            conexion["failed"] = True
+            conexion["error_text"] = request.failure
+            conexion["duration_ms"] = int((time.time() - conexion["wall_time"]) * 1000)
+        except Exception as e:
+            if logger:
+                logger.debug(f"No se pudo registrar requestfailed: {e}")
+
+    page.on("request", _on_request)
+    page.on("response", _on_response)
+    page.on("requestfinished", _on_request_finished)
+    page.on("requestfailed", _on_request_failed)
+
+    # Fallback CDP para post_data (solo Chromium): ver network_capture.py original.
+    try:
+        cdp = page.context.new_cdp_session(page)
+        cdp.send("Network.enable")
+
+        def _on_cdp_request_will_be_sent(params):
+            try:
+                req = params.get("request") or {}
+                if not req.get("hasPostData") or req.get("postData"):
+                    return
+                request_id = params.get("requestId")
+                if not request_id:
+                    return
+                post_data_cdp = cdp.send("Network.getRequestPostData", {"requestId": request_id}).get("postData")
+                if not post_data_cdp:
+                    return
+                metodo, url = req.get("method"), req.get("url")
+                pendientes = page._network_conexiones_esperando_postdata
+                for i, (m, u, conexion) in enumerate(pendientes):
+                    if m == metodo and u == url:
+                        conexion["post_data"] = _mask_sensitive(post_data_cdp)
+                        conexion["has_post_data"] = True
+                        conexion["post_data_via_cdp"] = True
+                        pendientes.pop(i)
+                        return
+                page._network_postdata_cdp_pendientes.setdefault((metodo, url), []).append(post_data_cdp)
+            except Exception as e:
+                if logger:
+                    logger.debug(f"No se pudo obtener postData via CDP: {e}")
+
+        cdp.on("Network.requestWillBeSent", _on_cdp_request_will_be_sent)
+    except Exception as e:
+        if logger:
+            logger.debug(f"Sin sesión CDP para el fallback de postData (¿navegador no Chromium?): {e}")
+
+
+def conexiones_del_test(page):
+    """Conexiones capturadas desde el último reportar_red(): las del test en curso.
+    Útil para validar el backend dentro del test (p. ej. "se envió el POST de login")."""
+    return list(getattr(page, "_network_evidence", [])[getattr(page, "_network_reported_idx", 0):])
+
+
+def esperar_conexion(page, predicado, timeout_ms=5000):
+    """Espera hasta que una conexión del test cumpla `predicado` y tenga respuesta (o falle).
+    Retorna la conexión o None."""
+    limite = time.time() + timeout_ms / 1000
+    while True:
+        for c in conexiones_del_test(page):
+            if predicado(c) and (c.get("status") or c.get("failed")):
+                return c
+        if time.time() >= limite:
+            return None
+        page.wait_for_timeout(100)
+
+
+def _en_vuelo(conexiones):
+    return [c for c in conexiones if not c.get("status") and not c.get("failed")]
+
+
+def resumir_red(conexiones):
+    """{"total", "ok", "errores", "fallidas"} — errores = HTTP >= 400 o sin respuesta."""
+    fallidas = sum(1 for c in conexiones if c.get("failed"))
+    http_error = sum(1 for c in conexiones if not c.get("failed") and (c.get("status") or 0) >= 400)
+    return {
+        "total": len(conexiones),
+        "ok": sum(1 for c in conexiones if not c.get("failed") and 0 < (c.get("status") or 0) < 400),
+        "errores": fallidas + http_error,
+        "fallidas": fallidas,
+    }
+
+
+def guardar_red_local(conexiones, carpeta, nombre_evento):
+    """Guarda las conexiones COMPLETAS (sin recortar bodies) en carpeta/network_<evento>_<ts>.json
+    y retorna la ruta absoluta (o None si no se pudo escribir)."""
+    os.makedirs(carpeta, exist_ok=True)
+    nombre = "".join(ch if ch.isalnum() or ch in "-_" else "_" for ch in nombre_evento)
+    ruta = os.path.abspath(os.path.join(carpeta, f"network_{nombre}_{int(time.time())}.json"))
+    with open(ruta, "w", encoding="utf-8") as fh:
+        json.dump(conexiones, fh, ensure_ascii=False, indent=2, default=str)
+    return ruta
+
+
+def reportar_red(page, cr, test_id=None, esperar_en_vuelo_ms=2000, logger=None, guardar_en=None, nombre_evento=None):
+    """
+    Envía a TraceReports las conexiones capturadas desde el último envío (las del test
+    actual) y retorna su resumen. Antes espera hasta `esperar_en_vuelo_ms` a que terminen
+    las requests todavía sin respuesta, para no reportarlas incompletas.
+
+    guardar_en: carpeta donde dejar además un JSON con la captura COMPLETA del test. El
+    servidor guarda como máximo 256 KB por body; con esto el reporte indica la ruta exacta
+    del archivo que tiene el body entero (p. ej. catálogos de varios MB).
+    """
+    capturadas = getattr(page, "_network_evidence", None)
+    if capturadas is None:
+        if logger:
+            logger.warning("reportar_red: el page no tiene attach_listeners() — no hay captura de red")
+        return None
+
+    desde = getattr(page, "_network_reported_idx", 0)
+    limite = time.time() + esperar_en_vuelo_ms / 1000
+    while _en_vuelo(capturadas[desde:]) and time.time() < limite:
+        try:
+            page.wait_for_timeout(100)  # deja que Playwright procese los eventos pendientes
+        except Exception:
+            break
+
+    nuevas = capturadas[desde:]
+    page._network_reported_idx = desde + len(nuevas)
+    resumen = resumir_red(nuevas)
+    if nuevas and guardar_en:
+        try:
+            ruta = guardar_red_local(nuevas, guardar_en, nombre_evento or "test")
+            for conexion in nuevas:
+                conexion["evidence_file"] = ruta
+            resumen["archivo"] = ruta
+        except OSError as e:
+            if logger:
+                logger.warning(f"No se pudo guardar la evidencia de red local: {e}")
+    if nuevas:
+        cr.attach_network(nuevas, test_id=test_id)
+    if logger:
+        logger.info(f"Red reportada: {resumen}")
+    return resumen

tracereports/pytest_plugin.py

@@ -0,0 +1,290 @@
+"""
+Plugin de pytest: reporta la suite a TraceReports sin cambiar el código de los tests.
+
+    pytest --tracereports                                   # servidor en $TRACEREPORTS_URL o localhost:8080
+    pytest --tracereports --tracereports-run "Regresión" --tracereports-env staging
+    pytest --tracereports -n 4                              # pytest-xdist: un solo reporte consolidado
+
+Qué hace:
+  - una ejecución (run) por sesión de pytest y un test por cada caso. Con pytest-xdist el
+    controlador crea la ejecución y los workers reportan en ella; se cierra cuando terminan
+    todos (si un worker se cae, sus tests quedan como interrumpidos y la ejecución, incompleta);
+  - identidad estable de cada test: su nodeid (archivo::clase::test[parámetros]), aparte del
+    nombre visible. Dos tests con el mismo nombre en archivos distintos no mezclan su historial.
+    @pytest.mark.tracereports_id("login-ok") la fija a mano si el nodeid cambia;
+  - contexto: proyecto (--tracereports-project / $TRACEREPORTS_PROJECT / la carpeta), rama y commit (del CI
+    o de git). El historial y las comparaciones solo usan ejecuciones del mismo contexto;
+  - estado PASS/FAIL/SKIP con el mensaje y el traceback del fallo (entrada del AI Triage). Con
+    pytest-rerunfailures, los intentos quedan en el mismo test ("pasó tras reintento") y la
+    evidencia del primer fallo se conserva;
+  - con pytest-playwright (fixture `page`): captura de pantalla al fallar, snapshot del DOM y
+    captura de red del test (pestaña "Red"), sin configurar nada;
+  - @pytest.mark.tracereports_expect(status=401, url="/api/auth") declara una respuesta negativa que
+    el test verifica a propósito (también en la clase o el módulo): no cuenta como error ni como
+    causa del fallo;
+  - fixture `tracereports` para agregar pasos y capturas propias:
+
+        def test_login(page, tracereports):
+            tracereports.log_info("Abrir login")
+            tracereports.attach_screenshot(page.screenshot(), "Formulario de login")
+
+La evidencia se envía en segundo plano con reintentos; al terminar, el resumen de la terminal
+dice si algo no llegó. --tracereports-strict hace fallar la sesión en ese caso (útil en CI).
+
+Configuración por variables de entorno equivalentes: TRACEREPORTS_URL, TRACEREPORTS_TOKEN, TRACEREPORTS_RUN_NAME,
+TRACEREPORTS_ENV, TRACEREPORTS_PROJECT, TRACEREPORTS_RUN_ID (unirse a una ejecución ya creada, p. ej. shards de
+CI), TRACEREPORTS_SPOOL_DIR, TRACEREPORTS_STRICT. Con --tracereports-zip DIR el reporte queda además en un ZIP
+(se abre sin servidor ni internet), ideal para adjuntarlo como artefacto del pipeline.
+"""
+
+import os
+
+import pytest
+
+from ._env import env
+from .client import TraceReports
+from .dom import capturar_dom
+from .network import attach_listeners, reportar_red
+
+_TEST_ID = pytest.StashKey[int]()
+_OUTCOME = pytest.StashKey[dict]()
+_PAGE = pytest.StashKey[object]()
+
+
+def _page(item):
+    """Página de pytest-playwright del test (pytest borra item.funcargs tras el teardown)."""
+    page = item.stash.get(_PAGE, None)
+    if page is None:
+        page = (getattr(item, "funcargs", None) or {}).get("page")
+    return page
+
+
+def _truthy(value):
+    return str(value or "").lower() in ("1", "true", "yes")
+
+
+def pytest_addoption(parser):
+    group = parser.getgroup("tracereports", "TraceReports")
+    group.addoption("--tracereports", action="store_true", help="reportar la ejecución a TraceReports")
+    group.addoption("--tracereports-url", default=None, help="URL del servidor (default: $TRACEREPORTS_URL o http://localhost:8080)")
+    group.addoption("--tracereports-run", default=None, help="nombre de la ejecución (default: $TRACEREPORTS_RUN_NAME o la carpeta del proyecto)")
+    group.addoption("--tracereports-env", default=None, help="ambiente: navegador, entorno, versión... (default: $TRACEREPORTS_ENV)")
+    group.addoption("--tracereports-project", default=None, help="proyecto (default: $TRACEREPORTS_PROJECT o la carpeta raíz)")
+    group.addoption("--tracereports-no-network", action="store_true", help="no capturar la red del backend con Playwright")
+    group.addoption("--tracereports-no-screenshots", action="store_true", help="no tomar captura de pantalla al fallar (datos sensibles en pantalla)")
+    group.addoption("--tracereports-no-dom", action="store_true", help="no enviar el snapshot del DOM al fallar")
+    group.addoption("--tracereports-zip", default=None, metavar="DIR", help="al terminar, guardar el reporte en ZIP en DIR (útil como artefacto de CI)")
+    group.addoption("--tracereports-spool", default=None, metavar="DIR", help="carpeta donde guardar la evidencia que no se pudo enviar (default: $TRACEREPORTS_SPOOL_DIR)")
+    group.addoption("--tracereports-strict", action="store_true", help="falla la sesión si parte de la evidencia no llegó al servidor (default: $TRACEREPORTS_STRICT)")
+
+
+def pytest_configure(config):
+    config.addinivalue_line("markers", "tracereports_id(key): identidad estable del test en TraceReports (reemplaza el nodeid)")
+    config.addinivalue_line("markers", "tracereports_expect(status, url='', method=''): respuesta HTTP negativa esperada por el test")
+    if config.getoption("--tracereports"):
+        config.pluginmanager.register(TraceReportsPlugin(config), "tracereports-plugin")
+
+
+@pytest.fixture
+def tracereports(request):
+    """Cliente de TraceReports ligado al test en curso (no-op si no se usa --tracereports)."""
+    plugin = request.config.pluginmanager.get_plugin("tracereports-plugin")
+    return plugin.cr if plugin else TraceReports(enabled=False)
+
+
+def _identity(item):
+    """(key, suite, params) del test: nodeid salvo que @tracereports_id lo fije."""
+    marker = item.get_closest_marker("tracereports_id")
+    key = str(marker.args[0]) if marker and marker.args else item.nodeid
+    suite = item.nodeid.rsplit("::", 1)[0] if "::" in item.nodeid else item.nodeid
+    callspec = getattr(item, "callspec", None)
+    params = getattr(callspec, "id", "") if callspec is not None else ""
+    return key, suite, params
+
+
+class TraceReportsPlugin:
+    def __init__(self, config):
+        self.config = config
+        self.cr = TraceReports(config.getoption("--tracereports-url"), spool_dir=config.getoption("--tracereports-spool"))
+        self.capture_network = not config.getoption("--tracereports-no-network")
+        self.capture_screenshots = not config.getoption("--tracereports-no-screenshots")
+        self.capture_dom = not config.getoption("--tracereports-no-dom")
+        self.strict = config.getoption("--tracereports-strict") or _truthy(env("STRICT"))
+        self.workerinput = getattr(config, "workerinput", None)  # presente en workers de xdist
+        self.crashed_workers = []
+        self.worker_problems = 0
+        self.problems = []
+
+    # ─── sesión ────────────────────────────────────────────────────────────
+    def _ensure_run(self):
+        """Crea (o se une a) la ejecución una sola vez. En un worker de xdist usa la del controlador."""
+        if self.cr.run_id:
+            return
+        if self.workerinput is not None:
+            self.cr.join_run(self.workerinput.get("tracereports_run_id"))
+            return
+        shared = env("RUN_ID")
+        if shared:
+            self.cr.join_run(shared)
+            return
+        root = str(self.config.rootpath)
+        name = self.config.getoption("--tracereports-run") or env("RUN_NAME") or os.path.basename(root)
+        environment = self.config.getoption("--tracereports-env") or env("ENV") or ""
+        project = self.config.getoption("--tracereports-project") or env("PROJECT") or os.path.basename(root)
+        self.cr.start_run(name, environment=environment, project=project, framework="pytest")
+
+    def pytest_sessionstart(self, session):
+        self._ensure_run()
+
+    @pytest.hookimpl(optionalhook=True)
+    def pytest_configure_node(self, node):
+        """xdist (controlador): todos los workers reportan en la misma ejecución."""
+        self._ensure_run()
+        node.workerinput["tracereports_run_id"] = self.cr.run_id
+
+    @pytest.hookimpl(optionalhook=True)
+    def pytest_testnodedown(self, node, error):
+        """xdist (controlador): un worker terminó; si se cayó, la ejecución queda incompleta."""
+        if error:
+            self.crashed_workers.append(getattr(node, "gateway", None) and node.gateway.id or "worker")
+        out = getattr(node, "workeroutput", None) or {}
+        self.worker_problems += int(out.get("tracereports_problems", 0))
+
+    def pytest_sessionfinish(self, session, exitstatus):
+        if self.workerinput is not None:
+            # worker: entrega su evidencia; el controlador cierra la ejecución
+            self.cr.flush()
+            self.cr._sender.drain_to_spool()
+            self.config.workeroutput["tracereports_problems"] = self.cr.delivery_problems()
+            return
+        if not self.cr.run_id:
+            if self.cr.enabled:
+                self.problems.append("no se pudo crear la ejecución en el servidor")
+            self._apply_strict(session)
+            return
+        if self.cr.run_created:
+            interrupted = bool(self.crashed_workers) or exitstatus == pytest.ExitCode.INTERRUPTED or bool(session.shouldstop)
+            self.cr.end_run(interrupted=interrupted)
+            zip_dir = self.config.getoption("--tracereports-zip")
+            if zip_dir:
+                self.zip_path = self.cr.download_report(zip_dir)
+        else:
+            self.cr.flush()
+            self.cr._sender.drain_to_spool()
+        lost = self.cr.delivery_problems() + self.worker_problems
+        if lost:
+            self.problems.append(f"{lost} eventos de evidencia no llegaron al servidor")
+        if self.crashed_workers:
+            self.problems.append(f"workers caídos: {', '.join(map(str, self.crashed_workers))} (ejecución incompleta)")
+        self._apply_strict(session)
+
+    def _apply_strict(self, session):
+        if self.strict and self.problems and session.exitstatus == pytest.ExitCode.OK:
+            session.exitstatus = pytest.ExitCode.TESTS_FAILED
+
+    def pytest_terminal_summary(self, terminalreporter):
+        if self.workerinput is not None:
+            return
+        if self.cr.run_id:
+            terminalreporter.write_line(f"TraceReports: {self.cr.base_url}/#run={self.cr.run_id}&view=dashboard")
+        if getattr(self, "zip_path", None):
+            terminalreporter.write_line(f"TraceReports ZIP: {self.zip_path}")
+        d = self.cr.delivery
+        if self.problems:
+            detail = ", ".join(f"{k}={d[k]}" for k in ("sent", "retried", "rejected", "dropped", "spooled", "lost", "unregistered_tests") if d[k])
+            terminalreporter.write_line(f"TraceReports: atención: {'; '.join(self.problems)} ({detail})"
+                                        + (" — --tracereports-strict: la sesión falla" if self.strict else ""),
+                                        yellow=True)
+
+    # ─── cada test ─────────────────────────────────────────────────────────
+    @pytest.hookimpl(hookwrapper=True)
+    def pytest_runtest_protocol(self, item, nextitem):
+        doc = (getattr(item.function, "__doc__", None) or "").strip() if hasattr(item, "function") else ""
+        markers = [m.name for m in item.iter_markers()
+                   if m.name not in ("parametrize", "usefixtures", "skip", "skipif", "xfail", "tracereports_id", "tracereports_expect",
+                                     "flaky")]
+        category = ", ".join([item.module.__name__.split(".")[-1], *markers]) if hasattr(item, "module") else ", ".join(markers)
+        key, suite, params = _identity(item)
+        test_id = self.cr.start_test(item.name, category=category, description=doc.splitlines()[0] if doc else "",
+                                     key=key, suite=suite, params=params)
+        if test_id:
+            item.stash[_TEST_ID] = test_id
+            for m in item.iter_markers("tracereports_expect"):
+                status = m.kwargs.get("status", m.args[0] if m.args else None)
+                if status is not None:
+                    self.cr.expect_response(status, url=m.kwargs.get("url", ""), method=m.kwargs.get("method", ""), test_id=test_id)
+        item.stash[_OUTCOME] = {"status": None, "message": "", "trace": "", "attempts": 0}
+        yield
+        self._finish(item)
+
+    @pytest.hookimpl(hookwrapper=True)
+    def pytest_runtest_call(self, item):
+        # La captura de red se engancha antes de que el test navegue (la fixture page ya existe).
+        page = (getattr(item, "funcargs", None) or {}).get("page")
+        if page is not None:
+            item.stash[_PAGE] = page
+            if self.capture_network and not hasattr(page, "_network_evidence"):
+                attach_listeners(page)
+        yield
+        # Con la página todavía abierta: esperar (máx. 2 s) las llamadas en vuelo y enviar la red.
+        # Después del teardown pytest-playwright cierra la página y ya no se puede esperar.
+        test_id = item.stash.get(_TEST_ID, None)
+        if page is not None and test_id and hasattr(page, "_network_evidence"):
+            reportar_red(page, self.cr, test_id=test_id, esperar_en_vuelo_ms=2000)
+
+    @pytest.hookimpl(hookwrapper=True)
+    def pytest_runtest_makereport(self, item, call):
+        report = (yield).get_result()
+        outcome = item.stash.get(_OUTCOME, None)
+        if outcome is None:
+            return
+        if report.when == "setup":
+            # cada intento empieza con su setup (pytest-rerunfailures repite setup/call/teardown)
+            outcome["attempts"] += 1
+            if outcome["attempts"] > 1:
+                previous = outcome["message"] or "falló"
+                test_id = item.stash.get(_TEST_ID, None)
+                self.cr.log_warning(f"Reintento {outcome['attempts']}: el intento {outcome['attempts'] - 1} falló — {previous}", test_id=test_id)
+                outcome.update(status=None, message="", trace="")
+        if report.skipped:
+            reason = report.longrepr[2] if isinstance(report.longrepr, tuple) else str(report.longrepr or "")
+            if outcome["status"] is None:
+                outcome.update(status="SKIP", message=reason.replace("Skipped: ", ""))
+        elif report.failed:
+            if outcome["status"] != "FAIL":
+                text = report.longreprtext or ""
+                last = [ln for ln in text.splitlines() if ln.startswith("E ")]
+                outcome.update(status="FAIL", message=(" ".join(ln[2:].strip() for ln in last[:3]) or text[:300]).strip(), trace=text)
+                if report.when != "call":
+                    outcome["message"] = f"Error en {report.when}: " + outcome["message"]
+                self._evidence_on_failure(item)
+        elif report.when == "call" and outcome["status"] is None:
+            outcome["status"] = "PASS"
+
+    def _evidence_on_failure(self, item):
+        page = _page(item)
+        if page is None:
+            return
+        test_id = item.stash.get(_TEST_ID, None)
+        if self.capture_screenshots:
+            try:
+                self.cr.attach_screenshot(page.screenshot(timeout=5000), "Captura al fallar", status="FAIL", test_id=test_id)
+            except Exception:
+                pass  # la página puede estar cerrada: la evidencia nunca rompe el test
+        if self.capture_dom:
+            # snapshot de los elementos: el reporte recomienda selectores si el fallo fue de locator
+            self.cr.attach_dom(capturar_dom(page), test_id=test_id)
+
+    def _finish(self, item):
+        test_id = item.stash.get(_TEST_ID, None)
+        if not test_id:
+            return
+        outcome = item.stash[_OUTCOME]
+        page = _page(item)
+        if page is not None and hasattr(page, "_network_evidence"):
+            # lo que llegó durante el teardown (la página ya puede estar cerrada: sin esperar)
+            reportar_red(page, self.cr, test_id=test_id, esperar_en_vuelo_ms=0)
+        if outcome["status"] == "FAIL":
+            self.cr.log_fail(outcome["message"] or "Falló", test_id=test_id)
+        self.cr.end_test(outcome["status"] or "PASS", error_message=outcome["message"] if outcome["status"] == "FAIL" else "",
+                         error_trace=outcome["trace"], test_id=test_id, attempts=outcome["attempts"])

tracereports/resend.py

@@ -0,0 +1,63 @@
+"""
+Reenvía la evidencia que quedó en la cola local (spool) porque el servidor no respondía:
+
+    python -m tracereports.resend ./tracereports-spool
+    python -m tracereports.resend ./tracereports-spool --url http://tracereports:8080 --timeout 120
+
+Cada evento lleva su clave de idempotencia: reenviarlo dos veces no duplica nada. Un spool más
+grande que la cola se reenvía por tandas. Lo que no se pueda enviar ahora vuelve a la misma carpeta.
+
+Código de salida: 0 solo si no queda ningún evento pendiente en la carpeta; 1 si queda evidencia
+(sin enviar, en archivos que otro proceso está reenviando, o ilegibles) o el servidor rechazó algo.
+"""
+
+from __future__ import annotations
+
+import argparse
+import logging
+import sys
+import time
+
+from .client import TraceReports
+from .transport import spool_files
+
+
+def main(argv=None) -> int:
+    parser = argparse.ArgumentParser(prog="python -m tracereports.resend", description=__doc__,
+                                     formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("spool_dir", help="carpeta del spool (TRACEREPORTS_SPOOL_DIR)")
+    parser.add_argument("--url", default=None, help="URL del servidor (default: $TRACEREPORTS_URL o http://localhost:8080)")
+    parser.add_argument("--timeout", type=float, default=120.0, help="segundos máximos reenviando")
+    args = parser.parse_args(argv)
+    logging.basicConfig(level=logging.INFO, format="%(message)s")
+
+    if not any(spool_files(args.spool_dir).values()):
+        print(f"No hay eventos pendientes en {args.spool_dir}.")
+        return 0
+
+    cr = TraceReports(args.url, spool_dir=args.spool_dir)
+    sender = cr._sender
+    deadline = time.time() + args.timeout
+    loaded = pending = 0
+    while time.time() < deadline:  # por tandas: el spool puede ser más grande que la cola
+        n = sender.load_spool()
+        loaded += n
+        pending = cr.flush(max(deadline - time.time(), 0))
+        if n == 0 or pending:
+            break
+    sender.drain_to_spool()  # lo que no salió vuelve al spool
+    d = cr.delivery
+    left = spool_files(args.spool_dir)
+    print(f"Reenviados {d['sent']} de {loaded} eventos cargados · rechazados por el servidor {d['rejected']} · "
+          f"vuelven al spool {d['spooled']}.")
+    if left["pending"]:
+        print(f"Quedan {left['pending']} archivos sin reenviar en {args.spool_dir} (el servidor no respondió o se acabó el tiempo).")
+    if left["claimed"]:
+        print(f"{left['claimed']} archivos los está reenviando otro proceso (o quedaron de uno que terminó: se retoman solos).")
+    if left["unreadable"]:
+        print(f"{left['unreadable']} archivos ilegibles quedaron como *.unreadable: revísalos a mano.")
+    return 0 if not any(left.values()) and d["rejected"] == 0 else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())