From ac49ef86d9daef0a21b105f7cc42890c953c7991 Mon Sep 17 00:00:00 2001 From: wate <110754234+r0liveir@users.noreply.github.com> Date: Sat, 29 Aug 2026 18:55:43 -0300 Subject: [PATCH 1/8] refactor: use just for recipes instead of makefile --- README.md | 10 ++++++---- justfile | 27 +++++++++++++++++++++++++++ 2 files changed, 33 insertions(+), 4 deletions(-) create mode 100644 justfile diff --git a/README.md b/README.md index 2f55793..3533f9f 100644 --- a/README.md +++ b/README.md @@ -20,16 +20,18 @@ Further improvements are planned to make this a cloud-native application. # Local development +For automated recipes, this project uses `Just`. Ensure you have it installed. + To start the backend, frontend and supabase, issue: ``` -make dev +just dev ``` To stop these services, do: ``` -make stop +just stop ``` # Docs @@ -51,11 +53,11 @@ $ uv pip install mkdocs Lastly, build the documentation: ```bash -$ make docs-build +$ just docs-build ``` This will output a `site/` directory containing the static site. To serve the website in localhost: ```bash -$ make docs-serve +$ just docs-serve ``` diff --git a/justfile b/justfile new file mode 100644 index 0000000..0865222 --- /dev/null +++ b/justfile @@ -0,0 +1,27 @@ +set default-list := true + +MKDOCS := "mkdocs" + +# start the dev environment +dev: + echo "Starting dev environment" + supabase start || npx supabase start + docker compose up --watch + +# stop dev environment +stop: + echo "Stopping dev environment" + docker compose down + supabase stop || npx supabase stop + +# serve documentation using mkdocs +docs-serve: + {{MKDOCS}} serve --config-file mkdocs.yml + +# build documentation using mkdocs +docs-build: + {{MKDOCS}} build --config-file mkdocs.yml + +# cleanup documentation +docs-clean: + rm -rf site/ From 484712b6f88f05a11c7f37d09b3c453bb6b0f3ea Mon Sep 17 00:00:00 2001 From: wate <110754234+r0liveir@users.noreply.github.com> Date: Sat, 29 Aug 2026 19:08:40 -0300 Subject: [PATCH 2/8] chore: update compose file --- Makefile | 22 ---------------------- docker-compose.yml | 13 +++++++++---- 2 files changed, 9 insertions(+), 26 deletions(-) delete mode 100644 Makefile diff --git a/Makefile b/Makefile deleted file mode 100644 index db818a3..0000000 --- a/Makefile +++ /dev/null @@ -1,22 +0,0 @@ -.PHONY: dev stop docs-serve docs-build - -MKDOCS ?= mkdocs - -dev: - echo "Starting dev environment" - supabase start || npx supabase start - docker compose up --watch - -stop: - echo "Stopping dev environment" - docker compose down - supabase stop || npx supabase stop - -docs-serve: - $(MKDOCS) serve --config-file mkdocs.yml - -docs-build: - $(MKDOCS) build --config-file mkdocs.yml - -docs-clean: - rm -R site/ diff --git a/docker-compose.yml b/docker-compose.yml index 4fbd687..52fcc98 100644 --- a/docker-compose.yml +++ b/docker-compose.yml @@ -3,10 +3,12 @@ services: build: context: ./frontend dockerfile: Dockerfile - user: "${LOCAL_UID:-1000}:${LOCAL_GID:-1000}" env_file: - ./frontend/.env.local - network_mode: host + environment: + - VITE_SUPABASE_URL=http://host.docker.internal:54321 + extra_hosts: + - "host.docker.internal:host-gateway" volumes: - ./frontend:/app - packages:/app/node_modules @@ -40,8 +42,11 @@ services: dockerfile: Dockerfile env_file: - ./backend/.env - # Supabase CLI binds locally to the host. This local stack targets Linux. - network_mode: host + extra_hosts: + - "host.docker.internal:host-gateway" + environment: + - SUPABASE_URL=http://host.docker.internal:54321 + - DATABASE_URL=postgresql+asyncpg://postgres:postgres@host.docker.internal:54322/postgres volumes: - ./backend:/app - backend_packages:/app/.venv From 6f388cd8144aa27d368ab16a30f7ae500d66bb10 Mon Sep 17 00:00:00 2001 From: wate <110754234+r0liveir@users.noreply.github.com> Date: Sat, 29 Aug 2026 20:18:09 -0300 Subject: [PATCH 3/8] fix: revert local uid/gid for schema generation and network_mode --- docker-compose.yml | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/docker-compose.yml b/docker-compose.yml index 52fcc98..51401b9 100644 --- a/docker-compose.yml +++ b/docker-compose.yml @@ -6,12 +6,14 @@ services: env_file: - ./frontend/.env.local environment: - - VITE_SUPABASE_URL=http://host.docker.internal:54321 + OPENAPI_URL: http://backend:8000/openapi.json extra_hosts: - "host.docker.internal:host-gateway" volumes: - ./frontend:/app - packages:/app/node_modules + ports: + - "5173:5173" depends_on: backend: condition: service_healthy @@ -44,6 +46,8 @@ services: - ./backend/.env extra_hosts: - "host.docker.internal:host-gateway" + ports: + - "8000:8000" environment: - SUPABASE_URL=http://host.docker.internal:54321 - DATABASE_URL=postgresql+asyncpg://postgres:postgres@host.docker.internal:54322/postgres From 43bbc6f54edbc2016f64d67a503b20ec2b94a625 Mon Sep 17 00:00:00 2001 From: wate <110754234+r0liveir@users.noreply.github.com> Date: Sat, 29 Aug 2026 20:34:09 -0300 Subject: [PATCH 4/8] chore: update production settings --- backend/.env.example | 4 ++-- backend/app/auth/service.py | 21 +++++++-------------- backend/app/core/config.py | 16 +++++++++++++--- backend/app/main.py | 19 ++++++++++++++----- frontend/src/schemas/types.gen.ts | 2 +- 5 files changed, 37 insertions(+), 25 deletions(-) diff --git a/backend/.env.example b/backend/.env.example index 8dc002a..c43ad80 100644 --- a/backend/.env.example +++ b/backend/.env.example @@ -1,4 +1,4 @@ SUPABASE_URL=http://127.0.0.1:54321 -# Required only while supporting legacy HS256 Supabase tokens. -SUPABASE_JWT_SECRET=jwt_secret_here DATABASE_URL=postgresql+asyncpg://postgres:postgres@127.0.0.1:54322/postgres +ENVIRONMENT=development +CORS_ORIGINS=https://app.example.com,https://admin.example.com diff --git a/backend/app/auth/service.py b/backend/app/auth/service.py index 38c8af2..1c45294 100644 --- a/backend/app/auth/service.py +++ b/backend/app/auth/service.py @@ -31,25 +31,18 @@ def verify_jwt_token( token: str, # self contained token that already has info like id, email, etc settings: Settings, ) -> AuthUser: - """Verify either legacy HS256 or current Supabase ES256 access tokens.""" + """Verify Supabase ES256 access tokens.""" try: - algorithm = jwt.get_unverified_header(token).get("alg") - - if algorithm == "HS256": - key = settings.SUPABASE_JWT_SECRET.get_secret_value() - elif algorithm == "ES256": - key = ( - get_jwk_client(str(settings.SUPABASE_URL)) - .get_signing_key_from_jwt(token) - .key - ) - else: - raise TokenInvalidError("Unsupported access token algorithm") + key = ( + get_jwk_client(str(settings.SUPABASE_URL)) + .get_signing_key_from_jwt(token) + .key + ) payload = jwt.decode( token, key, - algorithms=[algorithm], + algorithms=["ES256"], audience="authenticated", ) diff --git a/backend/app/core/config.py b/backend/app/core/config.py index 11b260e..d5bdf33 100644 --- a/backend/app/core/config.py +++ b/backend/app/core/config.py @@ -6,16 +6,26 @@ class Settings(BaseSettings): # app name - APP_NAME: str = "Meu App FastAPI" + APP_NAME: str = "WebMUN API" ENVIRONMENT: str = "development" + # list of origins by separated commas (e.g., "app.com,app.xyz") + CORS_ORIGINS: str = "" + # db config DATABASE_URL: SecretStr # supabase config SUPABASE_URL: AnyHttpUrl - SUPABASE_JWT_SECRET: SecretStr - JWT_ALGORITHM: str = "HS256" + + @property + def list_cors_origins(self) -> list[str]: + origins = [origin.strip() for origin in self.CORS_ORIGINS.split(",")] + + if self.ENVIRONMENT == "development": + return ["http://localhost:5173"] + + return origins # Host development uses backend/.env; containers and cloud inject process env. model_config = SettingsConfigDict(env_file=".env", extra="ignore") diff --git a/backend/app/main.py b/backend/app/main.py index 921c259..eaad7ef 100644 --- a/backend/app/main.py +++ b/backend/app/main.py @@ -14,14 +14,16 @@ 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() + + @asynccontextmanager async def lifespan(app: FastAPI): # startup phase - settings = get_settings() engine, session_factory = create_db(settings) app.state.db_engine = engine app.state.db_session_factory = session_factory @@ -45,12 +47,19 @@ async def app_exception_handler(request: Request, exc: AppException): return JSONResponse(status_code=exc.status_code, content={"detail": exc.message}) +settings = get_settings() + # CORS config for Vite app.add_middleware( CORSMiddleware, - allow_origins=["http://localhost:5173"], - allow_methods=["*"], - allow_headers=["*"], + allow_origins=settings.list_cors_origins, + allow_credentials=True, + allow_methods=["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"] + if settings.ENVIRONMENT == "production" + else ["*"], + allow_headers=["Authorization", "Content-Type", "Accept"] + if settings.ENVIRONMENT == "production" + else ["*"], ) # include commitees here? diff --git a/frontend/src/schemas/types.gen.ts b/frontend/src/schemas/types.gen.ts index 571a06b..17e3a5c 100644 --- a/frontend/src/schemas/types.gen.ts +++ b/frontend/src/schemas/types.gen.ts @@ -1,7 +1,7 @@ // This file is auto-generated by @hey-api/openapi-ts export type ClientOptions = { - baseUrl: 'http://localhost:8000' | (string & {}); + baseUrl: 'http://backend:8000' | (string & {}); }; /** From 95fc8590779e6ab228c8311e2c276fd982e3ca90 Mon Sep 17 00:00:00 2001 From: wate <110754234+r0liveir@users.noreply.github.com> Date: Sun, 30 Aug 2026 13:14:07 -0300 Subject: [PATCH 5/8] test(auth): cover ES256 token validation Co-authored-by: Codex --- backend/app/tests/auth/test_service.py | 35 ++++++++++++++------------ 1 file changed, 19 insertions(+), 16 deletions(-) diff --git a/backend/app/tests/auth/test_service.py b/backend/app/tests/auth/test_service.py index 3081b56..a239ef5 100644 --- a/backend/app/tests/auth/test_service.py +++ b/backend/app/tests/auth/test_service.py @@ -4,27 +4,28 @@ import jwt import pytest +from cryptography.hazmat.primitives.asymmetric import ec +import app.auth.service as auth_service from app.auth.service import TokenExpiredError, TokenInvalidError, verify_jwt_token -class FakeSecret: - def __init__(self, value: str): - self.value = value - - def get_secret_value(self) -> str: - return self.value +@pytest.fixture +def signing_key(monkeypatch): + private_key = ec.generate_private_key(ec.SECP256R1()) + jwk_client = SimpleNamespace( + get_signing_key_from_jwt=lambda _: SimpleNamespace(key=private_key.public_key()) + ) + monkeypatch.setattr(auth_service, "get_jwk_client", lambda _: jwk_client) + return private_key @pytest.fixture def settings(): - return SimpleNamespace( - SUPABASE_JWT_SECRET=FakeSecret("test-secret-that-is-at-least-32-bytes"), - JWT_ALGORITHM="HS256", - ) + return SimpleNamespace(SUPABASE_URL="https://supabase.example.test") -def make_token(*, user_id, expires_at: datetime) -> str: +def make_token(*, user_id, expires_at: datetime, signing_key) -> str: return jwt.encode( { "sub": str(user_id), @@ -32,16 +33,17 @@ def make_token(*, user_id, expires_at: datetime) -> str: "aud": "authenticated", "exp": expires_at, }, - "test-secret-that-is-at-least-32-bytes", - algorithm="HS256", + signing_key, + algorithm="ES256", ) -def test_verifies_valid_supabase_style_token(settings): +def test_verifies_valid_supabase_style_token(settings, signing_key): user_id = uuid4() token = make_token( user_id=user_id, expires_at=datetime.now(UTC) + timedelta(minutes=5), + signing_key=signing_key, ) user = verify_jwt_token(token, settings) @@ -50,16 +52,17 @@ def test_verifies_valid_supabase_style_token(settings): assert user.email == "delegate@example.test" -def test_rejects_expired_token(settings): +def test_rejects_expired_token(settings, signing_key): token = make_token( user_id=uuid4(), expires_at=datetime.now(UTC) - timedelta(minutes=1), + signing_key=signing_key, ) with pytest.raises(TokenExpiredError): verify_jwt_token(token, settings) -def test_rejects_invalid_token(settings): +def test_rejects_invalid_token(settings, signing_key): with pytest.raises(TokenInvalidError): verify_jwt_token("not-a-jwt", settings) From 20c1a72c72f6540728c9d4ebb197812b669558fc Mon Sep 17 00:00:00 2001 From: wate <110754234+r0liveir@users.noreply.github.com> Date: Sun, 30 Aug 2026 13:19:10 -0300 Subject: [PATCH 6/8] test(backend): configure settings for app imports Co-authored-by: Codex --- backend/app/main.py | 2 -- backend/app/tests/conftest.py | 9 +++++++++ 2 files changed, 9 insertions(+), 2 deletions(-) diff --git a/backend/app/main.py b/backend/app/main.py index eaad7ef..512646b 100644 --- a/backend/app/main.py +++ b/backend/app/main.py @@ -47,8 +47,6 @@ async def app_exception_handler(request: Request, exc: AppException): return JSONResponse(status_code=exc.status_code, content={"detail": exc.message}) -settings = get_settings() - # CORS config for Vite app.add_middleware( CORSMiddleware, diff --git a/backend/app/tests/conftest.py b/backend/app/tests/conftest.py index 9fc51e1..3ca7485 100644 --- a/backend/app/tests/conftest.py +++ b/backend/app/tests/conftest.py @@ -1,10 +1,19 @@ # Environment configuration file for testing +import os from datetime import datetime from uuid import UUID import pytest +# `app.main` builds middleware at import time, which loads Settings before the +# OpenAPI test can run. These are non-secret placeholders; database access is +# mocked in unit tests and no application lifespan is started by that test. +os.environ.setdefault( + "DATABASE_URL", "postgresql+asyncpg://postgres:postgres@localhost:5432/webmun_test" +) +os.environ.setdefault("SUPABASE_URL", "https://supabase.example.test") + from app.session.engine import SessionEngine from app.session.enums import ( SessionRole, From a83c5eb8dd3577ca359c811ac83c804e56415c64 Mon Sep 17 00:00:00 2001 From: wate <110754234+r0liveir@users.noreply.github.com> Date: Sun, 30 Aug 2026 17:51:18 -0300 Subject: [PATCH 7/8] feat: introduce initial redis setup --- backend/.env.example | 1 + backend/app/core/config.py | 4 +++- backend/app/core/dep.py | 6 ++++++ backend/app/main.py | 10 ++++++---- backend/app/session/manager.py | 13 ++----------- backend/app/session/service.py | 29 ++++++++++++++++------------ backend/app/session/store.py | 19 ++++++++++++++++++ backend/app/session/views.py | 32 ++++++++++++++++++++++++------- backend/pyproject.toml | 9 +++++---- backend/uv.lock | 23 ++++++++++++++++++++++ docker-compose.yml | 19 ++++++++++++++++++ frontend/src/schemas/types.gen.ts | 2 +- justfile | 9 +++++++-- 13 files changed, 134 insertions(+), 42 deletions(-) create mode 100644 backend/app/session/store.py diff --git a/backend/.env.example b/backend/.env.example index c43ad80..d5f27a4 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 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/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/frontend/src/schemas/types.gen.ts b/frontend/src/schemas/types.gen.ts index 17e3a5c..571a06b 100644 --- a/frontend/src/schemas/types.gen.ts +++ b/frontend/src/schemas/types.gen.ts @@ -1,7 +1,7 @@ // This file is auto-generated by @hey-api/openapi-ts export type ClientOptions = { - baseUrl: 'http://backend:8000' | (string & {}); + baseUrl: 'http://localhost:8000' | (string & {}); }; /** 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 From 1d9eaa96bc67d0730686e6852571dfeb30bf8e1b Mon Sep 17 00:00:00 2001 From: wate <110754234+r0liveir@users.noreply.github.com> Date: Sun, 30 Aug 2026 17:56:17 -0300 Subject: [PATCH 8/8] test(session): cover redis live state Co-authored-by: Codex --- backend/app/tests/conftest.py | 20 +++ backend/app/tests/session/test_service.py | 172 +++++++++----------- backend/app/tests/session/test_store.py | 33 ++++ backend/app/tests/session/test_views.py | 30 +++- backend/app/tests/session/test_websocket.py | 51 ++---- 5 files changed, 168 insertions(+), 138 deletions(-) create mode 100644 backend/app/tests/session/test_store.py diff --git a/backend/app/tests/conftest.py b/backend/app/tests/conftest.py index 3ca7485..74e540b 100644 --- a/backend/app/tests/conftest.py +++ b/backend/app/tests/conftest.py @@ -13,6 +13,7 @@ "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 +96,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", + ), + )