diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 38c0556..0993448 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -38,6 +38,16 @@ jobs: backend: name: Backend linting & testing runs-on: ubuntu-latest + services: + redis: + image: redis:7-alpine + ports: + - 6379:6379 + options: >- + --health-cmd "redis-cli ping" + --health-interval 10s + --health-timeout 5s + --health-retries 5 defaults: run: working-directory: backend @@ -56,6 +66,8 @@ jobs: - name: lint code run: uv run --active ruff check . - name: run tests + env: + REDIS_TEST_URL: redis://localhost:6379/15 run: | mkdir -p ../coverage uv run pytest --cov=app --cov-report=term-missing --cov-report=xml:../coverage/backend-coverage.xml diff --git a/backend/.env.example b/backend/.env.example index d5b0f66..77dfe4a 100644 --- a/backend/.env.example +++ b/backend/.env.example @@ -1,5 +1,8 @@ SUPABASE_URL=http://127.0.0.1:54321 DATABASE_URL=postgresql+asyncpg://postgres:postgres@127.0.0.1:54322/postgres ENVIRONMENT=development +LOG_LEVEL=INFO CORS_ORIGINS=https://app.example.com,https://admin.example.com -REDIS_URL=redis://127.0.0.1:6379 \ No newline at end of file +REDIS_URL=redis://127.0.0.1:6379 +# regis test url, keep as is for local testing +REDIS_TEST_URL=redis://localhost:6379/15 diff --git a/backend/app/core/config.py b/backend/app/core/config.py index 90d2b60..a743062 100644 --- a/backend/app/core/config.py +++ b/backend/app/core/config.py @@ -8,6 +8,7 @@ class Settings(BaseSettings): # app name APP_NAME: str = "WebMUN API" ENVIRONMENT: str = "development" + LOG_LEVEL: str = "INFO" # list of origins by separated commas (e.g., "app.com,app.xyz") CORS_ORIGINS: str = "" diff --git a/backend/app/core/dep.py b/backend/app/core/dep.py index 90daf10..94dcd0c 100644 --- a/backend/app/core/dep.py +++ b/backend/app/core/dep.py @@ -17,8 +17,8 @@ def get_session_engine(connection: HTTPConnection) -> SessionEngine: return connection.app.state.session_engine -def get_logger() -> logging.Logger: - return logging.getLogger("uvicorn.error") +def get_logger(connection: HTTPConnection) -> logging.Logger: + return connection.app.state.logger def get_session_store(connection: HTTPConnection) -> Redis: diff --git a/backend/app/core/logging.py b/backend/app/core/logging.py new file mode 100644 index 0000000..d0fe084 --- /dev/null +++ b/backend/app/core/logging.py @@ -0,0 +1,17 @@ +import logging + + +def configure_logging(level: str) -> logging.Logger: + """Configure the application logger once during startup.""" + logger = logging.getLogger("webmun") + logger.setLevel(level.upper()) + logger.propagate = False + + if not logger.handlers: + handler = logging.StreamHandler() + handler.setFormatter( + logging.Formatter("%(asctime)s %(levelname)s %(name)s: %(message)s") + ) + logger.addHandler(handler) + + return logger diff --git a/backend/app/main.py b/backend/app/main.py index 36c2daf..e6e6a3b 100644 --- a/backend/app/main.py +++ b/backend/app/main.py @@ -1,4 +1,5 @@ -from contextlib import asynccontextmanager +import asyncio +from contextlib import asynccontextmanager, suppress import redis.asyncio as redis from fastapi import FastAPI, Request @@ -10,9 +11,11 @@ from app.core.config import get_settings from app.core.database import create_db from app.core.exceptions import AppException +from app.core.logging import configure_logging from app.core.openapi import add_websocket_message_schemas from app.session.engine import SessionEngine from app.session.manager import ConnectionManager +from app.session.store import subscriber_worker from app.session.views import router as session_router settings = get_settings() @@ -21,6 +24,8 @@ @asynccontextmanager async def lifespan(app: FastAPI): # startup phase + logger = configure_logging(settings.LOG_LEVEL) + app.state.logger = logger engine, session_factory = create_db(settings) app.state.db_engine = engine app.state.db_session_factory = session_factory @@ -28,14 +33,32 @@ async def lifespan(app: FastAPI): app.state.session_engine = SessionEngine() app.state.connection_manager = ConnectionManager() - app.state.redis = redis.from_url( + redis_client = redis.from_url( settings.REDIS_URL.get_secret_value(), ) + await redis_client.ping() + + app.state.redis = redis_client + logger.info("Connected to Redis") + task = asyncio.create_task( + subscriber_worker( + client=redis_client, + connection_manager=app.state.connection_manager, + logger=logger, + ) + ) + + try: + yield - yield + finally: + task.cancel() + with suppress(asyncio.CancelledError): + await task - await app.state.redis.close() - await engine.dispose() + await app.state.redis.aclose() + await engine.dispose() + logger.info("Application shutdown complete") app = FastAPI( diff --git a/backend/app/session/manager.py b/backend/app/session/manager.py index 5e5482b..aac075d 100644 --- a/backend/app/session/manager.py +++ b/backend/app/session/manager.py @@ -35,7 +35,7 @@ def count_present_delegations(self, session_id: int) -> int: async def broadcast_message(self, session_id: int, message: ServerSessionMessage): """Sends current state to all clients in the room""" - for connection in self.active_connections[session_id]: + for connection in self.active_connections.get(session_id, {}): await connection.send_json(message.model_dump(mode="json")) async def send_message( diff --git a/backend/app/session/service.py b/backend/app/session/service.py index 3aef21b..cda8ada 100644 --- a/backend/app/session/service.py +++ b/backend/app/session/service.py @@ -26,6 +26,7 @@ from .manager import ConnectionManager from .models import ( DelegationContext, + DispatchOutcome, RollCallContext, SessionActor, SessionLiveState, @@ -58,11 +59,11 @@ async def build_actor( if role == enums.SessionRole.DELEGATE: if delegation_id is None: raise ActorResolutionError("needs delegate id") - state = await store.get_state(session=redis, session_id=session_id) - if state is None: + res = await store.get_outcome(client=redis, session_id=session_id) + if res is None: raise ActorResolutionError("session not found") - delegation = state.delegations.get(delegation_id) + delegation = res.state.delegations.get(delegation_id) if delegation is None: raise ActorResolutionError("delegation not found") @@ -148,9 +149,8 @@ async def activate_session( await session.commit() - await store.save_state(session=redis, state=live_state) - manager.active_connections.setdefault(committee_session_id, {}) + await store.save_outcome(client=redis, result=DispatchOutcome(state=live_state)) async def pause_session( @@ -177,11 +177,11 @@ async def prepare_session_connect( redis: Redis, ) -> SessionActor: """Service that prepares for session connect. - Primarily used as a fallback in case the SessionLiveState is not in manager + Used as a fallback if redis/backend does not have the session_id """ - live_state = await store.get_state(session=redis, session_id=committee_session_id) + res = await store.get_outcome(client=redis, session_id=committee_session_id) - if live_state is None: + if res is None: stored_state = await repository.get_session_info(session, committee_session_id) if stored_state is None: raise SessionFetchError("Could not fetch session info") @@ -194,7 +194,9 @@ async def prepare_session_connect( live_state = SessionLiveState.model_validate(stored_state.state_snapshot) # put SessionLiveState on Cache - live_state = await store.save_state(session=redis, state=live_state) + await store.save_outcome(client=redis, result=DispatchOutcome(state=live_state)) + + if manager.active_connections.get(committee_session_id) is None: manager.active_connections.setdefault(committee_session_id, {}) actor = await build_actor( @@ -216,14 +218,24 @@ async def handle_client_messages( data: schemas.EventMessage, redis: Redis, ): - event = data.event - state = await store.get_state(session=redis, session_id=session_id) - - logger.info(event) # Debugging + lock = redis.lock( + f"webmun:session:{session_id}:lock", + timeout=5, + blocking_timeout=2, + ) - try: - result = engine.dispatch(state, event, actor) - await store.save_state(session=redis, state=state) - return result - except EventRejectedError as exc: - return exc + # Lock for calculating in FSM without another worker overriding + async with lock: + event = data.event + outcome = await store.get_outcome(client=redis, session_id=session_id) + if outcome is None: + raise NotFoundError("Session state has not been found") + + logger.info("Processing %s for session %s", event.type, session_id) + + try: + result = engine.dispatch(outcome.state, event, actor) + await store.save_publish_outcome(client=redis, result=result) + return result + except EventRejectedError as exc: + return exc diff --git a/backend/app/session/store.py b/backend/app/session/store.py index 252363f..9d26741 100644 --- a/backend/app/session/store.py +++ b/backend/app/session/store.py @@ -1,19 +1,73 @@ +import asyncio +import logging + import redis.asyncio as redis -from app.session.models import SessionLiveState +from app.session.manager import ConnectionManager +from app.session.models import DispatchOutcome +from app.session.schemas import DispatchResultMessage + +SESSION_STATE_CHANNEL = "webmun:session:updates" + +def state_key(session_id: int) -> str: + return f"webmun:session:{session_id}" -async def get_state(session: redis.Redis, session_id: int) -> SessionLiveState | None: - res = await session.get(f"webmun:session:{session_id}") + +async def get_outcome(client: redis.Redis, session_id: int) -> DispatchOutcome | None: + """Get the current state for a session""" + res = await client.get(state_key(session_id)) if res is None: return None - return SessionLiveState.model_validate_json(res) + return DispatchOutcome.model_validate_json(res) + + +async def save_outcome(client: redis.Redis, result: DispatchOutcome) -> None: + """Only save outcome in the client cache""" + await client.set(state_key(result.state.session_id), result.model_dump_json()) + + +async def save_publish_outcome(client: redis.Redis, result: DispatchOutcome) -> None: + """Save outcome and publish to the channel""" + serialized_outcome = result.model_dump_json() + async with client.pipeline() as pipe: + pipe.set(state_key(result.state.session_id), serialized_outcome) + pipe.publish(SESSION_STATE_CHANNEL, result.model_dump_json()) + await pipe.execute() + +async def delete_outcome(client: redis.Redis, session_id: int) -> None: + await client.delete(state_key(session_id)) -async def save_state(session: redis.Redis, state: SessionLiveState) -> None: - await session.set(f"webmun:session:{state.session_id}", state.model_dump_json()) +async def subscriber_worker( + client: redis.Redis, + connection_manager: ConnectionManager, + logger: logging.Logger, + ready: asyncio.Event | None = None, +) -> None: + async with client.pubsub() as pubsub: + try: + await pubsub.subscribe(SESSION_STATE_CHANNEL) + logger.info("Subscribed to Redis channel %s", SESSION_STATE_CHANNEL) + if ready is not None: + ready.set() -async def delete_state(session: redis.Redis, session_id: int) -> None: - await session.delete(f"webmun:session:{session_id}") + async for message in pubsub.listen(): + if message and message["type"] == "message": + try: + outcome = DispatchOutcome.model_validate_json(message["data"]) + result = DispatchResultMessage( + state=outcome.state, effect=outcome.effect + ) + await connection_manager.broadcast_message( + session_id=outcome.state.session_id, message=result + ) + except Exception: + logger.exception("Failed to relay Redis session update") + except asyncio.CancelledError: + raise + except Exception: + logger.exception("Redis Pub/Sub worker stopped") + raise diff --git a/backend/app/session/views.py b/backend/app/session/views.py index e63c346..f7fbcdd 100644 --- a/backend/app/session/views.py +++ b/backend/app/session/views.py @@ -38,10 +38,8 @@ from app.session.engine import EventRejectedError, SessionEngine from app.session.enums import EventErrorCode from app.session.manager import ConnectionManager -from app.session.models import DispatchOutcome from app.session.schemas import ( AuthenticateMessage, - DispatchResultMessage, EventMessage, EventRejectedMessage, SessionCreationSchema, @@ -142,15 +140,32 @@ async def websocket_endpoint( redis=redis, ) - # connect, and send state snapshot - state = await store.get_state(session=redis, session_id=session_id) await manager.connect(websocket, session_id, actor) - await manager.send_message( - session_id=session_id, - websocket=websocket, - message=StateSnapshotMessage(state=state), + + # TODO: remove this lock whenever someone connects, since this may add latency + # when FSM is calculating something + # for an MVP, its alright + lock = redis.lock( + f"webmun:session:{session_id}:lock", + timeout=5, + blocking_timeout=2, ) + async with lock: + res = await store.get_outcome(client=redis, session_id=session_id) + if res is None: + manager.disconnect(websocket, session_id) + await websocket.close( + code=status.WS_1011_INTERNAL_ERROR, reason="session_unavailable" + ) + return + + await manager.send_message( + session_id=session_id, + websocket=websocket, + message=StateSnapshotMessage(state=res.state), + ) + try: while True: data = await websocket.receive_json() @@ -173,25 +188,16 @@ async def websocket_endpoint( data=validated_event, redis=redis, ) - match result: - # Either broadcast result outcome, or send error message back to socket - case DispatchOutcome(): - await manager.broadcast_message( - session_id=session_id, - message=DispatchResultMessage( - state=result.state, effect=result.effect - ), - ) - case EventRejectedError(): - await manager.send_message( - session_id=session_id, - message=EventRejectedMessage( - request_id=validated_event.request_id, - code=result.code, - message=str(result), - ), - websocket=websocket, - ) + if isinstance(result, EventRejectedError): + await manager.send_message( + session_id=session_id, + message=EventRejectedMessage( + request_id=validated_event.request_id, + code=result.code, + message=str(result), + ), + websocket=websocket, + ) except WebSocketDisconnect: manager.disconnect(websocket, session_id) diff --git a/backend/app/tests/conftest.py b/backend/app/tests/conftest.py index 8bd68aa..5c6e023 100644 --- a/backend/app/tests/conftest.py +++ b/backend/app/tests/conftest.py @@ -100,6 +100,7 @@ def fake_engine(): class FakeRedis: def __init__(self) -> None: self.values: dict[str, str] = {} + self.published: list[tuple[str, str]] = [] async def get(self, key: str) -> str | None: return self.values.get(key) @@ -110,6 +111,45 @@ async def set(self, key: str, value: str) -> None: async def delete(self, key: str) -> int: return int(self.values.pop(key, None) is not None) + def pipeline(self) -> "FakePipeline": + return FakePipeline(self) + + def lock(self, *_args: object, **_kwargs: object) -> "FakeLock": + return FakeLock() + + +class FakePipeline: + def __init__(self, client: FakeRedis) -> None: + self.client = client + self.commands: list[tuple[str, str, str]] = [] + + async def __aenter__(self) -> "FakePipeline": + return self + + async def __aexit__(self, *args: object) -> None: + return None + + def set(self, key: str, value: str) -> None: + self.commands.append(("set", key, value)) + + def publish(self, channel: str, message: str) -> None: + self.commands.append(("publish", channel, message)) + + async def execute(self) -> None: + for command, key, value in self.commands: + if command == "set": + self.client.values[key] = value + else: + self.client.published.append((key, value)) + + +class FakeLock: + async def __aenter__(self) -> "FakeLock": + return self + + async def __aexit__(self, *args: object) -> None: + return None + @pytest.fixture def fake_redis() -> FakeRedis: diff --git a/backend/app/tests/session/test_pubsub_integration.py b/backend/app/tests/session/test_pubsub_integration.py new file mode 100644 index 0000000..8a1fb2f --- /dev/null +++ b/backend/app/tests/session/test_pubsub_integration.py @@ -0,0 +1,110 @@ +"""Integration coverage for Redis fan-out across independent backend nodes.""" + +import asyncio +import logging +import os + +import pytest +from redis.asyncio import Redis + +from app.session import store +from app.session.manager import ConnectionManager +from app.session.models import DispatchOutcome, SessionActor, SessionLiveState + + +class RecordingWebSocket: + def __init__(self) -> None: + self.messages: list[dict] = [] + self.message_received = asyncio.Event() + + async def send_json(self, message: dict) -> None: + self.messages.append(message) + self.message_received.set() + + +@pytest.fixture +def anyio_backend() -> str: + return "asyncio" + + +@pytest.fixture +def redis_test_url() -> str: + url = os.environ.get("REDIS_TEST_URL") + if url is None: + pytest.skip("set REDIS_TEST_URL to run Redis integration tests") + return url + + +@pytest.mark.anyio +async def test_publish_relays_outcome_to_connections_on_two_nodes( + redis_test_url: str, + chair_actor: SessionActor, + session_state: SessionLiveState, +) -> None: + publisher = Redis.from_url(redis_test_url) + node_one_client = Redis.from_url(redis_test_url) + node_two_client = Redis.from_url(redis_test_url) + node_one_manager = ConnectionManager() + node_two_manager = ConnectionManager() + node_one_socket = RecordingWebSocket() + node_two_socket = RecordingWebSocket() + node_one_ready = asyncio.Event() + node_two_ready = asyncio.Event() + logger = logging.getLogger("test.redis_pubsub") + + try: + await publisher.ping() + await publisher.flushdb() + await node_one_manager.connect( + node_one_socket, session_state.session_id, chair_actor + ) # type: ignore[arg-type] + await node_two_manager.connect( + node_two_socket, session_state.session_id, chair_actor + ) # type: ignore[arg-type] + node_one_task = asyncio.create_task( + store.subscriber_worker( + node_one_client, node_one_manager, logger, ready=node_one_ready + ) + ) + node_two_task = asyncio.create_task( + store.subscriber_worker( + node_two_client, node_two_manager, logger, ready=node_two_ready + ) + ) + await asyncio.wait_for( + asyncio.gather(node_one_ready.wait(), node_two_ready.wait()), timeout=5 + ) + + outcome = DispatchOutcome(state=session_state) + await store.save_publish_outcome(publisher, outcome) + + await asyncio.wait_for(node_one_socket.message_received.wait(), timeout=5) + await asyncio.wait_for(node_two_socket.message_received.wait(), timeout=5) + + expected = { + "type": "dispatch_result", + "state": session_state.model_dump(mode="json"), + "effect": None, + } + assert node_one_socket.messages == [expected] + assert node_two_socket.messages == [expected] + assert await store.get_outcome(publisher, session_state.session_id) == outcome + finally: + for task in (locals().get("node_one_task"), locals().get("node_two_task")): + if task is not None: + task.cancel() + await asyncio.gather( + *( + task + for task in ( + locals().get("node_one_task"), + locals().get("node_two_task"), + ) + if task is not None + ), + return_exceptions=True, + ) + await publisher.flushdb() + await asyncio.gather( + publisher.aclose(), node_one_client.aclose(), node_two_client.aclose() + ) diff --git a/backend/app/tests/session/test_service.py b/backend/app/tests/session/test_service.py index 74d8a65..b293718 100644 --- a/backend/app/tests/session/test_service.py +++ b/backend/app/tests/session/test_service.py @@ -8,7 +8,7 @@ from app.session import enums, store from app.session.engine import EventRejectedError from app.session.enums import SessionRole -from app.session.models import SessionActor, SessionLiveState +from app.session.models import DispatchOutcome, SessionActor, SessionLiveState from app.session.schemas import EventMessage, JoinQueueEvent from app.session.service import ( ActorResolutionError, @@ -38,7 +38,7 @@ def brazil_assignment() -> CommitteeAssignment: async def test_builds_delegate_actor_from_redis( fake_redis, session_state: SessionLiveState ) -> None: - await store.save_state(fake_redis, session_state) # type: ignore[arg-type] + await store.save_outcome(fake_redis, DispatchOutcome(state=session_state)) # type: ignore[arg-type] actor = await build_actor( user_id=UUID("11111111-1111-1111-1111-111111111111"), @@ -81,7 +81,7 @@ async def test_cannot_build_actor_with_no_delegation_id(fake_redis) -> None: async def test_cannot_build_actor_with_nonexistent_delegation( fake_redis, session_state: SessionLiveState ) -> None: - await store.save_state(fake_redis, session_state) # type: ignore[arg-type] + await store.save_outcome(fake_redis, DispatchOutcome(state=session_state)) # type: ignore[arg-type] with pytest.raises(ActorResolutionError, match="delegation not found"): await build_actor( @@ -97,7 +97,7 @@ async def test_cannot_build_actor_with_nonexistent_delegation( async def test_prepare_connect_uses_redis_without_database( connection_manager, fake_redis, session_state: SessionLiveState, brazil_assignment ) -> None: - await store.save_state(fake_redis, session_state) # type: ignore[arg-type] + await store.save_outcome(fake_redis, DispatchOutcome(state=session_state)) # type: ignore[arg-type] actor = await prepare_session_connect( session=None, # type: ignore[arg-type] @@ -137,7 +137,9 @@ async def test_prepare_connect_hydrates_redis_from_database( ) assert actor.delegation is not None - assert await store.get_state(fake_redis, session_state.session_id) == session_state # type: ignore[arg-type] + assert ( + await store.get_outcome(fake_redis, session_state.session_id) + ).state == session_state # type: ignore[union-attr,arg-type] mock_get_session_info.assert_awaited_once() @@ -167,7 +169,7 @@ async def test_handle_client_messages_persists_dispatch_outcome( delegate_actor: SessionActor, ) -> None: session_state.current_state = enums.States.OPEN_GSL - await store.save_state(fake_redis, session_state) # type: ignore[arg-type] + await store.save_outcome(fake_redis, DispatchOutcome(state=session_state)) # type: ignore[arg-type] client_message = EventMessage( request_id=uuid4(), event=JoinQueueEvent(type=enums.DelegateEvents.JOIN_QUEUE, payload={}), @@ -184,14 +186,14 @@ async def test_handle_client_messages_persists_dispatch_outcome( assert fake_engine.dispatched["state"] is not None assert result.state is not None - assert (await store.get_state(fake_redis, session_state.session_id)) is not None # type: ignore[arg-type] + assert (await store.get_outcome(fake_redis, session_state.session_id)) is not None # type: ignore[arg-type] @pytest.mark.anyio async def test_handle_client_messages_does_not_persist_rejection( fake_redis, session_state: SessionLiveState, delegate_actor: SessionActor ) -> None: - await store.save_state(fake_redis, session_state) # type: ignore[arg-type] + await store.save_outcome(fake_redis, DispatchOutcome(state=session_state)) # type: ignore[arg-type] rejection = EventRejectedError( enums.EventErrorCode.INVALID_STATE, "Cannot enter queue right now" ) @@ -212,4 +214,6 @@ async def test_handle_client_messages_does_not_persist_rejection( ) assert result is rejection - assert await store.get_state(fake_redis, session_state.session_id) == session_state # type: ignore[arg-type] + assert ( + await store.get_outcome(fake_redis, session_state.session_id) + ).state == session_state # type: ignore[union-attr,arg-type] diff --git a/backend/app/tests/session/test_store.py b/backend/app/tests/session/test_store.py index c820d86..f35f6f0 100644 --- a/backend/app/tests/session/test_store.py +++ b/backend/app/tests/session/test_store.py @@ -1,7 +1,7 @@ import pytest from app.session import store -from app.session.models import SessionLiveState +from app.session.models import DispatchOutcome, SessionLiveState @pytest.fixture @@ -10,24 +10,41 @@ def anyio_backend() -> str: @pytest.mark.anyio -async def test_save_and_get_state(fake_redis, session_state: SessionLiveState) -> None: - await store.save_state(fake_redis, session_state) # type: ignore[arg-type] +async def test_save_and_get_outcome( + fake_redis, session_state: SessionLiveState +) -> None: + outcome = DispatchOutcome(state=session_state) + await store.save_outcome(fake_redis, outcome) # type: ignore[arg-type] - state = await store.get_state(fake_redis, session_state.session_id) # type: ignore[arg-type] + saved = await store.get_outcome(fake_redis, session_state.session_id) # type: ignore[arg-type] - assert state == session_state + assert saved == outcome @pytest.mark.anyio -async def test_get_missing_state_returns_none(fake_redis) -> None: - assert await store.get_state(fake_redis, 404) is None # type: ignore[arg-type] +async def test_get_missing_outcome_returns_none(fake_redis) -> None: + assert await store.get_outcome(fake_redis, 404) is None # type: ignore[arg-type] @pytest.mark.anyio -async def test_delete_state_removes_saved_state( +async def test_delete_outcome_removes_saved_outcome( fake_redis, session_state: SessionLiveState ) -> None: - await store.save_state(fake_redis, session_state) # type: ignore[arg-type] - await store.delete_state(fake_redis, session_state.session_id) # type: ignore[arg-type] + await store.save_outcome(fake_redis, DispatchOutcome(state=session_state)) # type: ignore[arg-type] + await store.delete_outcome(fake_redis, session_state.session_id) # type: ignore[arg-type] + + assert await store.get_outcome(fake_redis, session_state.session_id) is None # type: ignore[arg-type] + + +@pytest.mark.anyio +async def test_save_publish_outcome_updates_cache_and_publishes( + fake_redis, session_state: SessionLiveState +) -> None: + outcome = DispatchOutcome(state=session_state) + + await store.save_publish_outcome(fake_redis, outcome) # type: ignore[arg-type] - assert await store.get_state(fake_redis, session_state.session_id) is None # type: ignore[arg-type] + assert await store.get_outcome(fake_redis, session_state.session_id) == outcome # type: ignore[arg-type] + assert fake_redis.published == [ + (store.SESSION_STATE_CHANNEL, outcome.model_dump_json()) + ] diff --git a/backend/app/tests/session/test_views.py b/backend/app/tests/session/test_views.py index c5612a2..17dd3c8 100644 --- a/backend/app/tests/session/test_views.py +++ b/backend/app/tests/session/test_views.py @@ -89,7 +89,7 @@ def event_message(request_id: str) -> dict: @pytest.mark.anyio -async def test_websocket_endpoint_broadcasts_dispatch_outcome( +async def test_websocket_endpoint_relies_on_pubsub_for_dispatch_outcomes( authenticated_websocket_dependencies, chair_actor: SessionActor, fake_redis, @@ -105,7 +105,9 @@ async def test_websocket_endpoint_broadcasts_dispatch_outcome( return_value=DispatchOutcome(state=session_state) ) monkeypatch.setattr(views.service, "handle_client_messages", handle_client_messages) - await views.store.save_state(fake_redis, session_state) # type: ignore[arg-type] + await views.store.save_outcome( # type: ignore[arg-type] + fake_redis, DispatchOutcome(state=session_state) + ) await views.websocket_endpoint( websocket, # type: ignore[arg-type] @@ -123,11 +125,6 @@ async def test_websocket_endpoint_broadcasts_dispatch_outcome( "type": "state_snapshot", "state": session_state.model_dump(mode="json"), }, - { - "type": "dispatch_result", - "state": session_state.model_dump(mode="json"), - "effect": None, - }, ] handle_client_messages.assert_awaited_once() @@ -157,7 +154,9 @@ async def test_websocket_endpoint_sends_rejection_only_to_sender( "handle_client_messages", AsyncMock(return_value=rejection), ) - await views.store.save_state(fake_redis, session_state) # type: ignore[arg-type] + await views.store.save_outcome( # type: ignore[arg-type] + fake_redis, DispatchOutcome(state=session_state) + ) await views.websocket_endpoint( websocket, # type: ignore[arg-type] @@ -200,7 +199,9 @@ async def test_websocket_endpoint_rejects_invalid_event_and_keeps_connection_ope ) handle_client_messages = AsyncMock() monkeypatch.setattr(views.service, "handle_client_messages", handle_client_messages) - await views.store.save_state(fake_redis, session_state) # type: ignore[arg-type] + await views.store.save_outcome( # type: ignore[arg-type] + fake_redis, DispatchOutcome(state=session_state) + ) await views.websocket_endpoint( websocket, # type: ignore[arg-type] diff --git a/backend/app/tests/session/test_websocket.py b/backend/app/tests/session/test_websocket.py index 6f76ad8..6f3c2a8 100644 --- a/backend/app/tests/session/test_websocket.py +++ b/backend/app/tests/session/test_websocket.py @@ -41,7 +41,6 @@ async def test_connect_stores_actor( assert connection_manager.count_connected(1) == 1 -@pytest.mark.anyio @pytest.mark.anyio async def test_disconnect_removes_socket( connection_manager: ConnectionManager, @@ -112,10 +111,6 @@ async def test_send_message_sends_rejection_only_to_originating_connection( @pytest.mark.anyio -@pytest.mark.xfail( - strict=True, - reason="broadcast_message indexes active_connections when no clients are connected.", -) async def test_broadcast_state_without_connections_is_noop( connection_manager: ConnectionManager, ) -> None: