wup 0.2.15__tar.gz → 0.2.16__tar.gz

{wup-0.2.15/wup.egg-info → wup-0.2.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wup
-Version: 0.2.15
+Version: 0.2.16
 Summary: WUP (What's Up) - Intelligent file watcher for regression testing in large projects
 Author-email: Tom Sapletta <tom@sapletta.com>
 License: Apache-2.0
@@ -29,17 +29,17 @@ Dynamic: license-file
 
 ## AI Cost Tracking
 
-![PyPI](https://img.shields.io/badge/pypi-costs-blue) ![Version](https://img.shields.io/badge/version-0.2.15-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
-![AI Cost](https://img.shields.io/badge/AI%20Cost-$2.40-orange) ![Human Time](https://img.shields.io/badge/Human%20Time-4.1h-blue) ![Model](https://img.shields.io/badge/Model-openrouter%2Fqwen%2Fqwen3--coder--next-lightgrey)
+![PyPI](https://img.shields.io/badge/pypi-costs-blue) ![Version](https://img.shields.io/badge/version-0.2.16-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
+![AI Cost](https://img.shields.io/badge/AI%20Cost-$2.55-orange) ![Human Time](https://img.shields.io/badge/Human%20Time-4.5h-blue) ![Model](https://img.shields.io/badge/Model-openrouter%2Fqwen%2Fqwen3--coder--next-lightgrey)
 
-- 🤖 **LLM usage:** $2.4000 (16 commits)
-- 👤 **Human dev:** ~$411 (4.1h @ $100/h, 30min dedup)
+- 🤖 **LLM usage:** $2.5500 (17 commits)
+- 👤 **Human dev:** ~$445 (4.5h @ $100/h, 30min dedup)
 
 Generated on 2026-04-29 using [openrouter/qwen/qwen3-coder-next](https://openrouter.ai/qwen/qwen3-coder-next)
 
 ---
 
-![PyPI](https://img.shields.io/badge/pypi-wup-blue) ![Version](https://img.shields.io/badge/version-0.2.15-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
+![PyPI](https://img.shields.io/badge/pypi-wup-blue) ![Version](https://img.shields.io/badge/version-0.2.16-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
 
 **WUP (What's Up)** - Intelligent file watcher for regression testing in large projects.
 
@@ -333,6 +333,39 @@ Visible in `wup status` as a "Visual DOM diffs" section.
 
 If Playwright is not installed, the visual diff module logs a warning and skips scanning — it does **not** break the watcher.
 
+## Web Dashboard (wup-web)
+
+Optional FastAPI backend that receives events from WUP agents and renders a live dashboard.
+
+### Run
+
+```bash
+pip install -e wup-web/
+wup-web --reload --port 8000
+```
+
+Open <http://localhost:8000/> to see regressions, passes, anomalies, visual diffs, and health transitions in real time.
+
+### Configure agent → backend
+
+```yaml
+# wup.yaml
+web:
+  enabled: true
+  endpoint: "http://localhost:8000"
+  timeout_s: 2.0
+```
+
+Or via env:
+
+```bash
+export WUP_WEB_ENDPOINT=http://localhost:8000
+```
+
+The agent fire-and-forgets `REGRESSION`, `PASS`, `ANOMALY`, `VISUAL_DIFF`, and `HEALTH_TRANSITION` events. Network errors never break the watcher (soft-fail).
+
+See `wup-web/README.md` for full API reference and driver endpoints (DOM diff, browserless, anomaly).
+
 ## Project Structure
 
 ```
@@ -346,12 +379,21 @@ wup/
 │   ├── testql_discovery.py    # TestQLEndpointDiscovery: scenario parsing
 │   ├── testql_watcher.py      # TestQLWatcher: scenario runner + health tracking
 │   ├── visual_diff.py         # VisualDiffer: Playwright DOM snapshot + diff engine
+│   ├── web_client.py          # WebClient: async HTTP event sink → wup-web
 │   └── models/
 │       ├── __init__.py
-│       └── config.py          # Dataclasses: WupConfig, VisualDiffConfig, TestQLConfig...
+│       └── config.py          # Dataclasses: WupConfig, VisualDiffConfig, WebConfig...
+├── wup-web/                   # Optional FastAPI dashboard (separate package)
+│   ├── wup_web/
+│   │   ├── main.py            # FastAPI app
+│   │   ├── routers/           # events, drivers, dashboard
+│   │   ├── storage.py         # EventStore (in-memory + JSONL)
+│   │   └── templates/         # index.html dashboard
+│   └── tests/                 # FastAPI endpoint tests (pytest + TestClient)
 ├── tests/
 │   ├── test_wup.py            # unit/integration tests (incl. VisualDiffer, config)
 │   ├── test_testql_watcher.py # TestQLWatcher + VisualDiffer integration tests
+│   ├── test_web_client.py     # WebClient + WebConfig tests
 │   └── test_e2e.py            # end-to-end CLI tests
 ├── examples/
 │   ├── fastapi-app/           # FastAPI example project

{wup-0.2.15 → wup-0.2.16}/README.md

@@ -3,17 +3,17 @@
 
 ## AI Cost Tracking
 
-![PyPI](https://img.shields.io/badge/pypi-costs-blue) ![Version](https://img.shields.io/badge/version-0.2.15-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
-![AI Cost](https://img.shields.io/badge/AI%20Cost-$2.40-orange) ![Human Time](https://img.shields.io/badge/Human%20Time-4.1h-blue) ![Model](https://img.shields.io/badge/Model-openrouter%2Fqwen%2Fqwen3--coder--next-lightgrey)
+![PyPI](https://img.shields.io/badge/pypi-costs-blue) ![Version](https://img.shields.io/badge/version-0.2.16-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
+![AI Cost](https://img.shields.io/badge/AI%20Cost-$2.55-orange) ![Human Time](https://img.shields.io/badge/Human%20Time-4.5h-blue) ![Model](https://img.shields.io/badge/Model-openrouter%2Fqwen%2Fqwen3--coder--next-lightgrey)
 
-- 🤖 **LLM usage:** $2.4000 (16 commits)
-- 👤 **Human dev:** ~$411 (4.1h @ $100/h, 30min dedup)
+- 🤖 **LLM usage:** $2.5500 (17 commits)
+- 👤 **Human dev:** ~$445 (4.5h @ $100/h, 30min dedup)
 
 Generated on 2026-04-29 using [openrouter/qwen/qwen3-coder-next](https://openrouter.ai/qwen/qwen3-coder-next)
 
 ---
 
-![PyPI](https://img.shields.io/badge/pypi-wup-blue) ![Version](https://img.shields.io/badge/version-0.2.15-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
+![PyPI](https://img.shields.io/badge/pypi-wup-blue) ![Version](https://img.shields.io/badge/version-0.2.16-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
 
 **WUP (What's Up)** - Intelligent file watcher for regression testing in large projects.
 
@@ -307,6 +307,39 @@ Visible in `wup status` as a "Visual DOM diffs" section.
 
 If Playwright is not installed, the visual diff module logs a warning and skips scanning — it does **not** break the watcher.
 
+## Web Dashboard (wup-web)
+
+Optional FastAPI backend that receives events from WUP agents and renders a live dashboard.
+
+### Run
+
+```bash
+pip install -e wup-web/
+wup-web --reload --port 8000
+```
+
+Open <http://localhost:8000/> to see regressions, passes, anomalies, visual diffs, and health transitions in real time.
+
+### Configure agent → backend
+
+```yaml
+# wup.yaml
+web:
+  enabled: true
+  endpoint: "http://localhost:8000"
+  timeout_s: 2.0
+```
+
+Or via env:
+
+```bash
+export WUP_WEB_ENDPOINT=http://localhost:8000
+```
+
+The agent fire-and-forgets `REGRESSION`, `PASS`, `ANOMALY`, `VISUAL_DIFF`, and `HEALTH_TRANSITION` events. Network errors never break the watcher (soft-fail).
+
+See `wup-web/README.md` for full API reference and driver endpoints (DOM diff, browserless, anomaly).
+
 ## Project Structure
 
 ```
@@ -320,12 +353,21 @@ wup/
 │   ├── testql_discovery.py    # TestQLEndpointDiscovery: scenario parsing
 │   ├── testql_watcher.py      # TestQLWatcher: scenario runner + health tracking
 │   ├── visual_diff.py         # VisualDiffer: Playwright DOM snapshot + diff engine
+│   ├── web_client.py          # WebClient: async HTTP event sink → wup-web
 │   └── models/
 │       ├── __init__.py
-│       └── config.py          # Dataclasses: WupConfig, VisualDiffConfig, TestQLConfig...
+│       └── config.py          # Dataclasses: WupConfig, VisualDiffConfig, WebConfig...
+├── wup-web/                   # Optional FastAPI dashboard (separate package)
+│   ├── wup_web/
+│   │   ├── main.py            # FastAPI app
+│   │   ├── routers/           # events, drivers, dashboard
+│   │   ├── storage.py         # EventStore (in-memory + JSONL)
+│   │   └── templates/         # index.html dashboard
+│   └── tests/                 # FastAPI endpoint tests (pytest + TestClient)
 ├── tests/
 │   ├── test_wup.py            # unit/integration tests (incl. VisualDiffer, config)
 │   ├── test_testql_watcher.py # TestQLWatcher + VisualDiffer integration tests
+│   ├── test_web_client.py     # WebClient + WebConfig tests
 │   └── test_e2e.py            # end-to-end CLI tests
 ├── examples/
 │   ├── fastapi-app/           # FastAPI example project

{wup-0.2.15 → wup-0.2.16}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "wup"
-version = "0.2.15"
+version = "0.2.16"
 description = "WUP (What's Up) - Intelligent file watcher for regression testing in large projects"
 readme = "README.md"
 requires-python = ">=3.9"

wup-0.2.16/tests/test_web_client.py

@@ -0,0 +1,167 @@
+"""Tests for wup.web_client and WebConfig."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import threading
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from typing import List, Tuple
+
+import pytest
+
+from wup.models.config import WebConfig
+from wup.web_client import WebClient, resolve_endpoint
+
+# Skip all tests in this module if httpx is not installed
+pytest.importorskip("httpx")
+
+
+# ---------------------------------------------------------------------------
+# Lightweight HTTP recorder server (no external dep)
+# ---------------------------------------------------------------------------
+
+class _Recorder:
+    def __init__(self):
+        self.requests: List[Tuple[str, str, dict]] = []  # (method, path, body)
+
+
+def _make_handler(recorder: _Recorder, status: int = 201):
+    class Handler(BaseHTTPRequestHandler):
+        def log_message(self, *_): pass
+
+        def do_POST(self):
+            length = int(self.headers.get("Content-Length") or 0)
+            raw = self.rfile.read(length).decode("utf-8") if length else "{}"
+            try:
+                body = json.loads(raw)
+            except json.JSONDecodeError:
+                body = {"_raw": raw}
+            recorder.requests.append((self.command, self.path, body))
+            self.send_response(status)
+            self.send_header("Content-Type", "application/json")
+            self.end_headers()
+            self.wfile.write(b'{"accepted": true}')
+
+    return Handler
+
+
+@pytest.fixture
+def recorder_server():
+    rec = _Recorder()
+    server = HTTPServer(("127.0.0.1", 0), _make_handler(rec))
+    port = server.server_address[1]
+    thread = threading.Thread(target=server.serve_forever, daemon=True)
+    thread.start()
+    try:
+        yield f"http://127.0.0.1:{port}", rec
+    finally:
+        server.shutdown()
+        server.server_close()
+
+
+# ---------------------------------------------------------------------------
+# Tests
+# ---------------------------------------------------------------------------
+
+def test_resolve_endpoint_from_config():
+    cfg = WebConfig(endpoint="http://localhost:8000/")
+    assert resolve_endpoint(cfg) == "http://localhost:8000"
+
+
+def test_resolve_endpoint_from_env(monkeypatch):
+    cfg = WebConfig(endpoint="", endpoint_env="MY_WUP_WEB")
+    monkeypatch.setenv("MY_WUP_WEB", "http://my-host:9000/")
+    assert resolve_endpoint(cfg) == "http://my-host:9000"
+
+
+def test_resolve_endpoint_empty(monkeypatch):
+    cfg = WebConfig(endpoint="", endpoint_env="WUP_WEB_NONE")
+    monkeypatch.delenv("WUP_WEB_NONE", raising=False)
+    assert resolve_endpoint(cfg) == ""
+
+
+def test_is_active_false_when_disabled():
+    cfg = WebConfig(enabled=False, endpoint="http://x")
+    assert WebClient(cfg).is_active is False
+
+
+def test_is_active_false_when_no_endpoint():
+    cfg = WebConfig(enabled=True, endpoint="", endpoint_env="WUP_WEB_NONE")
+    assert WebClient(cfg).is_active is False
+
+
+def test_send_event_disabled_returns_false():
+    client = WebClient(WebConfig(enabled=False))
+    assert asyncio.run(client.send_event({"type": "REGRESSION"})) is False
+
+
+def test_send_event_posts_to_recorder(recorder_server):
+    base, rec = recorder_server
+    cfg = WebConfig(enabled=True, endpoint=base, timeout_s=5.0)
+    client = WebClient(cfg)
+    assert client.is_active is True
+
+    ok = asyncio.run(client.send_event({
+        "type": "REGRESSION",
+        "service": "users-web",
+        "file": "app/users/routes.py",
+        "endpoint": "/api/users",
+        "status": "fail",
+        "reason": "TestQL exit code 1",
+    }))
+    assert ok is True
+    assert len(rec.requests) == 1
+    method, path, body = rec.requests[0]
+    assert method == "POST"
+    assert path == "/events"
+    assert body["type"] == "REGRESSION"
+    assert body["service"] == "users-web"
+    assert "timestamp" in body  # auto-injected
+
+
+def test_send_event_with_api_key(recorder_server):
+    base, rec = recorder_server
+    cfg = WebConfig(enabled=True, endpoint=base, api_key="secret-token")
+    client = WebClient(cfg)
+    asyncio.run(client.send_event({"type": "PASS", "service": "x"}))
+    # body received OK; auth header is set on the client side (verified by no failure)
+    assert len(rec.requests) == 1
+
+
+def test_send_event_swallows_connection_error():
+    """Unreachable host must NOT raise — soft-fail by design."""
+    cfg = WebConfig(
+        enabled=True,
+        endpoint="http://127.0.0.1:1",  # almost certainly closed
+        timeout_s=0.5,
+    )
+    client = WebClient(cfg)
+    ok = asyncio.run(client.send_event({"type": "REGRESSION"}))
+    assert ok is False  # no exception raised
+
+
+def test_send_regression_helper(recorder_server):
+    base, rec = recorder_server
+    client = WebClient(WebConfig(enabled=True, endpoint=base))
+    ok = asyncio.run(client.send_regression(
+        service="users", file="x.py", endpoint="/api/users", reason="500",
+    ))
+    assert ok is True
+    body = rec.requests[0][2]
+    assert body["type"] == "REGRESSION"
+    assert body["service"] == "users"
+    assert body["status"] == "fail"
+
+
+def test_send_health_transition_helper(recorder_server):
+    base, rec = recorder_server
+    client = WebClient(WebConfig(enabled=True, endpoint=base))
+    ok = asyncio.run(client.send_health_transition(
+        service="users", from_status="up", to_status="down",
+    ))
+    assert ok is True
+    body = rec.requests[0][2]
+    assert body["type"] == "HEALTH_TRANSITION"
+    assert body["from"] == "up"
+    assert body["to"] == "down"

{wup-0.2.15 → wup-0.2.16}/wup/__init__.py

@@ -7,7 +7,7 @@ WUP monitors file changes and runs intelligent regression tests using a 3-layer
 3. Detail Layer: Full tests with blame reports (only on failure)
 """
 
-__version__ = "0.2.15"
+__version__ = "0.2.16"
 __author__ = "Tom Sapletta"
 
 from .config import load_config, save_config, get_default_config

{wup-0.2.15 → wup-0.2.16}/wup/config.py

@@ -20,6 +20,7 @@ from .models.config import (
     NotifyConfig,
     ServiceTestConfig,
     VisualDiffConfig,
+    WebConfig,
 )
 
 
@@ -218,6 +219,16 @@ def validate_config(raw: dict) -> WupConfig:
         headless=vd_raw.get("headless", True),
     )
 
+    # Parse web config (event sink)
+    web_raw = raw.get("web", {})
+    web = WebConfig(
+        enabled=web_raw.get("enabled", False),
+        endpoint=web_raw.get("endpoint", ""),
+        endpoint_env=web_raw.get("endpoint_env", "WUP_WEB_ENDPOINT"),
+        timeout_s=float(web_raw.get("timeout_s", 2.0)),
+        api_key=web_raw.get("api_key", ""),
+    )
+
     return WupConfig(
         project=project,
         watch=watch,
@@ -225,6 +236,7 @@ def validate_config(raw: dict) -> WupConfig:
         test_strategy=test_strategy,
         testql=testql,
         visual_diff=visual_diff,
+        web=web,
     )
 
 
@@ -302,6 +314,13 @@ def save_config(config: WupConfig, output_path: Path):
             "threshold_removed": config.visual_diff.threshold_removed,
             "threshold_changed": config.visual_diff.threshold_changed,
             "headless": config.visual_diff.headless,
+        },
+        "web": {
+            "enabled": config.web.enabled,
+            "endpoint": config.web.endpoint,
+            "endpoint_env": config.web.endpoint_env,
+            "timeout_s": config.web.timeout_s,
+            "api_key": config.web.api_key,
         }
     }
     

{wup-0.2.15 → wup-0.2.16}/wup/models/config.py

@@ -83,6 +83,16 @@ class VisualDiffConfig:
     headless: bool = True
 
 
+@dataclass
+class WebConfig:
+    """Configuration for sending events to wup-web backend."""
+    enabled: bool = False
+    endpoint: str = ""              # e.g. "http://localhost:8000/events"
+    endpoint_env: str = "WUP_WEB_ENDPOINT"
+    timeout_s: float = 2.0          # short — must not block watcher
+    api_key: str = ""               # optional bearer token
+
+
 @dataclass
 class ProjectConfig:
     """Project metadata."""
@@ -99,3 +109,4 @@ class WupConfig:
     test_strategy: TestStrategyConfig = field(default_factory=TestStrategyConfig)
     testql: TestQLConfig = field(default_factory=TestQLConfig)
     visual_diff: VisualDiffConfig = field(default_factory=VisualDiffConfig)
+    web: WebConfig = field(default_factory=WebConfig)

{wup-0.2.15 → wup-0.2.16}/wup/testql_watcher.py

@@ -16,6 +16,7 @@ from .config import load_config
 from .core import WupWatcher
 from .models.config import WupConfig, ServiceConfig
 from .visual_diff import VisualDiffer
+from .web_client import WebClient
 
 
 class BrowserNotifier:
@@ -96,6 +97,7 @@ class TestQLWatcher(WupWatcher):
         self.service_health = self._load_service_health()
         self.config = config
         self.visual_differ = VisualDiffer(project_root, config.visual_diff) if config and config.visual_diff else None
+        self.web_client = WebClient(config.web) if config and getattr(config, "web", None) else WebClient()
 
     def _load_service_health(self) -> Dict[str, Dict]:
         if not self.health_state_path.exists():
@@ -164,6 +166,20 @@ class TestQLWatcher(WupWatcher):
             }
         )
 
+        # Fire-and-forget: forward event to wup-web backend if active
+        if self.web_client.is_active:
+            try:
+                asyncio.ensure_future(
+                    self.web_client.send_health_transition(
+                        service=service,
+                        from_status=previous_status,
+                        to_status=status,
+                    )
+                )
+            except RuntimeError:
+                # No running event loop — skip silently
+                pass
+
     def _tokenize_service(self, service: str) -> List[str]:
         raw_tokens = re.split(r"[^a-zA-Z0-9]+", service.lower())
         return [token for token in raw_tokens if len(token) >= 3]

wup-0.2.16/wup/web_client.py

@@ -0,0 +1,178 @@
+"""
+WUP Web Client.
+
+Lightweight async HTTP client used by WUP agents to push events
+(REGRESSION, ANOMALY, PASS, VISUAL_DIFF, HEALTH_TRANSITION) to the
+optional `wup-web` FastAPI backend.
+
+Design constraints:
+  - **Soft-fail**: any network/HTTP error must NOT break the watcher.
+  - **Optional dependency**: httpx is optional; without it the client
+    becomes a no-op and logs a single warning.
+  - **Short timeout**: configurable via WebConfig.timeout_s (default 2s).
+"""
+
+from __future__ import annotations
+
+import os
+import time
+from dataclasses import asdict, is_dataclass
+from typing import Any, Dict, Optional
+
+from rich.console import Console
+
+from .models.config import WebConfig
+
+_console = Console()
+_HTTPX_AVAILABLE: Optional[bool] = None
+_HTTPX_WARN_LOGGED: bool = False
+
+
+def _httpx_available() -> bool:
+    global _HTTPX_AVAILABLE, _HTTPX_WARN_LOGGED
+    if _HTTPX_AVAILABLE is None:
+        try:
+            import httpx  # noqa: F401
+            _HTTPX_AVAILABLE = True
+        except ImportError:
+            _HTTPX_AVAILABLE = False
+            if not _HTTPX_WARN_LOGGED:
+                _console.print(
+                    "[yellow]wup.web_client: httpx not installed — events will not be sent[/yellow]"
+                )
+                _HTTPX_WARN_LOGGED = True
+    return _HTTPX_AVAILABLE
+
+
+def resolve_endpoint(cfg: WebConfig) -> str:
+    """Return endpoint URL from cfg or env, with trailing slash stripped."""
+    if cfg.endpoint:
+        return cfg.endpoint.rstrip("/")
+    env_var = cfg.endpoint_env or "WUP_WEB_ENDPOINT"
+    return os.environ.get(env_var, "").rstrip("/")
+
+
+def _normalize(payload: Any) -> Any:
+    """Convert dataclasses to plain dicts for JSON serialization."""
+    if is_dataclass(payload):
+        return asdict(payload)
+    if isinstance(payload, dict):
+        return {k: _normalize(v) for k, v in payload.items()}
+    if isinstance(payload, (list, tuple)):
+        return [_normalize(v) for v in payload]
+    return payload
+
+
+class WebClient:
+    """
+    Async event sink for the wup-web backend.
+
+    Usage::
+
+        client = WebClient(config.web)
+        await client.send_event({
+            "type": "REGRESSION",
+            "service": "users-web",
+            "file": "app/users/routes.py",
+            "endpoint": "/api/users",
+            "status": "fail",
+            "reason": "TestQL exit code 1",
+        })
+
+    All public methods are coroutines and never raise — they swallow
+    network errors and log them.
+    """
+
+    def __init__(self, cfg: Optional[WebConfig] = None) -> None:
+        self.cfg = cfg or WebConfig()
+        self.endpoint = resolve_endpoint(self.cfg)
+
+    @property
+    def is_active(self) -> bool:
+        return bool(self.cfg.enabled and self.endpoint and _httpx_available())
+
+    def _headers(self) -> Dict[str, str]:
+        h = {"Content-Type": "application/json", "User-Agent": "wup-web-client"}
+        if self.cfg.api_key:
+            h["Authorization"] = f"Bearer {self.cfg.api_key}"
+        return h
+
+    async def send_event(self, event: Dict[str, Any]) -> bool:
+        """
+        POST a single event to `<endpoint>/events`.
+
+        Returns True on 2xx, False otherwise (including disabled / no httpx).
+        Never raises.
+        """
+        if not self.is_active:
+            return False
+
+        payload = _normalize(event)
+        payload.setdefault("timestamp", int(time.time()))
+
+        url = f"{self.endpoint}/events"
+        try:
+            import httpx
+            async with httpx.AsyncClient(timeout=self.cfg.timeout_s) as client:
+                resp = await client.post(url, json=payload, headers=self._headers())
+                if 200 <= resp.status_code < 300:
+                    return True
+                _console.print(
+                    f"[yellow]wup.web_client: {url} → HTTP {resp.status_code}[/yellow]"
+                )
+                return False
+        except Exception as exc:  # noqa: BLE001 — soft-fail by design
+            _console.print(f"[yellow]wup.web_client: send_event failed ({exc})[/yellow]")
+            return False
+
+    async def send_regression(
+        self,
+        service: str,
+        file: str,
+        endpoint: str,
+        reason: str,
+        stage: str = "quick",
+    ) -> bool:
+        return await self.send_event({
+            "type": "REGRESSION",
+            "service": service,
+            "file": file,
+            "endpoint": endpoint,
+            "status": "fail",
+            "stage": stage,
+            "reason": reason,
+        })
+
+    async def send_pass(self, service: str, stage: str = "quick") -> bool:
+        return await self.send_event({
+            "type": "PASS",
+            "service": service,
+            "stage": stage,
+            "status": "ok",
+        })
+
+    async def send_health_transition(
+        self,
+        service: str,
+        from_status: str,
+        to_status: str,
+    ) -> bool:
+        return await self.send_event({
+            "type": "HEALTH_TRANSITION",
+            "service": service,
+            "from": from_status,
+            "to": to_status,
+        })
+
+    async def send_visual_diff(
+        self,
+        service: str,
+        url: str,
+        diff: Dict[str, Any],
+    ) -> bool:
+        return await self.send_event({
+            "type": "VISUAL_DIFF",
+            "service": service,
+            "url": url,
+            "diff": diff,
+        })

wup-0.2.16/wup-web/tests/conftest.py

@@ -0,0 +1,23 @@
+"""Shared fixtures for wup-web tests."""
+
+from __future__ import annotations
+
+import pytest
+from fastapi.testclient import TestClient
+
+from wup_web.main import create_app
+from wup_web.storage import EventStore, set_default_store
+
+
+@pytest.fixture
+def fresh_store():
+    store = EventStore(jsonl_path=None, capacity=100)
+    set_default_store(store)
+    yield store
+    set_default_store(EventStore(jsonl_path=None))
+
+
+@pytest.fixture
+def client(fresh_store) -> TestClient:
+    app = create_app()
+    return TestClient(app)