test(brencher): harden nginx test config + playwright container-running assertion #42

Open
hermes wants to merge 8 commits from hermes/brencher:copilot/refactor-use-asyncio-taskgroup into main_corrupted
8 changed files with 477 additions and 125 deletions
+3 -9
View File
@@ -1,14 +1,10 @@
FROM nginx:1.27-alpine
COPY .git /tmp/repo/.git
# Configure nginx to listen on 5001 to match container port expectations.
RUN sed -i 's/listen 80;/listen 5001;/' /etc/nginx/conf.d/default.conf
# Build a custom landing page directly in the image and inject git revision.
# Build a custom landing page directly in the image.
RUN set -eux; \
apk add --no-cache --virtual .git-deps git; \
GIT_REVISION="$(git --git-dir=/tmp/repo/.git rev-parse --short HEAD 2>/dev/null || echo unknown)"; \
{ \
echo '<!doctype html>'; \
echo '<html lang="en">'; \
@@ -21,11 +17,9 @@ RUN set -eux; \
echo ' <h1>Nginx Is Running</h1>'; \
echo ' <p>Custom landing page for the Brencher test app container.</p>'; \
echo ' <p>Port: 5001</p>'; \
echo " <p>Git revision: ${GIT_REVISION}</p>"; \
echo ' <p>Git revision: unknown</p>'; \
echo '</body>'; \
echo '</html>'; \
} > /usr/share/nginx/html/index.html; \
rm -rf /tmp/repo/.git; \
apk del .git-deps
} > /usr/share/nginx/html/index.html
EXPOSE 5001
+72 -21
View File
@@ -1,8 +1,8 @@
import asyncio
import logging
import os
import signal
import sys
import threading
import traceback
from typing import Any, Callable, Dict, List, Optional
@@ -27,9 +27,12 @@ class App:
def __init__(self, environments: Dict[str, Environment]) -> None:
self.environments: Dict[str, Environment] = {id: wrap_in_cached(e) for id, e in environments.items()}
self.state_lock = threading.Lock()
self.environment_update_event = threading.Event()
self.environment_update_event = asyncio.Event()
self.environment_update_version = 0
self.emit_callback: Optional[Callable[[], None]] = None
self.reset_requested = False
self.shutdown_event = asyncio.Event()
self.web_app: Any = None
def get_local_envs_to_emit(self) -> Dict[str, Dict[str, Any]]:
env_dtos: Dict[str, Dict[str, Any]] = {}
@@ -88,35 +91,83 @@ class App:
return branches
def processing_thread(self) -> None:
while True:
async def processing_loop(self) -> None:
while not self.shutdown_event.is_set():
import processing
emit = self.emit_callback or (lambda: None)
update_version = self.environment_update_version
with self.state_lock:
logger.info(f"Processing")
if processing.process_all_jobs(list(self.environments.values()), emit):
self.environment_update_event.wait(timeout=1 * 5)
else:
self.environment_update_event.wait(timeout=1 * 60)
self.environment_update_event.clear()
logger.info("Processing")
if self.reset_requested:
await asyncio.to_thread(processing.reset_caches, list(self.environments.values()))
self.reset_requested = False
has_error = await asyncio.to_thread(processing.process_all_jobs, list(self.environments.values()), emit)
if self.shutdown_event.is_set():
return
# Skip the wait when a newer update arrived while the current processing pass was running.
if self.environment_update_version != update_version:
continue
timeout = 5 if has_error else 60
try:
await asyncio.wait_for(self.environment_update_event.wait(), timeout=timeout)
except asyncio.TimeoutError:
pass
self.environment_update_event.clear()
def run(self) -> None:
processing = threading.Thread(target=self.processing_thread)
processing.daemon = True
processing.start()
def notify_environment_update(self) -> None:
self.environment_update_version += 1
self.environment_update_event.set()
def request_reset(self) -> None:
self.reset_requested = True
def stop(self) -> None:
self.shutdown_event.set()
self.notify_environment_update()
if self.web_app is not None:
self.web_app.stop()
async def runAsync(self) -> None:
await self.processing_loop()
async def runHeadlessAsync(self) -> None:
await self.processing_loop()
def runHeadless(self) -> None:
"""Run the processing loop on the current thread; blocks forever."""
self.processing_thread()
"""Run the processing loop until cancelled; blocks forever."""
asyncio.run(self.runHeadlessAsync())
def runWeb(self, port: int) -> None:
async def _run_web_server(self, web_app: Any) -> None:
"""Raise a sentinel exception when the server stops so TaskGroup cancels processing."""
await web_app.start_async()
raise _WebServerStopped()
async def runWebAsync(self, port: int) -> None:
import web
web_app = web.WebApp(core=self, port=port)
self.web_app = web_app
self.emit_callback = web_app.emit_envs
self.run()
web_app.start()
try:
# Keep processing and web serving coupled so shutdown or fatal failure tears down the whole app.
async with asyncio.TaskGroup() as task_group:
task_group.create_task(self.processing_loop())
task_group.create_task(self._run_web_server(web_app))
except* _WebServerStopped:
pass
finally:
self.emit_callback = None
self.web_app = None
def runWeb(self, port: int) -> None:
asyncio.run(self.runWebAsync(port))
def run(self) -> None:
asyncio.run(self.runAsync())
class _WebServerStopped(Exception):
pass
if __name__ == '__main__':
cli_env_ids_list = sys.argv[1:]
+68 -33
View File
@@ -10,12 +10,10 @@ from fastapi import FastAPI, Response, WebSocket, WebSocketDisconnect
from fastapi.middleware.cors import CORSMiddleware
from fastapi.responses import FileResponse
from app import App
from enironment import SharedStateConflictError, get_step
from app import App
from utils import custom_json_dumps
from processing import reset_caches
from secondary import SecondaryManager
from steps.step import CachingStep
logger = logging.getLogger(__name__)
@@ -47,12 +45,14 @@ class WebApp:
self.port = port
self.ws_connections: Dict[WebSocket, Dict[str, Any]] = {}
self.ws_lock = asyncio.Lock()
self._event_loop: Optional[asyncio.AbstractEventLoop] = None
self._server: Any = None
self.secondaryManager: Optional[SecondaryManager] = None
@asynccontextmanager
async def lifespan(fastapi_app: FastAPI) -> AsyncIterator[None]:
self._event_loop = asyncio.get_event_loop()
self._event_loop = asyncio.get_running_loop()
self.secondaryManager = SecondaryManager(
urls=os.getenv("SECONDARY_BRENCHER", ""),
on_update=lambda: self.broadcast_all(),
@@ -94,10 +94,20 @@ class WebApp:
merged = _merge_dicts(merged, connector.branches)
return merged
# --- Async scheduling from sync threads ---
# --- Async scheduling from sync callbacks ---
def _schedule_async(self, coro: Any) -> None:
if self._event_loop is not None and self._event_loop.is_running():
if self._event_loop is None or not self._event_loop.is_running():
logger.warning("Dropping scheduled coroutine because the web event loop is not running")
coro.close()
return
try:
running_loop = asyncio.get_running_loop()
except RuntimeError:
running_loop = None
if running_loop is self._event_loop:
self._event_loop.create_task(coro)
else:
asyncio.run_coroutine_threadsafe(coro, self._event_loop)
# --- Broadcasting ---
@@ -107,18 +117,19 @@ class WebApp:
disconnected = set()
message = custom_json_dumps({event: data})
for websocket in self.ws_connections.keys():
if self.ws_connections[websocket].get(event) == message:
continue
try:
await websocket.send_text(message)
self.ws_connections[websocket][event] = message
except Exception as e:
logger.error(f"Error sending to websocket: {e}")
disconnected.add(websocket)
async with self.ws_lock:
for websocket in list(self.ws_connections.keys()):
if self.ws_connections[websocket].get(event) == message:
continue
try:
await websocket.send_text(message)
self.ws_connections[websocket][event] = message
except Exception as e:
logger.error(f"Error sending to websocket: {e}")
disconnected.add(websocket)
for ws in disconnected:
self.ws_connections.pop(ws, None)
for ws in disconnected:
self.ws_connections.pop(ws, None)
async def broadcast_all(self) -> None:
await self.broadcast("branches", self.get_global_branches_to_emit())
@@ -135,7 +146,7 @@ class WebApp:
await self.broadcast("error", data)
def emit_envs(self) -> None:
"""Sync callback used by App's processing thread to push updates to clients."""
"""Sync callback used by App's processing loop to push updates to clients."""
self._schedule_async(self.broadcast_branches(self.get_global_branches_to_emit()))
self._schedule_async(self.broadcast_environments(self.get_global_envs_to_emit()))
@@ -163,18 +174,26 @@ class WebApp:
async def websocket_endpoint(self, websocket: WebSocket) -> None:
await websocket.accept()
self.ws_connections[websocket] = {}
# Compute payloads first so the dict registration below is a single
# atomic update under ws_lock — avoids the window where the key
# exists but the inner dict is empty, which races with broadcast()
# cleanup and crashes with KeyError at self.ws_connections[ws][...] = ...
branches_payload = custom_json_dumps({"branches": self.get_global_branches_to_emit()})
envs_payload = custom_json_dumps({"environments": self.get_global_envs_to_emit()})
version_payload = custom_json_dumps({"version": self.get_version()})
async with self.ws_lock:
self.ws_connections[websocket] = {
"version": version_payload,
"branches": branches_payload,
"environments": envs_payload,
}
try:
# Send initial state on connect and record it so duplicate broadcasts are suppressed
branches_payload = custom_json_dumps({"branches": self.get_global_branches_to_emit()})
envs_payload = custom_json_dumps({"environments": self.get_global_envs_to_emit()})
version_payload = custom_json_dumps({"version": self.get_version()})
await websocket.send_text(version_payload)
await websocket.send_text(branches_payload)
self.ws_connections[websocket]["branches"] = branches_payload
await websocket.send_text(envs_payload)
self.ws_connections[websocket]["environments"] = envs_payload
while True:
data = await websocket.receive_text()
@@ -187,7 +206,7 @@ class WebApp:
await self.secondaryManager.send({"update": update_data})
id = update_data.get('id', '')
if id == '':
reset_caches(list(self.core.environments.values()))
self.core.request_reset()
elif id not in self.core.environments.keys() and id not in {j for it in self.secondaryManager or [] for j in it.environments.keys()}:
logger.warning(f"Received update for unknown environment id {id}")
continue
@@ -218,22 +237,38 @@ class WebApp:
continue
if env:
p = get_step(env.pipeline, type(env.state))
if isinstance(p, CachingStep):
p.reset()
self.core.request_reset()
logger.info(f"Updated environment {env.id} branches to {update_data.get('branches')}, dry={update_data.get('dry')}")
self.core.environment_update_event.set()
self.core.notify_environment_update()
await self.broadcast_environments(self.get_global_envs_to_emit())
except WebSocketDisconnect:
self.ws_connections.pop(websocket, None)
async with self.ws_lock:
self.ws_connections.pop(websocket, None)
except Exception as e:
logger.error(f"WebSocket error: {e}:{traceback.format_exc()}")
await self.broadcast_error({'message': f'{e}:{traceback.format_exc()}'})
# --- Run ---
def start(self) -> None:
async def start_async(self) -> None:
import uvicorn
uvicorn.run(self.app, host='0.0.0.0', port=self.port, log_level='info')
config = uvicorn.Config(self.app, host='0.0.0.0', port=self.port, log_level='info')
self._server = uvicorn.Server(config)
try:
await self._server.serve()
except asyncio.CancelledError:
self._server.should_exit = True
raise
def start(self) -> None:
asyncio.run(self.start_async())
def stop(self) -> None:
if self._server is None:
return
if self._event_loop is not None and self._event_loop.is_running():
self._event_loop.call_soon_threadsafe(lambda: setattr(self._server, "should_exit", True))
else:
self._server.should_exit = True
+20
View File
@@ -1,8 +1,28 @@
import subprocess
from pathlib import Path
from enironment import Environment
from steps.docker_plain import DockerImageBuild, DockerContainerCheck, DockerContainerDeploy
from steps.git import GitClone, CheckoutMerged, GitUnmerge
from steps.shared_state import SharedStateHolderInMemory
REPO_ROOT = Path(__file__).resolve().parents[2]
def _git_output(*args: str) -> str:
try:
return subprocess.check_output(
["git", "-C", str(REPO_ROOT), *args],
text=True,
stderr=subprocess.STDOUT,
).strip()
except subprocess.CalledProcessError as exc:
raise RuntimeError(f"Unable to read git metadata for nginx test config: {' '.join(args)}\n{exc.output}") from exc
CURRENT_BRANCH = _git_output("rev-parse", "--abbrev-ref", "HEAD")
CURRENT_COMMIT = _git_output("rev-parse", "HEAD")
clone = GitClone(url="https://github.com/rudolf1/brencher.git")
container_check = DockerContainerCheck(
+52
View File
@@ -0,0 +1,52 @@
import asyncio
import sys
import types
from typing import Callable
import pytest
from enironment import Environment
import processing
from app import App
class TestAppAsyncio:
@pytest.mark.asyncio
async def test_run_web_async_stops_processing_when_server_exits(self, monkeypatch: pytest.MonkeyPatch) -> None:
process_calls = 0
emit_calls = 0
processing_started = asyncio.Event()
loop = asyncio.get_running_loop()
web_app_args: dict[str, object] = {}
def fake_process_all_jobs(environments: list[Environment], onupdate: Callable[[], None]) -> bool:
nonlocal process_calls
process_calls += 1
assert environments == []
onupdate()
loop.call_soon_threadsafe(processing_started.set)
return False
class FakeWebApp:
def __init__(self, core: App, port: int) -> None:
web_app_args["core"] = core
web_app_args["port"] = port
def emit_envs(self) -> None:
nonlocal emit_calls
emit_calls += 1
async def start_async(self) -> None:
await asyncio.wait_for(processing_started.wait(), timeout=1)
monkeypatch.setattr(processing, "process_all_jobs", fake_process_all_jobs)
monkeypatch.setitem(sys.modules, "web", types.SimpleNamespace(WebApp=FakeWebApp))
app = App({})
await asyncio.wait_for(app.runWebAsync(5001), timeout=1)
assert process_calls >= 1
assert emit_calls >= 1
assert web_app_args == {"core": app, "port": 5001}
assert app.emit_callback is None
+21 -21
View File
@@ -1,7 +1,7 @@
import asyncio
import json
import logging
import threading
from contextlib import suppress
from typing import Any, Generator
import docker
@@ -36,30 +36,30 @@ class TestDockerContainer:
logger.info(f"Starting")
app = App({"brencher_local1": brencher_local1.brencher_local1})
# app.runWeb(5001)
processing = threading.Thread(target=lambda: app.runWeb(5001), daemon=True)
processing.start()
processing = asyncio.create_task(app.runWebAsync(5001))
try:
eventually(
lambda: assert_equal(requests.get("http://localhost:5001/state", timeout=5000).status_code, 200, "Server did not respond with 200 OK within timeout"),
20.0,
1.0,
)
# await asyncio.sleep(5000)
state_data = requests.get("http://localhost:5001/state", timeout=5000).json()
logger.info(f"Application state: {json.dumps(state_data, indent=2)}")
eventually(
lambda: assert_equal(requests.get("http://localhost:5001/state", timeout=5000).status_code, 200, "Server did not respond with 200 OK within timeout"),
20.0,
1.0,
)
branches_data = requests.get("http://localhost:5001/branches", timeout=5000).json()
logger.info(f"Application branches: {json.dumps(branches_data, indent=2)}")
assert "brencher_local1" in state_data, "Missing 'brencher_local1' field in response"
assert len(state_data["brencher_local1"]["pipeline"]) > 0, "Steps defined for 'brencher_local1' are empty"
state_data = requests.get("http://localhost:5001/state", timeout=5000).json()
logger.info(f"Application state: {json.dumps(state_data, indent=2)}")
branches_data = requests.get("http://localhost:5001/branches", timeout=5000).json()
logger.info(f"Application branches: {json.dumps(branches_data, indent=2)}")
assert "brencher_local1" in state_data, "Missing 'brencher_local1' field in response"
assert len(state_data["brencher_local1"]["pipeline"]) > 0, "Steps defined for 'brencher_local1' are empty"
assert "brencher_local1" in branches_data, "Missing 'brencher_local1' field in response"
assert len(branches_data["brencher_local1"]) > 0, "No branches found for 'brencher_local1'"
assert "brencher_local1" in branches_data, "Missing 'brencher_local1' field in response"
assert len(branches_data["brencher_local1"]) > 0, "No branches found for 'brencher_local1'"
finally:
processing.cancel()
with suppress(asyncio.CancelledError):
await processing
assert processing.cancelled()
# TODO Verify DockerContainerDeploy step status is running and has correct image and ports
# {
+53 -41
View File
@@ -78,55 +78,67 @@ class TestDryRunPlaywright:
# Start app with nginx_local1 with main branch pre-selected and dry mode on.
env = nginx.test_local1
env.state.set_branches([("test/main", "HEAD")])
env.state.set_branches([(nginx.CURRENT_BRANCH, nginx.CURRENT_COMMIT)])
env.state.set_dry(True)
app = App({env.id: env})
_server_thread = threading.Thread(target=lambda: app.runWeb(APP_PORT), daemon=True)
_server_thread.start()
try:
# Wait for server to be up
eventually(lambda: assert_equal(requests.get(f"{APP_URL}/state", timeout=5).status_code, 200, "Server did not respond with 200 OK within timeout"))
logger.info("Server is up")
# Wait for server to be up
eventually(lambda: assert_equal(requests.get(f"{APP_URL}/state", timeout=5).status_code, 200, "Server did not respond with 200 OK within timeout"))
logger.info("Server is up")
# Wait for the pipeline to stabilize with dry=True:
# DockerContainerDeploy should return status="dry-run"
with brencher_page(APP_URL, env.id) as page:
eventually(
lambda: check_state(APP_URL, lambda s: assert_equal(next(
p for p in s[env.id]["pipeline"] if p["name"] == "SharedStateHolderInMemory"
)["status"]['dry'], True, "Pipeline step status is not 'running'")),
)
# Wait for the pipeline to stabilize with dry=True:
# DockerContainerDeploy should return status="dry-run"
with brencher_page(APP_URL, env.id) as page:
eventually(
lambda: check_state(APP_URL, lambda s: assert_equal(next(
p for p in s[env.id]["pipeline"] if p["name"] == "SharedStateHolderInMemory"
)["status"]['dry'], True, "Pipeline step status is not 'running'")),
)
# page.verify_pipeline_step_status("DockerContainerDeploy", "dry-run")
logger.info("Pipeline is in dry-run mode")
# page.verify_pipeline_step_status("DockerContainerDeploy", "dry-run")
logger.info("Pipeline is in dry-run mode")
# Verify no real container was created
docker_client = docker.from_env()
real_containers = docker_client.containers.list(filters={"name": CONTAINER_NAME}, all=True)
assert len(real_containers) == 0, "Container should NOT exist during dry run"
# Verify no real container was created
docker_client = docker.from_env()
real_containers = docker_client.containers.list(filters={"name": CONTAINER_NAME}, all=True)
assert len(real_containers) == 0, "Container should NOT exist during dry run"
# Disable dry run from the UI.
page.verify_dry_run_on()
page.set_dry_run_off()
page.verify_dry_run_off()
# Disable dry run from the UI.
page.verify_dry_run_on()
page.set_dry_run_off()
page.verify_dry_run_off()
page.click_refresh() # TODO Remove it
# Wait for pipeline to re-run and actually deploy the container
eventually(
lambda: check_state(APP_URL, lambda s: assert_equal(next(
p for p in s[env.id]["pipeline"] if p["name"] =="SharedStateHolderInMemory"
)["status"]['dry'], False, "Pipeline step status is not 'running'")),
)
# Wait for pipeline to re-run and actually deploy the container
eventually(
lambda: check_state(APP_URL, lambda s: assert_equal(next(
p for p in s[env.id]["pipeline"] if p["name"] =="SharedStateHolderInMemory"
)["status"]['dry'], False, "Pipeline step status is not 'running'")),
)
# Wait for pipeline to re-run and actually deploy the container
eventually(
lambda: check_state(APP_URL, lambda s: assert_equal({p["name"] for p in s[env.id]["pipeline"] if bool(p['is_running'])}, set(), "Pipeline still running")),
timeout=20,
interval=1.0,
)
# page.verify_pipeline_step_status("DockerContainerDeploy", "running")
logger.info("Container deployed and running after dry run disabled")
# Wait for the real container to be created and started.
eventually(
lambda: _assert_container_running(docker_client),
# Allow time for a cold image build and first container start on CI runners.
timeout=180,
interval=5.0,
)
# page.verify_pipeline_step_status("DockerContainerDeploy", "running")
logger.info("Container deployed and running after dry run disabled")
# Final sanity: real container must exist and be running
containers = docker_client.containers.list(filters={"name": CONTAINER_NAME})
assert len(containers) == 1, "Container should exist and be running after deploy"
assert containers[0].status == "running"
# Final sanity: real container must exist and be running
containers = docker_client.containers.list(filters={"name": CONTAINER_NAME})
assert len(containers) == 1, "Container should exist and be running after deploy"
assert containers[0].status == "running"
finally:
app.stop()
server_thread.join(timeout=30)
if server_thread.is_alive():
logger.warning("App server thread did not stop within 30 seconds")
def _assert_container_running(docker_client: docker.DockerClient) -> None:
containers = docker_client.containers.list(filters={"name": CONTAINER_NAME}, all=True)
assert len(containers) > 0, "Container should exist after deploy"
assert_equal({container.status for container in containers}, {"running"}, "Container should be running after deploy")
+188
View File
@@ -0,0 +1,188 @@
"""
Regression tests for the WebSocket ws_connections race fixed in PR #42.
Background
----------
Before the fix, ``WebApp.ws_connections`` (a Dict[WebSocket, Dict[str, Any]])
was modified from two uncoordinated coroutines: ``websocket_endpoint`` and
``broadcast()``. Adding the key, then awaiting ``send_text``, then assigning
``self.ws_connections[websocket]["branches"] = ...`` left a window where the
key existed but the inner dict was empty. A concurrent ``broadcast()`` loop
could ``pop(ws)`` the same key, and the next assignment crashed with::
File "/app/backend/web.py", line 184, in websocket_endpoint
self.ws_connections[websocket]["branches"] = branches_payload
~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^
KeyError: <starlette.websockets.WebSocket object at 0x...>
The fix serialises every mutation of ``ws_connections`` under an
``asyncio.Lock`` and registers the websocket with all three payloads in a
single atomic assignment before the first ``send_text`` await.
These tests verify the lock contract on a real ``WebApp`` instance with
fake websocket objects that simulate the production timing.
"""
import asyncio
import sys
from typing import Any, Dict, List
import pytest
# Match the project's import layout: backend modules are at top level.
sys.path.insert(0, "backend")
from web import WebApp
class FakeWebSocket:
"""Minimal stand-in for starlette.websockets.WebSocket.
- ``send_delay`` lets us widen the race window between accept and dict
writes, mimicking slow clients.
- ``receive_text`` raises ``WebSocketDisconnect`` so the endpoint exits
cleanly after one round-trip.
"""
def __init__(self, send_delay: float = 0.0) -> None:
self.sent: List[str] = []
self.accepted = False
self.send_delay = send_delay
async def accept(self) -> None:
self.accepted = True
async def send_text(self, message: str) -> None:
if self.send_delay:
await asyncio.sleep(self.send_delay)
self.sent.append(message)
async def receive_text(self) -> str:
from starlette.websockets import WebSocketDisconnect
raise WebSocketDisconnect()
class FakeCore:
"""Minimal stand-in for ``app.App`` — only the methods WebApp touches."""
def __init__(self) -> None:
self.local_envs: Dict[str, Any] = {}
def get_local_envs_to_emit(self) -> Dict[str, Any]:
return self.local_envs
def get_local_branches_to_emit(self) -> Dict[str, Any]:
return {}
def _make_web_app() -> WebApp:
return WebApp(core=FakeCore(), port=0) # type: ignore[arg-type]
@pytest.mark.asyncio
async def test_websocket_endpoint_registers_atomically_under_lock() -> None:
"""websocket_endpoint must register the ws with all three payloads in a
single dict assignment under ``ws_lock``, BEFORE any ``send_text``.
The lock and the atomic dict write are the contract; if either is
missing, this test fails with KeyError or with the dict missing keys.
"""
web_app = _make_web_app()
ws = FakeWebSocket(send_delay=0.01) # widen the race window
async def concurrent_broadcast() -> None:
# Try to interleave several broadcasts while the endpoint is
# awaiting send_text. Pre-fix, this would race with the dict
# updates and either crash or drop the connection.
for _ in range(5):
await asyncio.sleep(0.005)
await web_app.broadcast("branches", {"x": 1})
task = asyncio.create_task(concurrent_broadcast())
await web_app.websocket_endpoint(ws) # type: ignore[arg-type]
await task
# Endpoint must have accepted the connection
assert ws.accepted
# Three initial send_text calls (version, branches, environments)
assert len(ws.sent) >= 3
# After endpoint exits cleanly (WebSocketDisconnect), the entry is gone
assert ws not in web_app.ws_connections
@pytest.mark.asyncio
async def test_broadcast_and_concurrent_register_dont_crash() -> None:
"""``broadcast()`` and a concurrent ``websocket_endpoint`` registration
must serialise cleanly under the lock. Pre-fix this could raise
``RuntimeError: dictionary changed size during iteration`` or
``KeyError`` when the outer key was popped between accept and write.
"""
web_app = _make_web_app()
n = 20
sockets = [FakeWebSocket(send_delay=0.002) for _ in range(n)]
async def register(s: FakeWebSocket) -> None:
await web_app.websocket_endpoint(s) # type: ignore[arg-type]
async def broadcaster() -> None:
for _ in range(10):
await web_app.broadcast("environments", {"k": "v"})
await asyncio.sleep(0)
# All endpoints + broadcasts run concurrently. Pre-fix this would crash
# with KeyError or RuntimeError on most runs.
await asyncio.gather(
*(register(s) for s in sockets),
broadcaster(),
)
# All endpoints should have cleaned up after themselves.
async with web_app.ws_lock:
leftover = list(web_app.ws_connections.keys())
assert leftover == [], f"expected ws_connections to drain, got {leftover}"
@pytest.mark.asyncio
async def test_ws_lock_exists_and_is_asyncio_lock() -> None:
"""Sanity check on the lock attribute — guards against accidental
removal in future refactors.
"""
import asyncio as _asyncio
web_app = _make_web_app()
assert isinstance(web_app.ws_lock, _asyncio.Lock)
@pytest.mark.asyncio
async def test_broadcast_skips_already_sent_payload() -> None:
"""broadcast() must not re-send a payload it has already sent to a
connection (used for de-dup). This is the second contract of the
function (the first being serialised mutation); ensure the lock didn't
break the de-dup check.
"""
from web import custom_json_dumps
web_app = _make_web_app()
ws = FakeWebSocket()
# Pre-register a websocket with the EXACT JSON payload that broadcast()
# will produce. ``broadcast(event, data)`` JSON-encodes
# ``{event: data}`` into the message and compares against the stored
# value, so we need to mirror that here.
payload = {"branches": "msg-1"}
web_app.ws_connections[ws] = {"branches": custom_json_dumps(payload)}
# Two broadcasts with the same payload — second one must be de-duped
# against the stored value (the de-dup check on line 120:
# ``if self.ws_connections[websocket].get(event) == message: continue``).
await web_app.broadcast("branches", payload)
# After the first call, the de-dup is in place — a second identical
# broadcast must not reach send_text.
sent_before = len(ws.sent)
await web_app.broadcast("branches", payload)
assert len(ws.sent) == sent_before, (
f"de-dup broken: second broadcast sent {len(ws.sent) - sent_before} extra message(s)"
)
# Cleanup
async with web_app.ws_lock:
web_app.ws_connections.pop(ws, None)