Add automated CRUD test suite with GitHub Actions CI

- Configure pytest-asyncio (auto mode, session loop scope) in pyproject.toml
- Add test/conftest.py: sets SERVER_CONFIG=test and TEST_DBURL env vars before
  any rsptx imports; session-scoped init_test_db fixture drops/recreates tables
  and seeds base courses + testuser1 via create_initial_courses_users()
- Add test/components/rsptx/db/conftest.py: session-scoped fixtures for
  test_user, test_course, and overview_course
- Replace broken test_crud.py skeleton with smoke tests for seeded data
- Add test_user.py: full CRUD cycle for auth_user (create, fetch, update,
  duplicate detection, delete)
- Add test_course.py: fetch by name/id, create, nonexistent returns None
- Add test_rslogging.py: create_useinfo_entry, count_useinfo_for, poll summary
- Add test_question.py: question CRUD, question_grade create/fetch/update/
  duplicate handling
- Add test_assignment.py: assignment CRUD, assignment_question linking,
  visibility filtering
- Add .github/workflows/test-crud.yml: runs the 31 CRUD tests on every PR
  against a PostgreSQL 16 service container

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: bnmnetp

.github/workflows/test-crud.yml

@@ -0,0 +1,67 @@
+name: CRUD Tests
+
+on:
+  pull_request:
+    paths:
+      - 'components/rsptx/db/**'
+      - 'components/rsptx/configuration/**'
+      - 'components/rsptx/validation/**'
+      - 'components/rsptx/response_helpers/**'
+      - 'test/components/rsptx/db/**'
+      - 'test/conftest.py'
+      - '.github/workflows/test-crud.yml'
+      - 'pyproject.toml'
+
+jobs:
+  crud-tests:
+    runs-on: ubuntu-latest
+
+    services:
+      postgres:
+        image: postgres:16
+        env:
+          POSTGRES_USER: runestone
+          POSTGRES_PASSWORD: runestone
+          POSTGRES_DB: runestone_test
+        ports:
+          - 5432:5432
+        options: >-
+          --health-cmd pg_isready
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+
+    env:
+      SERVER_CONFIG: test
+      TEST_DBURL: postgresql://runestone:runestone@localhost:5432/runestone_test
+      DROP_TABLES: "Yes"
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.10'
+
+      - name: Install Poetry
+        uses: snok/install-poetry@v1
+        with:
+          virtualenvs-create: true
+          virtualenvs-in-project: true
+
+      - name: Cache Poetry virtualenv
+        uses: actions/cache@v4
+        with:
+          path: .venv
+          key: venv-${{ runner.os }}-py3.10-${{ hashFiles('pyproject.toml', 'poetry.lock') }}
+          restore-keys: |
+            venv-${{ runner.os }}-py3.10-
+
+      - name: Install dependencies
+        run: poetry install --with dev --no-interaction
+
+      - name: Run CRUD tests
+        run: |
+          poetry run pytest test/components/rsptx/db/ -v --tb=short

pyproject.toml

@@ -175,6 +175,10 @@ exclude = [
     "bases/rsptx/library_server_api",
 ]
 
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "session"
+
 [tool.black]
 line-length = 88
 

test/components/rsptx/db/conftest.py

@@ -0,0 +1,32 @@
+"""
+Database-layer test fixtures.
+
+All fixtures here depend on `init_test_db` (defined in test/conftest.py) to
+ensure the database is initialised and seeded before use.
+"""
+
+import pytest
+
+
+@pytest.fixture(scope="session")
+async def test_user(init_test_db):
+    """Return the seeded testuser1 AuthUserValidator."""
+    from rsptx.db.crud import fetch_user
+
+    return await fetch_user("testuser1")
+
+
+@pytest.fixture(scope="session")
+async def test_course(init_test_db):
+    """Return the seeded test_course_1 CoursesValidator."""
+    from rsptx.db.crud import fetch_course
+
+    return await fetch_course("test_course_1")
+
+
+@pytest.fixture(scope="session")
+async def overview_course(init_test_db):
+    """Return the seeded overview course (testuser1's home course)."""
+    from rsptx.db.crud import fetch_course
+
+    return await fetch_course("overview")

test/components/rsptx/db/test_assignment.py

