diff --git a/Dockerfile_test_app b/Dockerfile_test_app index f1bf22f..a4bfb6b 100644 --- a/Dockerfile_test_app +++ b/Dockerfile_test_app @@ -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 ''; \ echo ''; \ @@ -21,11 +17,9 @@ RUN set -eux; \ echo '

Nginx Is Running

'; \ echo '

Custom landing page for the Brencher test app container.

'; \ echo '

Port: 5001

'; \ - echo "

Git revision: ${GIT_REVISION}

"; \ + echo '

Git revision: unknown

'; \ echo ''; \ echo ''; \ - } > /usr/share/nginx/html/index.html; \ - rm -rf /tmp/repo/.git; \ - apk del .git-deps + } > /usr/share/nginx/html/index.html EXPOSE 5001 diff --git a/backend/app.py b/backend/app.py index 63cc7ba..4a82e09 100644 --- a/backend/app.py +++ b/backend/app.py @@ -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:] diff --git a/backend/web.py b/backend/web.py index 7409b79..79ad556 100644 --- a/backend/web.py +++ b/backend/web.py @@ -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 diff --git a/tests/configs/nginx.py b/tests/configs/nginx.py index 095b9b8..75d1bab 100644 --- a/tests/configs/nginx.py +++ b/tests/configs/nginx.py @@ -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( diff --git a/tests/test_app_asyncio.py b/tests/test_app_asyncio.py new file mode 100644 index 0000000..1fe7e26 --- /dev/null +++ b/tests/test_app_asyncio.py @@ -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 diff --git a/tests/test_containertest.py b/tests/test_containertest.py index 665627f..5fe5279 100644 --- a/tests/test_containertest.py +++ b/tests/test_containertest.py @@ -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 # { diff --git a/tests/test_dry_run_playwright.py b/tests/test_dry_run_playwright.py index 9527c8a..ecf9339 100644 --- a/tests/test_dry_run_playwright.py +++ b/tests/test_dry_run_playwright.py @@ -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") diff --git a/tests/test_web_ws_lock.py b/tests/test_web_ws_lock.py new file mode 100644 index 0000000..6700afc --- /dev/null +++ b/tests/test_web_ws_lock.py @@ -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: + +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)