Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 2 additions & 0 deletions bases/rsptx/assignment_server_api/core.py
Original file line number Diff line number Diff line change
Expand Up @@ -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
Expand Down Expand Up @@ -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)
Expand Down
78 changes: 78 additions & 0 deletions bases/rsptx/assignment_server_api/routers/delegated_grader.py
Original file line number Diff line number Diff line change
@@ -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,
)
}
58 changes: 58 additions & 0 deletions test/bases/rsptx/assignment_server_api/conftest.py
Original file line number Diff line number Diff line change
Expand Up @@ -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):
"""
Expand Down Expand Up @@ -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):
"""
Expand Down
Original file line number Diff line number Diff line change
@@ -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
Loading