@@ -0,0 +1,123 @@
+"""
+Tests for assignment CRUD operations.
+"""
+import datetime
+import pytest
+
+pytestmark = pytest.mark.asyncio(loop_scope="session")
+
+from rsptx.db.crud import (
+    fetch_assignments,
+    fetch_one_assignment,
+    create_assignment,
+    update_assignment,
+    create_assignment_question,
+    create_question,
+)
+from rsptx.db.models import AssignmentValidator, AssignmentQuestionValidator, QuestionValidator
+from rsptx.response_helpers.core import canonical_utcnow
+
+COURSE_NAME = "test_course_1"
+ASSIGN_NAME = "crud_test_assignment"
+Q_NAME = "crud_assign_question_1"
+
+
+@pytest.fixture(scope="session")
+async def test_question_for_assignment(init_test_db):
+    """A question to attach to assignments."""
+    return await create_question(
+        QuestionValidator(
+            base_course=COURSE_NAME,
+            name=Q_NAME,
+            chapter="ch1",
+            subchapter="sub1",
+            author="testuser1",
+            question="Assignment test question?",
+            timestamp=canonical_utcnow(),
+            question_type="mchoice",
+            is_private=False,
+            from_source=False,
+            review_flag=False,
+        )
+    )
+
+
+@pytest.fixture(scope="session")
+async def test_assignment(test_course, test_question_for_assignment):
+    """Create an assignment for this module's tests."""
+    assignment = await create_assignment(
+        AssignmentValidator(
+            course=test_course.id,
+            name=ASSIGN_NAME,
+            points=10,
+            released=False,
+            description="CRUD test assignment",
+            duedate=datetime.datetime(2099, 1, 1),
+            visible=True,
+            from_source=False,
+            is_peer=False,
+            current_index=0,
+            peer_async_visible=False,
+        )
+    )
+    return assignment
+
+
+async def test_create_assignment(test_assignment):
+    """Created assignment has an id and correct name."""
+    assert test_assignment is not None
+    assert test_assignment.id is not None
+    assert test_assignment.name == ASSIGN_NAME
+    assert test_assignment.course is not None
+
+
+async def test_fetch_assignments(test_assignment):
+    """fetch_assignments returns a list that includes our assignment."""
+    assignments = await fetch_assignments(COURSE_NAME, fetch_all=True)
+    names = [a.name for a in assignments]
+    assert ASSIGN_NAME in names
+
+
+async def test_fetch_one_assignment(test_assignment):
+    """fetch_one_assignment returns the correct assignment by id."""
+    fetched = await fetch_one_assignment(test_assignment.id)
+    assert fetched is not None
+    assert fetched.id == test_assignment.id
+    assert fetched.name == ASSIGN_NAME
+
+
+async def test_update_assignment(test_assignment):
+    """Updating the description persists."""
+    updated = AssignmentValidator(**test_assignment.dict())
+    updated.description = "Updated description"
+    await update_assignment(updated)
+
+    fetched = await fetch_one_assignment(test_assignment.id)
+    assert fetched.description == "Updated description"
+
+
+async def test_create_assignment_question(test_assignment, test_question_for_assignment):
+    """Adding a question to an assignment persists."""
+    aq = await create_assignment_question(
+        AssignmentQuestionValidator(
+            assignment_id=test_assignment.id,
+            question_id=test_question_for_assignment.id,
+            points=10,
+            activities_required=0,
+            reading_assignment=False,
+            sorting_priority=0,
+            which_to_grade="best_answer",
+            autograde="pct_correct",
+        )
+    )
+    assert aq is not None
+    assert aq.id is not None
+    assert aq.assignment_id == test_assignment.id
+    assert aq.question_id == test_question_for_assignment.id
+
+
+async def test_fetch_visible_assignments(test_assignment):
+    """is_visible filter returns our visible assignment."""
+    visible = await fetch_assignments(COURSE_NAME, is_visible=True)
+    names = [a.name for a in visible]
+    assert ASSIGN_NAME in names

test/components/rsptx/db/test_course.py

