diff --git a/backend/.env.example b/backend/.env.example index c43ad80..d5b0f66 100644 --- a/backend/.env.example +++ b/backend/.env.example @@ -2,3 +2,4 @@ SUPABASE_URL=http://127.0.0.1:54321 DATABASE_URL=postgresql+asyncpg://postgres:postgres@127.0.0.1:54322/postgres ENVIRONMENT=development CORS_ORIGINS=https://app.example.com,https://admin.example.com +REDIS_URL=redis://127.0.0.1:6379 \ No newline at end of file diff --git a/backend/app/core/config.py b/backend/app/core/config.py index d5bdf33..90d2b60 100644 --- a/backend/app/core/config.py +++ b/backend/app/core/config.py @@ -18,6 +18,8 @@ class Settings(BaseSettings): # supabase config SUPABASE_URL: AnyHttpUrl + REDIS_URL: SecretStr + @property def list_cors_origins(self) -> list[str]: origins = [origin.strip() for origin in self.CORS_ORIGINS.split(",")] @@ -33,4 +35,4 @@ def list_cors_origins(self) -> list[str]: @lru_cache def get_settings(): - return Settings() + return Settings() # type:ignore diff --git a/backend/app/core/dep.py b/backend/app/core/dep.py index 3694b68..90daf10 100644 --- a/backend/app/core/dep.py +++ b/backend/app/core/dep.py @@ -1,6 +1,7 @@ import logging from fastapi.requests import HTTPConnection +from redis.asyncio import Redis from app.session.engine import SessionEngine from app.session.manager import ConnectionManager @@ -18,3 +19,8 @@ def get_session_engine(connection: HTTPConnection) -> SessionEngine: def get_logger() -> logging.Logger: return logging.getLogger("uvicorn.error") + + +def get_session_store(connection: HTTPConnection) -> Redis: + """Dependency injection for Cache pool""" + return connection.app.state.redis diff --git a/backend/app/main.py b/backend/app/main.py index 512646b..36c2daf 100644 --- a/backend/app/main.py +++ b/backend/app/main.py @@ -1,5 +1,6 @@ from contextlib import asynccontextmanager +import redis.asyncio as redis from fastapi import FastAPI, Request from fastapi.middleware.cors import CORSMiddleware from fastapi.openapi.utils import get_openapi @@ -14,10 +15,6 @@ from app.session.manager import ConnectionManager from app.session.views import router as session_router -# Startup and shutdown logic for shared variables, such as -# (db session, settings, connection manager, etc) -# You can view more of this on "FastAPI Lifespan" - settings = get_settings() @@ -31,8 +28,13 @@ async def lifespan(app: FastAPI): app.state.session_engine = SessionEngine() app.state.connection_manager = ConnectionManager() + app.state.redis = redis.from_url( + settings.REDIS_URL.get_secret_value(), + ) + yield + await app.state.redis.close() await engine.dispose() diff --git a/backend/app/session/manager.py b/backend/app/session/manager.py index b302d66..5e5482b 100644 --- a/backend/app/session/manager.py +++ b/backend/app/session/manager.py @@ -4,28 +4,19 @@ from fastapi import WebSocket -from app.session.schemas import ServerSessionMessage, StateSnapshotMessage +from app.session.schemas import ServerSessionMessage -from .models import SessionActor, SessionLiveState +from .models import SessionActor class ConnectionManager: def __init__(self): # Initialize dictionary with room_name and dict with websocket -> delegation self.active_connections: dict[int, dict[WebSocket, SessionActor]] = {} - self.room_states: dict[int, SessionLiveState] = {} - # async def connect(self, websocket: WebSocket, session_id: int, actor: SessionActor): self.active_connections.setdefault(session_id, {})[websocket] = actor - # Send the initial state through the same typed protocol as later updates. - if session_id in self.room_states: - state = self.room_states[session_id] - await websocket.send_json( - StateSnapshotMessage(state=state).model_dump(mode="json") - ) - def disconnect(self, websocket: WebSocket, session_id: int): self.active_connections[session_id].pop(websocket) diff --git a/backend/app/session/service.py b/backend/app/session/service.py index ff69ac4..3aef21b 100644 --- a/backend/app/session/service.py +++ b/backend/app/session/service.py @@ -7,11 +7,13 @@ from datetime import datetime from uuid import UUID +from redis.asyncio import Redis from sqlalchemy.ext.asyncio import AsyncSession import app.session.enums as enums import app.session.repository as repository import app.session.schemas as schemas +import app.session.store as store from app.access.models import CommitteeAssignment from app.core.exceptions import ( BadRequest, @@ -38,11 +40,11 @@ class SessionFetchError(Exception): pass -def build_actor( +async def build_actor( user_id: UUID, - manager: ConnectionManager, session_id: int, role: enums.SessionRole, + redis: Redis, delegation_id: int | None = None, ) -> SessionActor: @@ -56,7 +58,7 @@ def build_actor( if role == enums.SessionRole.DELEGATE: if delegation_id is None: raise ActorResolutionError("needs delegate id") - state = manager.room_states.get(session_id) + state = await store.get_state(session=redis, session_id=session_id) if state is None: raise ActorResolutionError("session not found") @@ -109,6 +111,7 @@ async def activate_session( session: AsyncSession, manager: ConnectionManager, committee_session_id: int, + redis: Redis, ): """Activate a planned session""" stored = await get_session_for_activation(session, committee_session_id) @@ -145,7 +148,8 @@ async def activate_session( await session.commit() - manager.room_states[committee_session_id] = live_state + await store.save_state(session=redis, state=live_state) + manager.active_connections.setdefault(committee_session_id, {}) @@ -170,11 +174,12 @@ async def prepare_session_connect( manager: ConnectionManager, committee_session_id: int, assignment: CommitteeAssignment, + redis: Redis, ) -> SessionActor: """Service that prepares for session connect. Primarily used as a fallback in case the SessionLiveState is not in manager """ - live_state = manager.room_states.get(committee_session_id) + live_state = await store.get_state(session=redis, session_id=committee_session_id) if live_state is None: stored_state = await repository.get_session_info(session, committee_session_id) @@ -188,37 +193,37 @@ async def prepare_session_connect( # fetch state_snapshot and validate to be a SessionLiveState live_state = SessionLiveState.model_validate(stored_state.state_snapshot) - # put SessionLiveState on ConnectionManager - manager.room_states[committee_session_id] = live_state + # put SessionLiveState on Cache + live_state = await store.save_state(session=redis, state=live_state) manager.active_connections.setdefault(committee_session_id, {}) - actor = build_actor( + actor = await build_actor( user_id=assignment.user_id, - manager=manager, session_id=committee_session_id, role=enums.SessionRole(assignment.role.upper()), delegation_id=assignment.representation_id, + redis=redis, ) return actor async def handle_client_messages( - manager: ConnectionManager, engine: SessionEngine, logger: logging.Logger, session_id: int, actor: SessionActor, data: schemas.EventMessage, + redis: Redis, ): event = data.event - state = manager.room_states[session_id] + state = await store.get_state(session=redis, session_id=session_id) logger.info(event) # Debugging try: result = engine.dispatch(state, event, actor) - manager.room_states[session_id] = result.state + await store.save_state(session=redis, state=state) return result except EventRejectedError as exc: return exc diff --git a/backend/app/session/store.py b/backend/app/session/store.py new file mode 100644 index 0000000..252363f --- /dev/null +++ b/backend/app/session/store.py @@ -0,0 +1,19 @@ +import redis.asyncio as redis + +from app.session.models import SessionLiveState + + +async def get_state(session: redis.Redis, session_id: int) -> SessionLiveState | None: + res = await session.get(f"webmun:session:{session_id}") + if res is None: + return None + + return SessionLiveState.model_validate_json(res) + + +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 delete_state(session: redis.Redis, session_id: int) -> None: + await session.delete(f"webmun:session:{session_id}") diff --git a/backend/app/session/views.py b/backend/app/session/views.py index 547fe13..e63c346 100644 --- a/backend/app/session/views.py +++ b/backend/app/session/views.py @@ -13,6 +13,7 @@ status, ) from pydantic import ValidationError +from redis.asyncio import Redis from sqlalchemy.ext.asyncio import AsyncSession import app.access.service as access @@ -26,8 +27,14 @@ ) from app.core.config import Settings, get_settings from app.core.database import get_db_session -from app.core.dep import get_connection_manager, get_logger, get_session_engine +from app.core.dep import ( + get_connection_manager, + get_logger, + get_session_engine, + get_session_store, +) from app.core.exceptions import AccessDeniedError +from app.session import store from app.session.engine import EventRejectedError, SessionEngine from app.session.enums import EventErrorCode from app.session.manager import ConnectionManager @@ -38,6 +45,7 @@ EventMessage, EventRejectedMessage, SessionCreationSchema, + StateSnapshotMessage, ) router = APIRouter() @@ -75,6 +83,7 @@ async def activate_session_endpoint( db_session: Annotated[AsyncSession, Depends(get_db_session)], manager: Annotated[ConnectionManager, Depends(get_connection_manager)], current_user: Annotated[AuthUser, Depends(get_current_user)], + redis: Annotated[Redis, Depends(get_session_store)], ): """Endpoint to activate a planned session""" stored = await service.get_session_for_activation( @@ -87,7 +96,10 @@ async def activate_session_endpoint( required_role="chair", ) await service.activate_session( - session=db_session, manager=manager, committee_session_id=session_id + session=db_session, + redis=redis, + manager=manager, + committee_session_id=session_id, ) @@ -99,13 +111,10 @@ async def websocket_endpoint( engine: Annotated[SessionEngine, Depends(get_session_engine)], logger: Annotated[logging.Logger, Depends(get_logger)], settings: Annotated[Settings, Depends(get_settings)], + redis: Annotated[Redis, Depends(get_session_store)], ): """ Endpoint for connecting to a committee session. - - Overall flow: accepts websocket -> user sends token -> we verify it -> - if valid, lookup an assigment -> builds actor, connects to manager, and receive The - current session state """ await websocket.accept() @@ -130,9 +139,18 @@ async def websocket_endpoint( manager=manager, committee_session_id=session_id, assignment=assignment, + 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), + ) + try: while True: data = await websocket.receive_json() @@ -148,12 +166,12 @@ async def websocket_endpoint( continue result = await service.handle_client_messages( - manager=manager, engine=engine, logger=logger, session_id=session_id, actor=actor, data=validated_event, + redis=redis, ) match result: # Either broadcast result outcome, or send error message back to socket diff --git a/backend/app/tests/conftest.py b/backend/app/tests/conftest.py index 3ca7485..8bd68aa 100644 --- a/backend/app/tests/conftest.py +++ b/backend/app/tests/conftest.py @@ -13,6 +13,8 @@ "DATABASE_URL", "postgresql+asyncpg://postgres:postgres@localhost:5432/webmun_test" ) os.environ.setdefault("SUPABASE_URL", "https://supabase.example.test") +os.environ.setdefault("REDIS_URL", "redis://localhost:6379/0") + from app.session.engine import SessionEngine from app.session.enums import ( @@ -95,6 +97,25 @@ def fake_engine(): return FakeEngine() +class FakeRedis: + def __init__(self) -> None: + self.values: dict[str, str] = {} + + async def get(self, key: str) -> str | None: + return self.values.get(key) + + async def set(self, key: str, value: str) -> None: + self.values[key] = value + + async def delete(self, key: str) -> int: + return int(self.values.pop(key, None) is not None) + + +@pytest.fixture +def fake_redis() -> FakeRedis: + return FakeRedis() + + @pytest.fixture def connection_manager(): return ConnectionManager() diff --git a/backend/app/tests/session/test_service.py b/backend/app/tests/session/test_service.py index 2dd9711..74d8a65 100644 --- a/backend/app/tests/session/test_service.py +++ b/backend/app/tests/session/test_service.py @@ -1,4 +1,3 @@ -# Test suite for service layer from unittest.mock import AsyncMock, MagicMock from uuid import UUID, uuid4 @@ -6,10 +5,9 @@ from app.access.enums import SessionRoles from app.access.models import CommitteeAssignment -from app.session import enums +from app.session import enums, store from app.session.engine import EventRejectedError from app.session.enums import SessionRole -from app.session.manager import ConnectionManager from app.session.models import SessionActor, SessionLiveState from app.session.schemas import EventMessage, JoinQueueEvent from app.session.service import ( @@ -22,7 +20,12 @@ @pytest.fixture -def brazil_assignment(): +def anyio_backend() -> str: + return "asyncio" + + +@pytest.fixture +def brazil_assignment() -> CommitteeAssignment: return CommitteeAssignment( user_id=UUID("44444444-4444-4444-4444-444444444444"), committee_id=0, @@ -31,85 +34,77 @@ def brazil_assignment(): ) -def test_can_build_actor( - connection_manager: ConnectionManager, - session_state: SessionLiveState, +@pytest.mark.anyio +async def test_builds_delegate_actor_from_redis( + fake_redis, session_state: SessionLiveState ) -> None: - connection_manager.room_states[0] = session_state + await store.save_state(fake_redis, session_state) # type: ignore[arg-type] - actor = build_actor( + actor = await build_actor( user_id=UUID("11111111-1111-1111-1111-111111111111"), - manager=connection_manager, - session_id=0, + session_id=session_state.session_id, role=SessionRole.DELEGATE, delegation_id=0, + redis=fake_redis, # type: ignore[arg-type] ) assert actor.role == SessionRole.DELEGATE assert actor.delegation is not None - assert actor.delegation.id == connection_manager.room_states[0].delegations[0].id - assert ( - actor.delegation.name == connection_manager.room_states[0].delegations[0].name - ) + assert actor.delegation.id == session_state.delegations[0].id + assert actor.delegation.name == session_state.delegations[0].name -def test_cannot_build_actor_with_nonexistent_state( - connection_manager: ConnectionManager, -) -> None: +@pytest.mark.anyio +async def test_cannot_build_actor_with_missing_redis_state(fake_redis) -> None: with pytest.raises(ActorResolutionError, match="session not found"): - build_actor( + await build_actor( user_id=UUID("11111111-1111-1111-1111-111111111111"), - manager=connection_manager, session_id=0, role=SessionRole.DELEGATE, delegation_id=0, + redis=fake_redis, # type: ignore[arg-type] ) -def test_cannot_build_actor_with_no_delegation_id( - connection_manager: ConnectionManager, - session_state: SessionLiveState, -) -> None: +@pytest.mark.anyio +async def test_cannot_build_actor_with_no_delegation_id(fake_redis) -> None: with pytest.raises(ActorResolutionError, match="needs delegate id"): - connection_manager.room_states[0] = session_state - build_actor( + await build_actor( user_id=UUID("11111111-1111-1111-1111-111111111111"), - manager=connection_manager, session_id=0, role=SessionRole.DELEGATE, + redis=fake_redis, # type: ignore[arg-type] ) -def test_cannot_build_actor_with_nonexistent_delegation( - connection_manager: ConnectionManager, - session_state: SessionLiveState, +@pytest.mark.anyio +async def test_cannot_build_actor_with_nonexistent_delegation( + fake_redis, session_state: SessionLiveState ) -> None: - with pytest.raises(ActorResolutionError, match="delegation not found"): - connection_manager.room_states[0] = session_state + await store.save_state(fake_redis, session_state) # type: ignore[arg-type] - build_actor( + with pytest.raises(ActorResolutionError, match="delegation not found"): + await build_actor( user_id=UUID("11111111-1111-1111-1111-111111111111"), - manager=connection_manager, - session_id=0, + session_id=session_state.session_id, role=SessionRole.DELEGATE, delegation_id=999, + redis=fake_redis, # type: ignore[arg-type] ) @pytest.mark.anyio -async def test_prepare_connect_without_db( - connection_manager: ConnectionManager, - session_state: SessionLiveState, - brazil_assignment: CommitteeAssignment, +async def test_prepare_connect_uses_redis_without_database( + connection_manager, fake_redis, session_state: SessionLiveState, brazil_assignment ) -> None: - connection_manager.room_states[0] = session_state - mock_session = None + await store.save_state(fake_redis, session_state) # type: ignore[arg-type] actor = await prepare_session_connect( - session=mock_session, # type: ignore due to mock session not needing to be called. if it is, we fail + session=None, # type: ignore[arg-type] manager=connection_manager, - committee_session_id=0, + committee_session_id=session_state.session_id, assignment=brazil_assignment, + redis=fake_redis, # type: ignore[arg-type] ) assert actor.role == enums.SessionRole.DELEGATE @@ -118,106 +113,87 @@ async def test_prepare_connect_without_db( @pytest.mark.anyio -async def test_prepare_connect_fetches_db( - connection_manager: ConnectionManager, - brazil_assignment: CommitteeAssignment, +async def test_prepare_connect_hydrates_redis_from_database( + connection_manager, + fake_redis, + session_state: SessionLiveState, + brazil_assignment, monkeypatch, ) -> None: - mock_session = MagicMock - mock_stored_state = MagicMock() - mock_stored_state.status = "active" - mock_stored_state.state_snapshot = {"session_id": 0} - + mock_stored_state = MagicMock( + status="active", state_snapshot=session_state.model_dump(mode="json") + ) mock_get_session_info = AsyncMock(return_value=mock_stored_state) - monkeypatch.setattr( "app.session.repository.get_session_info", mock_get_session_info ) - # prevent model_validate from breaking validation - monkeypatch.setattr( - SessionLiveState, - "model_validate", - MagicMock(return_value=mock_stored_state.state_snapshot), - ) - - monkeypatch.setattr("app.session.service.build_actor", MagicMock()) - - await prepare_session_connect( - session=mock_session, # type: ignore + actor = await prepare_session_connect( + session=MagicMock(), manager=connection_manager, - committee_session_id=0, + committee_session_id=session_state.session_id, assignment=brazil_assignment, + redis=fake_redis, # type: ignore[arg-type] ) - mock_get_session_info.assert_called_once_with(mock_session, 0) + assert actor.delegation is not None + assert await store.get_state(fake_redis, session_state.session_id) == session_state # type: ignore[arg-type] + mock_get_session_info.assert_awaited_once() @pytest.mark.anyio -async def test_cant_prepare_connect_storedlive_missing( - connection_manager: ConnectionManager, - brazil_assignment: CommitteeAssignment, - monkeypatch, +async def test_prepare_connect_rejects_missing_durable_session( + connection_manager, fake_redis, brazil_assignment, monkeypatch ) -> None: - with pytest.raises(SessionFetchError, match="Could not fetch session info"): - mock_session = MagicMock - mock_get_session_info = AsyncMock(return_value=None) - - monkeypatch.setattr( - "app.session.repository.get_session_info", mock_get_session_info - ) + monkeypatch.setattr( + "app.session.repository.get_session_info", AsyncMock(return_value=None) + ) + with pytest.raises(SessionFetchError, match="Could not fetch session info"): await prepare_session_connect( - session=mock_session, # type: ignore + session=MagicMock(), manager=connection_manager, committee_session_id=0, assignment=brazil_assignment, + redis=fake_redis, # type: ignore[arg-type] ) @pytest.mark.anyio -async def test_handle_client_messages_returns_dispatch_outcome_and_updates_state( - connection_manager: ConnectionManager, +async def test_handle_client_messages_persists_dispatch_outcome( + fake_redis, fake_engine, session_state: SessionLiveState, delegate_actor: SessionActor, ) -> None: session_state.current_state = enums.States.OPEN_GSL - connection_manager.room_states[session_state.session_id] = session_state - + await store.save_state(fake_redis, session_state) # type: ignore[arg-type] client_message = EventMessage( request_id=uuid4(), event=JoinQueueEvent(type=enums.DelegateEvents.JOIN_QUEUE, payload={}), ) result = await handle_client_messages( - manager=connection_manager, engine=fake_engine, logger=__import__("logging").getLogger("test"), session_id=session_state.session_id, actor=delegate_actor, data=client_message, + redis=fake_redis, # type: ignore[arg-type] ) - # tests if engine dispatched the message - - assert fake_engine.dispatched["state"] is session_state - assert fake_engine.dispatched["event"].type == enums.DelegateEvents.JOIN_QUEUE - assert fake_engine.dispatched["actor"] is delegate_actor - assert result.state is session_state - assert connection_manager.room_states[session_state.session_id] is session_state + 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] @pytest.mark.anyio -async def test_handle_client_messages_returns_event_rejection_without_updating_state( - connection_manager: ConnectionManager, - session_state: SessionLiveState, - delegate_actor: SessionActor, +async def test_handle_client_messages_does_not_persist_rejection( + fake_redis, session_state: SessionLiveState, delegate_actor: SessionActor ) -> None: - connection_manager.room_states[session_state.session_id] = session_state + await store.save_state(fake_redis, session_state) # type: ignore[arg-type] rejection = EventRejectedError( - enums.EventErrorCode.INVALID_STATE, - "Cannot enter queue right now", + enums.EventErrorCode.INVALID_STATE, "Cannot enter queue right now" ) rejecting_engine = MagicMock() rejecting_engine.dispatch.side_effect = rejection @@ -227,13 +203,13 @@ async def test_handle_client_messages_returns_event_rejection_without_updating_s ) result = await handle_client_messages( - manager=connection_manager, engine=rejecting_engine, logger=__import__("logging").getLogger("test"), session_id=session_state.session_id, actor=delegate_actor, data=event, + redis=fake_redis, # type: ignore[arg-type] ) assert result is rejection - assert connection_manager.room_states[session_state.session_id] is session_state + assert await store.get_state(fake_redis, session_state.session_id) == session_state # type: ignore[arg-type] diff --git a/backend/app/tests/session/test_store.py b/backend/app/tests/session/test_store.py new file mode 100644 index 0000000..c820d86 --- /dev/null +++ b/backend/app/tests/session/test_store.py @@ -0,0 +1,33 @@ +import pytest + +from app.session import store +from app.session.models import SessionLiveState + + +@pytest.fixture +def anyio_backend() -> str: + return "asyncio" + + +@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] + + state = await store.get_state(fake_redis, session_state.session_id) # type: ignore[arg-type] + + assert state == session_state + + +@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] + + +@pytest.mark.anyio +async def test_delete_state_removes_saved_state( + 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] + + assert await store.get_state(fake_redis, session_state.session_id) is None # type: ignore[arg-type] diff --git a/backend/app/tests/session/test_views.py b/backend/app/tests/session/test_views.py index 0893b85..c5612a2 100644 --- a/backend/app/tests/session/test_views.py +++ b/backend/app/tests/session/test_views.py @@ -92,6 +92,7 @@ def event_message(request_id: str) -> dict: async def test_websocket_endpoint_broadcasts_dispatch_outcome( authenticated_websocket_dependencies, chair_actor: SessionActor, + fake_redis, session_state: SessionLiveState, monkeypatch, ) -> None: @@ -104,6 +105,7 @@ 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.websocket_endpoint( websocket, # type: ignore[arg-type] @@ -112,15 +114,20 @@ async def test_websocket_endpoint_broadcasts_dispatch_outcome( engine=MagicMock(), logger=MagicMock(), settings=MagicMock(), + redis=fake_redis, # type: ignore[arg-type] ) assert websocket.accepted is True assert websocket.sent_json == [ + { + "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() @@ -129,6 +136,7 @@ async def test_websocket_endpoint_broadcasts_dispatch_outcome( async def test_websocket_endpoint_sends_rejection_only_to_sender( authenticated_websocket_dependencies, chair_actor: SessionActor, + fake_redis, session_state: SessionLiveState, monkeypatch, ) -> None: @@ -149,6 +157,7 @@ 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.websocket_endpoint( websocket, # type: ignore[arg-type] @@ -157,15 +166,20 @@ async def test_websocket_endpoint_sends_rejection_only_to_sender( engine=MagicMock(), logger=MagicMock(), settings=MagicMock(), + redis=fake_redis, # type: ignore[arg-type] ) assert websocket.sent_json == [ + { + "type": "state_snapshot", + "state": session_state.model_dump(mode="json"), + }, { "type": "event_rejected", "request_id": str(request_id), "code": enums.EventErrorCode.INVALID_STATE, "message": "Cannot enter queue right now", - } + }, ] @@ -173,6 +187,7 @@ async def test_websocket_endpoint_sends_rejection_only_to_sender( async def test_websocket_endpoint_rejects_invalid_event_and_keeps_connection_open( authenticated_websocket_dependencies, chair_actor: SessionActor, + fake_redis, session_state: SessionLiveState, monkeypatch, ) -> None: @@ -185,6 +200,7 @@ 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.websocket_endpoint( websocket, # type: ignore[arg-type] @@ -193,18 +209,21 @@ async def test_websocket_endpoint_rejects_invalid_event_and_keeps_connection_ope engine=MagicMock(), logger=MagicMock(), settings=MagicMock(), + redis=fake_redis, # type: ignore[arg-type] ) assert websocket.closed is None - assert websocket.sent_json[0]["type"] == "event_rejected" - assert websocket.sent_json[0]["request_id"] is None - assert websocket.sent_json[0]["code"] == enums.EventErrorCode.INVALID_MESSAGE + assert websocket.sent_json[0]["type"] == "state_snapshot" + assert websocket.sent_json[1]["type"] == "event_rejected" + assert websocket.sent_json[1]["request_id"] is None + assert websocket.sent_json[1]["code"] == enums.EventErrorCode.INVALID_MESSAGE handle_client_messages.assert_not_awaited() @pytest.mark.anyio async def test_websocket_endpoint_closes_when_initial_auth_message_is_invalid( chair_actor: SessionActor, + fake_redis, ) -> None: websocket = FakeWebSocket([{"type": "event"}]) @@ -215,6 +234,7 @@ async def test_websocket_endpoint_closes_when_initial_auth_message_is_invalid( engine=MagicMock(), logger=MagicMock(), settings=MagicMock(), + redis=fake_redis, # type: ignore[arg-type] ) assert websocket.accepted is True diff --git a/backend/app/tests/session/test_websocket.py b/backend/app/tests/session/test_websocket.py index 153c457..6f76ad8 100644 --- a/backend/app/tests/session/test_websocket.py +++ b/backend/app/tests/session/test_websocket.py @@ -1,12 +1,11 @@ import pytest from app.session import enums -from app.session.manager import ConnectionManager, SessionLiveState -from app.session.models import DispatchOutcome, SessionActor +from app.session.manager import ConnectionManager +from app.session.models import SessionActor from app.session.schemas import ( DispatchResultMessage, EventRejectedMessage, - StateSnapshotMessage, ) @@ -43,25 +42,6 @@ async def test_connect_stores_actor( @pytest.mark.anyio -async def test_connect_sends_existing_room_state( - connection_manager: ConnectionManager, - session_state: SessionLiveState, - chair_actor: SessionActor, -) -> None: - websocket = FakeWebSocket() - connection_manager.room_states[session_state.session_id] = session_state - - await connection_manager.connect( - websocket, # type:ignore - session_id=session_state.session_id, - actor=chair_actor, - ) - - expected_json = StateSnapshotMessage(state=session_state).model_dump(mode="json") - - assert websocket.sent_json[-1] == expected_json - - @pytest.mark.anyio async def test_disconnect_removes_socket( connection_manager: ConnectionManager, @@ -79,31 +59,29 @@ async def test_disconnect_removes_socket( @pytest.mark.anyio async def test_broadcast_state_sends_snapshot_to_all_connections( connection_manager: ConnectionManager, - session_state: SessionLiveState, + session_state, chair_actor: SessionActor, delegate_actor: SessionActor, ) -> None: chair_socket = FakeWebSocket() delegate_socket = FakeWebSocket() - connection_manager.room_states[session_state.session_id] = session_state await connection_manager.connect( chair_socket, # type:ignore - session_state.session_id, + 1, chair_actor, ) await connection_manager.connect( delegate_socket, # type:ignore - session_state.session_id, + 1, delegate_actor, ) chair_socket.sent_json.clear() delegate_socket.sent_json.clear() - outcome = DispatchOutcome(state=session_state) - msg = DispatchResultMessage(state=outcome.state, effect=outcome.effect) + msg = DispatchResultMessage(state=session_state, effect=None) - await connection_manager.broadcast_message(session_state.session_id, msg) + await connection_manager.broadcast_message(1, msg) expected = msg.model_dump(mode="json") assert chair_socket.sent_json == [expected] @@ -133,15 +111,18 @@ async def test_send_message_sends_rejection_only_to_originating_connection( assert delegate_socket.sent_json == [message.model_dump(mode="json")] +@pytest.mark.anyio @pytest.mark.xfail( strict=True, - reason="broadcast_state indexes active_connections when state exists.", + reason="broadcast_message indexes active_connections when no clients are connected.", ) -@pytest.mark.anyio async def test_broadcast_state_without_connections_is_noop( connection_manager: ConnectionManager, - session_state: SessionLiveState, ) -> None: - connection_manager.room_states[session_state.session_id] = session_state - - await connection_manager.broadcast_message(session_state.session_id, state=None) # type:ignore + await connection_manager.broadcast_message( + 1, + message=EventRejectedMessage( + code=enums.EventErrorCode.INVALID_STATE, + message="No connected clients", + ), + ) diff --git a/backend/pyproject.toml b/backend/pyproject.toml index 7edcd17..67ca305 100644 --- a/backend/pyproject.toml +++ b/backend/pyproject.toml @@ -9,10 +9,11 @@ dependencies = [ "pytest>=9.1.0", "pytest-cov>=7.0.0", "ruff>=0.15.17", - "supabase", - "pyjwt", - "sqlalchemy", - "asyncpg" + "supabase", + "pyjwt", + "sqlalchemy", + "asyncpg", + "redis>=8.1.0", ] [tool.ruff] diff --git a/backend/uv.lock b/backend/uv.lock index 004c268..70e8d42 100644 --- a/backend/uv.lock +++ b/backend/uv.lock @@ -38,6 +38,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/da/42/e921fccf5015463e32a3cf6ee7f980a6ed0f395ceeaa45060b61d86486c2/anyio-4.13.0-py3-none-any.whl", hash = "sha256:08b310f9e24a9594186fd75b4f73f4a4152069e3853f1ed8bfbf58369f4ad708", size = 114353, upload-time = "2026-03-24T12:59:08.246Z" }, ] +[[package]] +name = "async-timeout" +version = "5.0.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a5/ae/136395dfbfe00dfc94da3f3e136d0b13f394cba8f4841120e34226265780/async_timeout-5.0.1.tar.gz", hash = "sha256:d9321a7a3d5a6a5e187e824d2fa0793ce379a202935782d555d6e9d2735677d3", size = 9274, upload-time = "2024-11-06T16:41:39.6Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fe/ba/e2081de779ca30d473f21f5b30e0e737c438205440784c7dfc81efc2b029/async_timeout-5.0.1-py3-none-any.whl", hash = "sha256:39e3809566ff85354557ec2398b55e096c8364bacac9405a7a1fa429e77fe76c", size = 6233, upload-time = "2024-11-06T16:41:37.9Z" }, +] + [[package]] name = "asyncpg" version = "0.31.0" @@ -96,6 +105,7 @@ dependencies = [ { name = "pyjwt" }, { name = "pytest" }, { name = "pytest-cov" }, + { name = "redis" }, { name = "ruff" }, { name = "sqlalchemy" }, { name = "supabase" }, @@ -108,6 +118,7 @@ requires-dist = [ { name = "pyjwt" }, { name = "pytest", specifier = ">=9.1.0" }, { name = "pytest-cov", specifier = ">=7.0.0" }, + { name = "redis", specifier = ">=8.1.0" }, { name = "ruff", specifier = ">=0.15.17" }, { name = "sqlalchemy" }, { name = "supabase" }, @@ -1444,6 +1455,18 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/13/60/164246615e8b059f6d53d34648a0784260421ec98a07eb1e45160f063221/realtime-2.31.0-py3-none-any.whl", hash = "sha256:f6e494b53d6a6e80b6efcee6711c8dd40413a52e766271de1bce8ced6c36cc1d", size = 22374, upload-time = "2026-06-04T13:37:21.162Z" }, ] +[[package]] +name = "redis" +version = "8.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "async-timeout", marker = "python_full_version < '3.11.3'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a8/99/604f0b666d4c616d891cf77ebb9db6bb21601344c051aebf1b72b9ff915f/redis-8.1.0.tar.gz", hash = "sha256:6e1a19beef9225c83efd689c7e6b7da2d5215b1f42cd13b7fc3714d0a09c7b25", size = 5254356, upload-time = "2026-07-30T08:51:00.269Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/66/9d/c5731f6e3608663d4d3656fd8d3aecee8b509c3082818f5a13eae925baea/redis-8.1.0-py3-none-any.whl", hash = "sha256:a4fe1aac3d3b3cc791d4b3d5931c5a956045dc951ee74d1c913ee3ac4d2ee9fb", size = 560618, upload-time = "2026-07-30T08:50:58.497Z" }, +] + [[package]] name = "rich" version = "15.0.0" diff --git a/docker-compose.yml b/docker-compose.yml index 51401b9..f67988c 100644 --- a/docker-compose.yml +++ b/docker-compose.yml @@ -38,6 +38,20 @@ services: - action: restart path: ./backend/app/session/enums.py + redis: + image: redis:latest + healthcheck: + test: ["CMD-SHELL", "redis-cli ping | grep PONG"] + interval: 1s + timeout: 3s + retries: 5 + ports: + - "6379:6379" + command: redis-server --appendonly yes + volumes: + - redis_data:/data + + backend: build: context: ./backend @@ -51,9 +65,13 @@ services: environment: - SUPABASE_URL=http://host.docker.internal:54321 - DATABASE_URL=postgresql+asyncpg://postgres:postgres@host.docker.internal:54322/postgres + - REDIS_URL=redis://redis:6379/0 volumes: - ./backend:/app - backend_packages:/app/.venv + depends_on: + redis: + condition: service_healthy healthcheck: test: ["CMD", "python3", "-c", "import urllib.request, sys; res = urllib.request.urlopen('http://localhost:8000/committees/health', timeout=3); @@ -67,3 +85,4 @@ services: volumes: packages: backend_packages: + redis_data: diff --git a/justfile b/justfile index 0865222..082dcc5 100644 --- a/justfile +++ b/justfile @@ -3,17 +3,22 @@ set default-list := true MKDOCS := "mkdocs" # start the dev environment -dev: +start-dev: echo "Starting dev environment" supabase start || npx supabase start docker compose up --watch # stop dev environment -stop: +stop-dev: echo "Stopping dev environment" docker compose down supabase stop || npx supabase stop +# stop and clean containers, images, and volumes +clean-dev: + docker compose down -v --rmi all --remove-orphans + supabase stop --no-backup + # serve documentation using mkdocs docs-serve: {{MKDOCS}} serve --config-file mkdocs.yml