diff --git a/bases/rsptx/assignment_server_api/core.py b/bases/rsptx/assignment_server_api/core.py index 5290645d9..4e4bf7f1f 100644 --- a/bases/rsptx/assignment_server_api/core.py +++ b/bases/rsptx/assignment_server_api/core.py @@ -24,6 +24,7 @@ from .routers import instructor from .routers import peer from .routers import grader +from .routers import delegated_grader from .routers import echoform from rsptx.auth.csrf import add_csrf_protection from rsptx.exceptions.core import add_exception_handlers @@ -75,6 +76,7 @@ async def lifespan(app: FastAPI): app.include_router(student.router) app.include_router(grader.router) +app.include_router(delegated_grader.router) app.include_router(instructor.router) app.include_router(peer.router) app.include_router(echoform.router) diff --git a/bases/rsptx/assignment_server_api/routers/delegated_grader.py b/bases/rsptx/assignment_server_api/routers/delegated_grader.py new file mode 100644 index 000000000..b3f36fbca --- /dev/null +++ b/bases/rsptx/assignment_server_api/routers/delegated_grader.py @@ -0,0 +1,78 @@ +"""Assignment-scoped access contract for delegated grading.""" + +from fastapi import APIRouter, Depends, HTTPException, status +from pydantic import BaseModel, ConfigDict + +from rsptx.auth.grader_permissions import ( + GraderCapabilities, + GraderRole, + resolve_grader_capabilities, +) +from rsptx.auth.session import auth_manager +from rsptx.db.models import AuthUserValidator + +router = APIRouter( + prefix="/grader", + tags=["delegated-grader"], +) + + +class AssignmentGraderCapabilitiesResponse(BaseModel): + """Public, identity-free grading capabilities for one assignment.""" + + model_config = ConfigDict(extra="forbid") + + role: GraderRole + can_grade: bool + can_view_student_identities: bool + assignment_blind_grading: bool + + +class AssignmentGraderCapabilitiesEnvelope(BaseModel): + model_config = ConfigDict(extra="forbid") + + detail: AssignmentGraderCapabilitiesResponse + + +async def require_assignment_grader( + assignment_id: int, + user: AuthUserValidator = Depends(auth_manager), +) -> GraderCapabilities: + """Return effective capabilities or fail without revealing the assignment.""" + + if not user.id or not user.course_id: + raise HTTPException( + status_code=status.HTTP_400_BAD_REQUEST, + detail="Invalid user or missing course", + ) + + capabilities = await resolve_grader_capabilities( + user_id=user.id, + course_id=user.course_id, + assignment_id=assignment_id, + ) + if not capabilities.can_grade: + raise HTTPException( + status_code=status.HTTP_403_FORBIDDEN, + detail="Grading access denied", + ) + return capabilities + + +@router.get( + "/assignments/{assignment_id}/capabilities", + response_model=AssignmentGraderCapabilitiesEnvelope, +) +async def get_assignment_grader_capabilities( + capabilities: GraderCapabilities = Depends(require_assignment_grader), +): + """Return the identity policy the server will enforce for this grader.""" + + return { + "detail": AssignmentGraderCapabilitiesResponse( + role=capabilities.role, + can_grade=capabilities.can_grade, + can_view_student_identities=capabilities.can_view_student_identities, + assignment_blind_grading=capabilities.assignment_blind_grading, + ) + } diff --git a/test/bases/rsptx/assignment_server_api/conftest.py b/test/bases/rsptx/assignment_server_api/conftest.py index 705fc3eda..ac006bdc5 100644 --- a/test/bases/rsptx/assignment_server_api/conftest.py +++ b/test/bases/rsptx/assignment_server_api/conftest.py @@ -118,6 +118,43 @@ async def editor_user(init_test_db): return user +@pytest_asyncio.fixture(scope="session") +async def delegated_grader_user(init_test_db): + """Create a course grader who deliberately has no instructor membership.""" + from rsptx.db.crud import ( + create_user, + fetch_course, + fetch_user, + grant_course_grader, + ) + from rsptx.db.models import AuthUserValidator + + course = await fetch_course("test_course_1") + user = await fetch_user("test_delegated_grader") + if user is None: + user = await create_user( + AuthUserValidator( + username="test_delegated_grader", + first_name="Test", + last_name="Delegated Grader", + password="xxx", + email="test_delegated_grader@example.com", + course_name=course.course_name, + course_id=course.id, + donated=True, + active=True, + accept_tcp=True, + created_on=datetime.datetime(2020, 1, 1), + modified_on=datetime.datetime(2020, 1, 1), + registration_key="", + registration_id="", + reset_password_key="", + ) + ) + await grant_course_grader(course.id, user.id) + return user + + @pytest_asyncio.fixture async def auth_student_client(student_user): """ @@ -171,6 +208,27 @@ async def auth_editor_client(editor_user): app.dependency_overrides[auth_manager] = prior_override +@pytest_asyncio.fixture +async def auth_delegated_grader_client(delegated_grader_user): + """Async client authenticated as a delegated grader, not an instructor.""" + from rsptx.assignment_server_api.core import app + from rsptx.auth.session import auth_manager + + mock_auth = AsyncMock(return_value=delegated_grader_user) + prior_override = app.dependency_overrides.get(auth_manager) + app.dependency_overrides[auth_manager] = lambda: delegated_grader_user + transport = httpx.ASGITransport(app=app) + with patch("rsptx.endpoint_validators.core.auth_manager", mock_auth): + async with httpx.AsyncClient( + transport=transport, base_url="http://test" + ) as client: + yield client + if prior_override is None: + app.dependency_overrides.pop(auth_manager, None) + else: + app.dependency_overrides[auth_manager] = prior_override + + @pytest_asyncio.fixture(scope="session") async def auth_instructor_client(instructor_user): """ diff --git a/test/bases/rsptx/assignment_server_api/test_delegated_grader_routes.py b/test/bases/rsptx/assignment_server_api/test_delegated_grader_routes.py new file mode 100644 index 000000000..608f692b4 --- /dev/null +++ b/test/bases/rsptx/assignment_server_api/test_delegated_grader_routes.py @@ -0,0 +1,107 @@ +"""Route tests for the assignment-scoped delegated-grader contract.""" + +import datetime +import uuid + +import pytest + +from rsptx.db.crud import ( + create_assignment, + fetch_course, + set_assignment_blind_grading, +) +from rsptx.db.models import AssignmentValidator + + +pytestmark = pytest.mark.asyncio(loop_scope="session") + + +async def _make_assignment(*, blind_grading: bool): + course = await fetch_course("test_course_1") + assignment = await create_assignment( + AssignmentValidator( + course=course.id, + name=f"Delegated grader route {uuid.uuid4().hex}", + points=0, + released=False, + duedate=datetime.datetime(2099, 1, 1), + visible=True, + from_source=False, + is_peer=False, + current_index=0, + peer_async_visible=False, + ) + ) + if blind_grading: + await set_assignment_blind_grading(assignment.id, True) + return assignment + + +async def test_instructor_capabilities_keep_student_identities( + auth_instructor_client, +): + assignment = await _make_assignment(blind_grading=False) + + response = await auth_instructor_client.get( + f"/grader/assignments/{assignment.id}/capabilities" + ) + + assert response.status_code == 200 + assert response.json()["detail"] == { + "role": "instructor", + "can_grade": True, + "can_view_student_identities": True, + "assignment_blind_grading": False, + } + + +async def test_delegated_grader_capabilities_are_anonymous_for_blind_assignment( + auth_delegated_grader_client, +): + assignment = await _make_assignment(blind_grading=True) + + response = await auth_delegated_grader_client.get( + f"/grader/assignments/{assignment.id}/capabilities" + ) + + assert response.status_code == 200 + assert response.json()["detail"] == { + "role": "delegated_grader", + "can_grade": True, + "can_view_student_identities": False, + "assignment_blind_grading": True, + } + + +async def test_delegated_grader_cannot_grade_identified_assignment( + auth_delegated_grader_client, +): + assignment = await _make_assignment(blind_grading=False) + + response = await auth_delegated_grader_client.get( + f"/grader/assignments/{assignment.id}/capabilities" + ) + + assert response.status_code == 403 + assert response.json()["detail"] == "Grading access denied" + + +async def test_student_cannot_claim_blind_grading_capabilities(auth_student_client): + assignment = await _make_assignment(blind_grading=True) + + response = await auth_student_client.get( + f"/grader/assignments/{assignment.id}/capabilities" + ) + + assert response.status_code == 403 + + +async def test_delegated_grader_still_cannot_read_identity_bearing_answers( + auth_delegated_grader_client, +): + response = await auth_delegated_grader_client.get( + "/instructor/grader/questions/answers", + params={"assignment_id": 1, "question_id": 1}, + ) + + assert response.status_code == 401