@@ -0,0 +1,65 @@
+"""
+Tests for course CRUD operations.
+"""
+import datetime
+import pytest
+
+pytestmark = pytest.mark.asyncio(loop_scope="session")
+
+from rsptx.db.crud import fetch_course, fetch_course_by_id, create_course
+from rsptx.db.models import CoursesValidator
+
+NEW_COURSE_NAME = "crud_test_course"
+
+
+@pytest.fixture(scope="session")
+async def new_course(init_test_db):
+    """Create a transient test course for the duration of this module."""
+    course = await create_course(
+        CoursesValidator(
+            course_name=NEW_COURSE_NAME,
+            base_course="overview",
+            term_start_date=datetime.date(2024, 1, 1),
+            login_required=False,
+            allow_pairs=False,
+            downloads_enabled=False,
+            courselevel="",
+            institution="Test University",
+            new_server=True,
+        )
+    )
+    yield course
+
+
+async def test_fetch_seeded_course(test_course):
+    """test_course_1 must exist after seed."""
+    assert test_course is not None
+    assert test_course.course_name == "test_course_1"
+
+
+async def test_create_course(new_course):
+    """Created course is returned with an id."""
+    assert new_course is not None
+    assert new_course.id is not None
+    assert new_course.course_name == NEW_COURSE_NAME
+
+
+async def test_fetch_course_by_name(new_course):
+    """Fetching by name returns the newly created course."""
+    fetched = await fetch_course(NEW_COURSE_NAME)
+    assert fetched is not None
+    assert fetched.course_name == NEW_COURSE_NAME
+    assert fetched.institution == "Test University"
+
+
+async def test_fetch_course_by_id(new_course):
+    """Fetching by id returns the same course."""
+    fetched = await fetch_course_by_id(new_course.id)
+    assert fetched is not None
+    assert fetched.course_name == NEW_COURSE_NAME
+
+
+async def test_fetch_nonexistent_course():
+    """Fetching a missing course returns None-wrapped validator."""
+    result = await fetch_course("this_course_does_not_exist_xyz")
+    assert result is None or result.course_name is None

test/components/rsptx/db/test_crud.py

@@ -1,69 +1,33 @@
-from rsptx.db.crud import *
+"""
+Smoke tests for the top-level crud module (create_initial_courses_users, etc.).
+
+The detailed per-domain tests live in test_user.py, test_course.py,
+test_rslogging.py, test_question.py, and test_assignment.py.
+"""
 import pytest
-import asyncio
 
+pytestmark = pytest.mark.asyncio(loop_scope="session")
+
+from rsptx.db import crud
+from rsptx.db.crud import fetch_user, fetch_course
 
-@pytest.mark.asyncio
-async def test_create_useinfo_entry():
-    assert create_useinfo_entry is not None
-    # Write the code for the test here.
-    # Tip: use the pytest.raises context manager to test for exceptions.
-    # create and new entry
-    with pytest.raises(Exception):
-        create_useinfo_entry(
-            sid="test_sid",
-            div_id="test_div_id",
-            event="test_event",
-            act="test_act",
-            timestamp="test_timestamp",
-            course_id="test_course_id",
-            chapter="test_chapter",
-            subchapter="test_subchapter",
-            session="test_session",
-            ip_address="test_ip_address",
-        )
-    x = await create_useinfo_entry(
-        sid="test_sid",
-        div_id="test_div_id",
-        event="test_event",
-        act="test_act",
-        timestamp="test_timestamp",
-        course_id="test_course_id",
-        chapter="test_chapter",
-        subchapter="test_subchapter",
-        session="test_session",
-        ip_address="test_ip_address",
-    )
-    assert x is not None
-    assert x.sid == "test_sid"
-    assert x.div_id == "test_div_id"
-    assert x.event == "test_event"
-    assert x.act == "test_act"
-    assert x.timestamp == "test_timestamp"
-    assert x.course_id == "test_course_id"
-    assert x.chapter == "test_chapter"
-    assert x.subchapter == "test_subchapter"
-    assert x.session == "test_session"
-    assert x.ip_address == "test_ip_address"
 
+async def test_crud_module_importable():
+    """The crud module must be importable."""
+    assert crud is not None
 
-@pytest.mark.asyncio
-async def test_create_question_grade_entry():
-    # Test creating a new QuestionGrade entry
-    sid = "test_sid"
-    course_name = "test_course"
-    qid = "test_qid"
-    grade = 85
 
-    # Call the function to create a new QuestionGrade entry
-    new_qg = await create_question_grade_entry(sid, course_name, qid, grade)
+async def test_seeded_courses_exist(init_test_db):
+    """create_initial_courses_users must have seeded the expected base courses."""
+    for course_name in ("overview", "test_course_1", "fopp", "thinkcspy"):
+        course = await fetch_course(course_name)
+        assert course is not None, f"Expected seeded course '{course_name}' not found"
+        assert course.course_name == course_name
 
-    # Assert that the returned object is not None
-    assert new_qg is not None
 
-    # Assert that the returned object has the correct attributes
-    assert new_qg.sid == sid
-    assert new_qg.course_name == course_name
-    assert new_qg.div_id == qid
-    assert new_qg.score == grade
-    assert new_qg.comment == "autograded"
+async def test_seeded_user_exists(init_test_db):
+    """testuser1 must exist after seeding."""
+    user = await fetch_user("testuser1")
+    assert user is not None
+    assert user.username == "testuser1"
+    assert user.email == "testuser1@example.com"