Use pytest for testing

Author: JelteF

.github/workflows/ci.yaml

@@ -81,5 +81,8 @@ jobs:
       - name: Install dependencies
         run: uv sync
 
+      - name: Run migrations
+        run: uv run manage.py migrate --noinput
+
       - name: Run tests
-        run: uv run manage.py test --verbosity=2
+        run: uv run pytest

pgcommitfest/commitfest/tests/test_apiv1.py

@@ -1,159 +1,94 @@
-from django.test import Client, TestCase, override_settings
+from django.test import override_settings
 
 import json
-from datetime import date, timedelta
+from datetime import date
 
-from pgcommitfest.commitfest.models import CommitFest
+import pytest
 
+from pgcommitfest.commitfest.models import CommitFest
 
-@override_settings(AUTO_CREATE_COMMITFESTS=False)
-class NeedsCIEndpointTestCase(TestCase):
-    """Test the /api/v1/commitfests/needs_ci endpoint."""
+pytestmark = pytest.mark.django_db
 
-    @classmethod
-    def setUpTestData(cls):
-        today = date.today()
 
-        # Create test commitfests with various statuses
-        cls.open_cf = CommitFest.objects.create(
+@pytest.fixture
+def commitfests():
+    """Create test commitfests with various statuses."""
+    return {
+        "open": CommitFest.objects.create(
             name="2025-01",
             status=CommitFest.STATUS_OPEN,
-            startdate=today - timedelta(days=30),
-            enddate=today + timedelta(days=30),
+            startdate=date(2025, 1, 1),
+            enddate=date(2025, 1, 31),
             draft=False,
-        )
-
-        cls.in_progress_cf = CommitFest.objects.create(
+        ),
+        "in_progress": CommitFest.objects.create(
             name="2024-11",
             status=CommitFest.STATUS_INPROGRESS,
-            startdate=today - timedelta(days=60),
-            enddate=today + timedelta(days=0),
+            startdate=date(2024, 11, 1),
+            enddate=date(2024, 11, 30),
             draft=False,
-        )
-
-        # Previous CF that ended 3 days ago (should be included - within 7 day window)
-        cls.recent_previous_cf = CommitFest.objects.create(
+        ),
+        "recent_previous": CommitFest.objects.create(
             name="2024-09",
             status=CommitFest.STATUS_CLOSED,
-            startdate=today - timedelta(days=90),
-            enddate=today - timedelta(days=3),
+            startdate=date(2024, 9, 1),
+            enddate=date(2024, 9, 30),
             draft=False,
-        )
-
-        # Old previous CF that ended 10 days ago (should be excluded - outside 7 day window)
-        cls.old_previous_cf = CommitFest.objects.create(
+        ),
+        "old_previous": CommitFest.objects.create(
             name="2024-07",
             status=CommitFest.STATUS_CLOSED,
-            startdate=today - timedelta(days=120),
-            enddate=today - timedelta(days=10),
+            startdate=date(2024, 7, 1),
+            enddate=date(2024, 7, 31),
             draft=False,
-        )
-
-        # Draft commitfest
-        cls.draft_cf = CommitFest.objects.create(
+        ),
+        "draft": CommitFest.objects.create(
             name="2025-03-draft",
             status=CommitFest.STATUS_OPEN,
-            startdate=today + timedelta(days=60),
-            enddate=today + timedelta(days=120),
+            startdate=date(2025, 3, 1),
+            enddate=date(2025, 3, 31),
             draft=True,
-        )
-
-    def setUp(self):
-        self.client = Client()
-
-    def test_endpoint_returns_200(self):
-        """Test that the endpoint returns HTTP 200 OK."""
-        response = self.client.get("/api/v1/commitfests/needs_ci")
-        self.assertEqual(response.status_code, 200)
-
-    def test_response_is_valid_json(self):
-        """Test that the response is valid JSON."""
-        response = self.client.get("/api/v1/commitfests/needs_ci")
-        try:
-            data = json.loads(response.content)
-        except json.JSONDecodeError:
-            self.fail("Response is not valid JSON")
-
-        self.assertIn("commitfests", data)
-        self.assertIsInstance(data["commitfests"], dict)
-
-    def test_response_content_type(self):
-        """Test that the response has correct Content-Type header."""
-        response = self.client.get("/api/v1/commitfests/needs_ci")
-        self.assertEqual(response["Content-Type"], "application/json")
-
-    def test_cors_header_present(self):
-        """Test that CORS header is present for API access."""
-        response = self.client.get("/api/v1/commitfests/needs_ci")
-        self.assertEqual(response["Access-Control-Allow-Origin"], "*")
-
-    def test_includes_open_commitfest(self):
-        """Test that open commitfests are included in response."""
-        response = self.client.get("/api/v1/commitfests/needs_ci")
-        data = json.loads(response.content)
-        commitfests = data["commitfests"]
-
-        # Should include the open commitfest
-        self.assertIn("open", commitfests)
-        self.assertEqual(commitfests["open"]["name"], self.open_cf.name)
-
-    def test_includes_in_progress_commitfest(self):
-        """Test that in-progress commitfests are included in response."""
-        response = self.client.get("/api/v1/commitfests/needs_ci")
-        data = json.loads(response.content)
-        commitfests = data["commitfests"]
-
-        # Should include the in-progress commitfest
-        self.assertEqual(commitfests["in_progress"]["name"], self.in_progress_cf.name)
-
-    def test_includes_recent_previous_commitfest(self):
-        """Test that recently ended commitfests are included (within 7 days)."""
-        response = self.client.get("/api/v1/commitfests/needs_ci")
-        data = json.loads(response.content)
-        commitfests = data["commitfests"]
-
-        # Should include recent previous commitfest (ended 3 days ago)
-        self.assertIsNotNone(commitfests["previous"])
-
-    def test_excludes_old_previous_commitfest(self):
-        """Test that old commitfests are excluded (older than 7 days)."""
-        response = self.client.get("/api/v1/commitfests/needs_ci")
-        data = json.loads(response.content)
-        commitfests = data["commitfests"]
-
-        # Should not include old previous commitfest (ended 10 days ago)
-        self.assertNotEqual(
-            commitfests["previous"]["name"],
-            self.old_previous_cf.name,
-            "Old previous commitfest should be excluded",
-        )
-
-    def test_excludes_next_open_and_final(self):
-        """Test that next_open and final are excluded from response."""
-        response = self.client.get("/api/v1/commitfests/needs_ci")
-        data = json.loads(response.content)
-        commitfests = data["commitfests"]
-
-        # These keys should not be present in the response
-        self.assertNotIn("next_open", commitfests)
-        self.assertNotIn("final", commitfests)
-
-    def test_response_structure(self):
-        """Test that response has expected structure."""
-        response = self.client.get("/api/v1/commitfests/needs_ci")
-        data = json.loads(response.content)
-
-        # Top-level structure
-        self.assertIn("commitfests", data)
-        self.assertIsInstance(data["commitfests"], dict)
-
-        # Check that commitfest objects have expected fields
-        commitfests = data["commitfests"]
-        for key, cf_data in commitfests.items():
-            self.assertIsInstance(cf_data, dict)
-            # Basic fields that should be present
-            self.assertIn("id", cf_data)
-            self.assertIn("name", cf_data)
-            self.assertIn("status", cf_data)
-            self.assertIn("startdate", cf_data)
-            self.assertIn("enddate", cf_data)
+        ),
+    }
+
+
+def test_needs_ci_endpoint(client, commitfests):
+    """Test the /api/v1/commitfests/needs_ci endpoint returns correct data."""
+    with override_settings(AUTO_CREATE_COMMITFESTS=False):
+        response = client.get("/api/v1/commitfests/needs_ci")
+
+    # Check response metadata
+    assert response.status_code == 200
+    assert response["Content-Type"] == "application/json"
+    assert response["Access-Control-Allow-Origin"] == "*"
+
+    # Parse and compare response
+    data = json.loads(response.content)
+
+    expected = {
+        "commitfests": {
+            "open": {
+                "id": commitfests["open"].id,
+                "name": "2025-01",
+                "status": "Open",
+                "startdate": "2025-01-01",
+                "enddate": "2025-01-31",
+            },
+            "in_progress": {
+                "id": commitfests["in_progress"].id,
+                "name": "2024-11",
+                "status": "In Progress",
+                "startdate": "2024-11-01",
+                "enddate": "2024-11-30",
+            },
+            "draft": {
+                "id": commitfests["draft"].id,
+                "name": "2025-03-draft",
+                "status": "Open",
+                "startdate": "2025-03-01",
+                "enddate": "2025-03-31",
+            },
+        }
+    }
+
+    assert data == expected

pyproject.toml

@@ -18,6 +18,8 @@ dev = [
     "pycodestyle",
     "ruff",
     "djhtml",
+    "pytest",
+    "pytest-django",
 ]
 
 [tool.setuptools.packages.find]
@@ -47,3 +49,13 @@ section-order = [
 [tool.ruff.lint.isort.sections]
 # Group all Django imports into a separate section.
 django = ["django"]
+
+[tool.pytest.ini_options]
+DJANGO_SETTINGS_MODULE = "pgcommitfest.settings"
+python_files = ["tests.py", "test_*.py", "*_tests.py"]
+testpaths = ["pgcommitfest"]
+addopts = [
+    "--reuse-db",
+    "--strict-markers",
+    "-vv",
+]