| Tags |
diff --git a/pgcommitfest/commitfest/tests/__init__.py b/pgcommitfest/commitfest/tests/__init__.py
new file mode 100644
index 00000000..7d5a9d90
--- /dev/null
+++ b/pgcommitfest/commitfest/tests/__init__.py
@@ -0,0 +1 @@
+# Tests for the commitfest application
diff --git a/pgcommitfest/commitfest/tests/conftest.py b/pgcommitfest/commitfest/tests/conftest.py
new file mode 100644
index 00000000..baff4328
--- /dev/null
+++ b/pgcommitfest/commitfest/tests/conftest.py
@@ -0,0 +1,139 @@
+"""Shared test fixtures for commitfest tests."""
+
+from django.contrib.auth.models import User
+
+from datetime import date
+
+import pytest
+
+from pgcommitfest.commitfest.models import CommitFest
+from pgcommitfest.userprofile.models import UserProfile
+
+
+@pytest.fixture
+def alice():
+ """Create test user Alice with a profile (uses default notify_all_author=True)."""
+ user = User.objects.create_user(
+ username="alice",
+ first_name="Alice",
+ last_name="Anderson",
+ email="alice@example.com",
+ )
+ UserProfile.objects.create(user=user)
+ return user
+
+
+@pytest.fixture
+def bob():
+ """Create test user Bob."""
+ return User.objects.create_user(
+ username="b",
+ first_name="Bob",
+ last_name="Brown",
+ email="bob@example.com",
+ )
+
+
+@pytest.fixture
+def charlie():
+ """Create test user Charlie."""
+ return User.objects.create_user(
+ username="charlie",
+ first_name="Charlie",
+ last_name="Chen",
+ email="charlie@example.com",
+ )
+
+
+@pytest.fixture
+def dave():
+ """Create test user Dave."""
+ return User.objects.create_user(
+ username="dave",
+ first_name="Dave",
+ last_name="Davis",
+ email="dave@example.com",
+ )
+
+
+@pytest.fixture
+def users(alice, bob, charlie, dave):
+ """Create all test users and return as a dictionary."""
+ return {
+ "alice": alice,
+ "bob": bob,
+ "charlie": charlie,
+ "dave": dave,
+ }
+
+
+@pytest.fixture
+def open_cf():
+ """Create an open commitfest."""
+ return CommitFest.objects.create(
+ name="2025-01",
+ status=CommitFest.STATUS_OPEN,
+ startdate=date(2025, 1, 1),
+ enddate=date(2025, 1, 31),
+ draft=False,
+ )
+
+
+@pytest.fixture
+def in_progress_cf():
+ """Create an in-progress commitfest."""
+ return CommitFest.objects.create(
+ name="2024-11",
+ status=CommitFest.STATUS_INPROGRESS,
+ startdate=date(2024, 11, 1),
+ enddate=date(2024, 11, 30),
+ draft=False,
+ )
+
+
+@pytest.fixture
+def recent_closed_cf():
+ """Create a recently closed commitfest."""
+ return CommitFest.objects.create(
+ name="2024-09",
+ status=CommitFest.STATUS_CLOSED,
+ startdate=date(2024, 9, 1),
+ enddate=date(2024, 9, 30),
+ draft=False,
+ )
+
+
+@pytest.fixture
+def old_closed_cf():
+ """Create an old closed commitfest."""
+ return CommitFest.objects.create(
+ name="2024-07",
+ status=CommitFest.STATUS_CLOSED,
+ startdate=date(2024, 7, 1),
+ enddate=date(2024, 7, 31),
+ draft=False,
+ )
+
+
+@pytest.fixture
+def draft_cf():
+ """Create a draft commitfest."""
+ return CommitFest.objects.create(
+ name="2025-03-draft",
+ status=CommitFest.STATUS_OPEN,
+ startdate=date(2025, 3, 1),
+ enddate=date(2025, 3, 31),
+ draft=True,
+ )
+
+
+@pytest.fixture
+def commitfests(open_cf, in_progress_cf, recent_closed_cf, old_closed_cf, draft_cf):
+ """Create all test commitfests and return as a dictionary."""
+ return {
+ "open": open_cf,
+ "in_progress": in_progress_cf,
+ "recent_previous": recent_closed_cf,
+ "old_previous": old_closed_cf,
+ "draft": draft_cf,
+ }
diff --git a/pgcommitfest/commitfest/tests/test_apiv1.py b/pgcommitfest/commitfest/tests/test_apiv1.py
new file mode 100644
index 00000000..10e1b718
--- /dev/null
+++ b/pgcommitfest/commitfest/tests/test_apiv1.py
@@ -0,0 +1,162 @@
+import json
+from datetime import datetime, timezone
+
+import pytest
+
+from pgcommitfest.commitfest.models import (
+ MailThread,
+ Patch,
+ PatchOnCommitFest,
+)
+
+pytestmark = pytest.mark.django_db
+
+
+def test_needs_ci_endpoint(client, commitfests):
+ """Test the /api/v1/commitfests/needs_ci endpoint returns correct data."""
+ 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
+
+
+def test_commitfest_patches_endpoint(client, open_cf, alice, bob):
+ """Test the /api/v1/commitfests//patches endpoint."""
+ # Create test patches
+ patch1 = Patch.objects.create(name="Add feature X")
+ patch1.authors.add(alice)
+ patch1.lastmail = datetime(2025, 1, 15, 10, 30, 0, tzinfo=timezone.utc)
+ patch1.save()
+
+ patch2 = Patch.objects.create(name="Fix bug Y")
+ patch2.authors.add(alice, bob)
+ patch2.save()
+
+ # Link patches to commitfest
+ PatchOnCommitFest.objects.create(
+ patch=patch1,
+ commitfest=open_cf,
+ enterdate=datetime.now(),
+ status=PatchOnCommitFest.STATUS_REVIEW,
+ )
+ PatchOnCommitFest.objects.create(
+ patch=patch2,
+ commitfest=open_cf,
+ enterdate=datetime.now(),
+ status=PatchOnCommitFest.STATUS_AUTHOR,
+ )
+
+ response = client.get(f"/api/v1/commitfests/{open_cf.id}/patches")
+
+ assert response.status_code == 200
+ assert response["Content-Type"] == "application/json"
+ assert response["Access-Control-Allow-Origin"] == "*"
+
+ data = json.loads(response.content)
+
+ assert data["commitfest_id"] == open_cf.id
+ assert len(data["patches"]) == 2
+
+ # Patches are ordered by id
+ p1 = data["patches"][0]
+ assert p1["id"] == patch1.id
+ assert p1["name"] == "Add feature X"
+ assert p1["status"] == "Needs review"
+ assert p1["authors"] == ["Alice Anderson"]
+ assert p1["last_email_time"] == "2025-01-15T10:30:00+00:00"
+
+ p2 = data["patches"][1]
+ assert p2["id"] == patch2.id
+ assert p2["name"] == "Fix bug Y"
+ assert p2["status"] == "Waiting on Author"
+ assert sorted(p2["authors"]) == ["Alice Anderson", "Bob Brown"]
+ assert p2["last_email_time"] is None
+
+
+def test_commitfest_patches_endpoint_not_found(client, commitfests):
+ """Test the patches endpoint returns 404 for non-existent commitfest."""
+ response = client.get("/api/v1/commitfests/99999/patches")
+ assert response.status_code == 404
+
+
+def test_patch_threads_endpoint(client, open_cf, alice):
+ """Test the /api/v1/patches//threads endpoint."""
+ patch = Patch.objects.create(name="Test patch")
+ patch.authors.add(alice)
+
+ PatchOnCommitFest.objects.create(
+ patch=patch,
+ commitfest=open_cf,
+ enterdate=datetime.now(),
+ status=PatchOnCommitFest.STATUS_REVIEW,
+ )
+
+ # Create mail threads
+ thread1 = MailThread.objects.create(
+ messageid="abc123@example.com",
+ subject="[PATCH] Test patch v1",
+ firstmessage=datetime(2025, 1, 10, 9, 0, 0, tzinfo=timezone.utc),
+ firstauthor="alice@example.com",
+ latestmessage=datetime(2025, 1, 12, 14, 30, 0, tzinfo=timezone.utc),
+ latestauthor="bob@example.com",
+ latestsubject="Re: [PATCH] Test patch v1",
+ latestmsgid="def456@example.com",
+ )
+ patch.mailthread_set.add(thread1)
+
+ response = client.get(f"/api/v1/patches/{patch.id}/threads")
+
+ assert response.status_code == 200
+ assert response["Content-Type"] == "application/json"
+
+ data = json.loads(response.content)
+
+ assert data["patch_id"] == patch.id
+ assert data["name"] == "Test patch"
+ assert len(data["threads"]) == 1
+
+ t = data["threads"][0]
+ assert t["messageid"] == "abc123@example.com"
+ assert t["subject"] == "[PATCH] Test patch v1"
+ assert t["latest_message_id"] == "def456@example.com"
+ assert t["latest_message_time"] == "2025-01-12T14:30:00+00:00"
+ assert t["has_attachment"] is False
+
+
+def test_patch_threads_endpoint_not_found(client, commitfests):
+ """Test the threads endpoint returns 404 for non-existent patch."""
+ response = client.get("/api/v1/patches/99999/threads")
+ assert response.status_code == 404
diff --git a/pgcommitfest/commitfest/tests/test_closure_notifications.py b/pgcommitfest/commitfest/tests/test_closure_notifications.py
new file mode 100644
index 00000000..eb7cfc7a
--- /dev/null
+++ b/pgcommitfest/commitfest/tests/test_closure_notifications.py
@@ -0,0 +1,443 @@
+from django.conf import settings
+
+import base64
+from datetime import date, datetime, timedelta
+from email import message_from_string
+
+import pytest
+
+from pgcommitfest.commitfest.models import (
+ CfbotBranch,
+ CommitFest,
+ Patch,
+ PatchHistory,
+ PatchOnCommitFest,
+ PendingNotification,
+)
+from pgcommitfest.mailqueue.models import QueuedMail
+from pgcommitfest.userprofile.models import UserProfile
+
+pytestmark = pytest.mark.django_db
+
+
+def get_email_body(queued_mail):
+ """Extract and decode the email body from a QueuedMail object."""
+ msg = message_from_string(queued_mail.fullmsg)
+ for part in msg.walk():
+ if part.get_content_type() == "text/plain":
+ payload = part.get_payload()
+ return base64.b64decode(payload).decode("utf-8")
+ return ""
+
+
+def test_send_closure_notifications_to_authors_of_open_patches(alice, in_progress_cf):
+ """Authors of patches with open status should receive closure notifications."""
+ patch = Patch.objects.create(name="Test Patch")
+ patch.authors.add(alice)
+ PatchOnCommitFest.objects.create(
+ patch=patch,
+ commitfest=in_progress_cf,
+ enterdate=datetime.now(),
+ status=PatchOnCommitFest.STATUS_REVIEW,
+ )
+
+ in_progress_cf.send_closure_notifications()
+
+ assert QueuedMail.objects.count() == 1
+ mail = QueuedMail.objects.first()
+ assert mail.receiver == alice.email
+ assert f"Commitfest {in_progress_cf.name} has closed" in mail.fullmsg
+ body = get_email_body(mail)
+ assert "Test Patch" in body
+
+
+def test_no_notification_for_committed_patches(alice, in_progress_cf):
+ """Authors of committed patches should not receive notifications."""
+ patch = Patch.objects.create(name="Committed Patch")
+ patch.authors.add(alice)
+ PatchOnCommitFest.objects.create(
+ patch=patch,
+ commitfest=in_progress_cf,
+ enterdate=datetime.now(),
+ leavedate=datetime.now(),
+ status=PatchOnCommitFest.STATUS_COMMITTED,
+ )
+
+ in_progress_cf.send_closure_notifications()
+
+ assert QueuedMail.objects.count() == 0
+
+
+def test_no_notification_for_withdrawn_patches(alice, in_progress_cf, open_cf):
+ """Withdrawn patches should not receive notifications or be auto-moved."""
+ patch = Patch.objects.create(
+ name="Withdrawn Patch",
+ lastmail=datetime.now() - timedelta(days=5),
+ )
+ patch.authors.add(alice)
+ PatchOnCommitFest.objects.create(
+ patch=patch,
+ commitfest=in_progress_cf,
+ enterdate=datetime.now(),
+ leavedate=datetime.now(),
+ status=PatchOnCommitFest.STATUS_WITHDRAWN,
+ )
+
+ in_progress_cf.auto_move_active_patches()
+ in_progress_cf.send_closure_notifications()
+
+ assert QueuedMail.objects.count() == 0
+
+
+def test_one_email_per_author_with_multiple_patches(alice, in_progress_cf):
+ """An author with multiple open patches should receive one email listing all patches."""
+ patch1 = Patch.objects.create(name="Patch One")
+ patch1.authors.add(alice)
+ PatchOnCommitFest.objects.create(
+ patch=patch1,
+ commitfest=in_progress_cf,
+ enterdate=datetime.now(),
+ status=PatchOnCommitFest.STATUS_REVIEW,
+ )
+
+ patch2 = Patch.objects.create(name="Patch Two")
+ patch2.authors.add(alice)
+ PatchOnCommitFest.objects.create(
+ patch=patch2,
+ commitfest=in_progress_cf,
+ enterdate=datetime.now(),
+ status=PatchOnCommitFest.STATUS_AUTHOR,
+ )
+
+ in_progress_cf.send_closure_notifications()
+
+ assert QueuedMail.objects.count() == 1
+ mail = QueuedMail.objects.first()
+ body = get_email_body(mail)
+ assert "Patch One" in body
+ assert "Patch Two" in body
+
+
+def test_multiple_authors_receive_separate_emails(alice, bob, in_progress_cf):
+ """Each author of open patches should receive their own notification."""
+ patch1 = Patch.objects.create(name="Alice Patch")
+ patch1.authors.add(alice)
+ PatchOnCommitFest.objects.create(
+ patch=patch1,
+ commitfest=in_progress_cf,
+ enterdate=datetime.now(),
+ status=PatchOnCommitFest.STATUS_REVIEW,
+ )
+
+ patch2 = Patch.objects.create(name="Bob Patch")
+ patch2.authors.add(bob)
+ PatchOnCommitFest.objects.create(
+ patch=patch2,
+ commitfest=in_progress_cf,
+ enterdate=datetime.now(),
+ status=PatchOnCommitFest.STATUS_COMMITTER,
+ )
+
+ in_progress_cf.send_closure_notifications()
+
+ assert QueuedMail.objects.count() == 2
+ receivers = set(QueuedMail.objects.values_list("receiver", flat=True))
+ assert receivers == {alice.email, bob.email}
+
+
+def test_coauthors_both_receive_notification(alice, bob, in_progress_cf):
+ """Both co-authors of a patch should receive notifications."""
+ patch = Patch.objects.create(name="Coauthored Patch")
+ patch.authors.add(alice)
+ patch.authors.add(bob)
+ PatchOnCommitFest.objects.create(
+ patch=patch,
+ commitfest=in_progress_cf,
+ enterdate=datetime.now(),
+ status=PatchOnCommitFest.STATUS_REVIEW,
+ )
+
+ in_progress_cf.send_closure_notifications()
+
+ assert QueuedMail.objects.count() == 2
+ receivers = set(QueuedMail.objects.values_list("receiver", flat=True))
+ assert receivers == {alice.email, bob.email}
+
+
+def test_no_notification_for_author_who_opted_out(bob, in_progress_cf):
+ """Authors who explicitly opted out should not receive closure notifications."""
+ UserProfile.objects.create(user=bob, notify_all_author=False)
+ patch = Patch.objects.create(name="Test Patch")
+ patch.authors.add(bob)
+ PatchOnCommitFest.objects.create(
+ patch=patch,
+ commitfest=in_progress_cf,
+ enterdate=datetime.now(),
+ status=PatchOnCommitFest.STATUS_REVIEW,
+ )
+
+ in_progress_cf.send_closure_notifications()
+
+ assert QueuedMail.objects.count() == 0
+
+
+def test_notification_for_author_without_profile(bob, in_progress_cf):
+ """Authors without a UserProfile should receive notifications (opt-out default)."""
+ patch = Patch.objects.create(name="Test Patch")
+ patch.authors.add(bob)
+ PatchOnCommitFest.objects.create(
+ patch=patch,
+ commitfest=in_progress_cf,
+ enterdate=datetime.now(),
+ status=PatchOnCommitFest.STATUS_REVIEW,
+ )
+
+ in_progress_cf.send_closure_notifications()
+
+ assert QueuedMail.objects.count() == 1
+ mail = QueuedMail.objects.first()
+ assert mail.receiver == bob.email
+
+
+# Auto-move tests
+
+
+def test_auto_move_patch_with_recent_email_activity(
+ alice, bob, in_progress_cf, open_cf
+):
+ """Patches with recent email activity should be auto-moved to the next commitfest."""
+ patch = Patch.objects.create(
+ name="Active Patch",
+ lastmail=datetime.now() - timedelta(days=5),
+ )
+ patch.authors.add(alice)
+ patch.subscribers.add(bob) # Bob subscribes to get notifications
+ PatchOnCommitFest.objects.create(
+ patch=patch,
+ commitfest=in_progress_cf,
+ enterdate=datetime.now(),
+ status=PatchOnCommitFest.STATUS_REVIEW,
+ )
+
+ in_progress_cf.auto_move_active_patches()
+ in_progress_cf.send_closure_notifications()
+
+ # Patch should be moved
+ patch.refresh_from_db()
+ assert patch.current_commitfest().id == open_cf.id
+
+ # Move should create a history entry with by_cfbot=True
+ history = PatchHistory.objects.filter(patch=patch).first()
+ assert history is not None
+ assert history.by_cfbot is True
+ assert "Moved from CF" in history.what
+
+ # PendingNotification should be created for author and subscriber
+ assert PendingNotification.objects.filter(history=history, user=alice).exists()
+ assert PendingNotification.objects.filter(history=history, user=bob).exists()
+
+ # No closure email for moved patches (move triggers its own notification)
+ assert QueuedMail.objects.count() == 0
+
+
+def test_no_auto_move_without_email_activity(alice, in_progress_cf, open_cf):
+ """Patches without recent email activity should NOT be auto-moved."""
+ patch = Patch.objects.create(
+ name="Inactive Patch",
+ lastmail=datetime.now()
+ - timedelta(days=settings.AUTO_MOVE_EMAIL_ACTIVITY_DAYS + 10),
+ )
+ patch.authors.add(alice)
+ PatchOnCommitFest.objects.create(
+ patch=patch,
+ commitfest=in_progress_cf,
+ enterdate=datetime.now(),
+ status=PatchOnCommitFest.STATUS_REVIEW,
+ )
+
+ in_progress_cf.auto_move_active_patches()
+ in_progress_cf.send_closure_notifications()
+
+ # Patch should NOT be moved
+ patch.refresh_from_db()
+ assert patch.current_commitfest().id == in_progress_cf.id
+
+ # Closure email should be sent for non-moved patches
+ assert QueuedMail.objects.count() == 1
+ mail = QueuedMail.objects.first()
+ body = get_email_body(mail)
+ assert "Inactive Patch" in body
+ assert "needs attention" in body
+
+
+def test_no_auto_move_when_failing_too_long(alice, in_progress_cf, open_cf):
+ """Patches failing CI for too long should NOT be auto-moved even with recent activity."""
+ patch = Patch.objects.create(
+ name="Failing Patch",
+ lastmail=datetime.now() - timedelta(days=5),
+ )
+ patch.authors.add(alice)
+ PatchOnCommitFest.objects.create(
+ patch=patch,
+ commitfest=in_progress_cf,
+ enterdate=datetime.now(),
+ status=PatchOnCommitFest.STATUS_REVIEW,
+ )
+
+ # Add CfbotBranch with long-standing failure
+ CfbotBranch.objects.create(
+ patch=patch,
+ branch_id=1,
+ branch_name="test-branch",
+ apply_url="https://example.com",
+ status="failed",
+ failing_since=datetime.now()
+ - timedelta(days=settings.AUTO_MOVE_MAX_FAILING_DAYS + 10),
+ )
+
+ in_progress_cf.auto_move_active_patches()
+ in_progress_cf.send_closure_notifications()
+
+ # Patch should NOT be moved
+ patch.refresh_from_db()
+ assert patch.current_commitfest().id == in_progress_cf.id
+
+ # Author should receive closure notification
+ assert QueuedMail.objects.count() == 1
+ mail = QueuedMail.objects.first()
+ body = get_email_body(mail)
+ assert "Failing Patch" in body
+
+
+def test_auto_move_when_failing_within_threshold(alice, in_progress_cf, open_cf):
+ """Patches failing CI within the threshold should still be auto-moved."""
+ patch = Patch.objects.create(
+ name="Recently Failing Patch",
+ lastmail=datetime.now() - timedelta(days=5),
+ )
+ patch.authors.add(alice)
+ PatchOnCommitFest.objects.create(
+ patch=patch,
+ commitfest=in_progress_cf,
+ enterdate=datetime.now(),
+ status=PatchOnCommitFest.STATUS_REVIEW,
+ )
+
+ # Add CfbotBranch with recent failure (within threshold)
+ CfbotBranch.objects.create(
+ patch=patch,
+ branch_id=2,
+ branch_name="test-branch-2",
+ apply_url="https://example.com",
+ status="failed",
+ failing_since=datetime.now()
+ - timedelta(days=settings.AUTO_MOVE_MAX_FAILING_DAYS - 5),
+ )
+
+ in_progress_cf.auto_move_active_patches()
+ in_progress_cf.send_closure_notifications()
+
+ # Patch should be moved (failure is recent enough)
+ patch.refresh_from_db()
+ assert patch.current_commitfest().id == open_cf.id
+
+ # No closure email for moved patches
+ assert QueuedMail.objects.count() == 0
+
+
+def test_regular_cf_does_not_move_to_draft_cf(alice, in_progress_cf):
+ """Regular commitfest should move patches to the next regular CF, not a draft CF."""
+ # Create a draft CF with earlier startdate - should be ignored for regular CF patches
+ draft_cf = CommitFest.objects.create(
+ name="2024-12-draft",
+ status=CommitFest.STATUS_OPEN,
+ startdate=date(2024, 12, 1),
+ enddate=date(2024, 12, 31),
+ draft=True,
+ )
+ # Create a regular CF with later startdate - this is where patches should go
+ regular_cf = CommitFest.objects.create(
+ name="2025-03",
+ status=CommitFest.STATUS_OPEN,
+ startdate=date(2025, 3, 1),
+ enddate=date(2025, 3, 31),
+ draft=False,
+ )
+
+ patch = Patch.objects.create(
+ name="Regular Patch",
+ lastmail=datetime.now() - timedelta(days=5),
+ )
+ patch.authors.add(alice)
+ PatchOnCommitFest.objects.create(
+ patch=patch,
+ commitfest=in_progress_cf,
+ enterdate=datetime.now(),
+ status=PatchOnCommitFest.STATUS_REVIEW,
+ )
+
+ in_progress_cf.auto_move_active_patches()
+
+ # Should be moved to regular CF, not draft CF
+ patch.refresh_from_db()
+ assert patch.current_commitfest().id == regular_cf.id
+ assert patch.current_commitfest().id != draft_cf.id
+
+
+def test_draft_cf_moves_active_patches_to_next_draft(alice, bob):
+ """Active patches in a draft commitfest should be auto-moved to the next draft CF."""
+ # Create two draft CFs - one closing and one to receive patches
+ closing_draft_cf = CommitFest.objects.create(
+ name="2025-03-draft",
+ status=CommitFest.STATUS_INPROGRESS,
+ startdate=date(2025, 3, 1),
+ enddate=date(2025, 3, 31),
+ draft=True,
+ )
+ # Create a regular open CF with earlier startdate - should be ignored for draft patches
+ CommitFest.objects.create(
+ name="2025-05",
+ status=CommitFest.STATUS_OPEN,
+ startdate=date(2025, 5, 1),
+ enddate=date(2025, 5, 31),
+ draft=False,
+ )
+ next_draft_cf = CommitFest.objects.create(
+ name="2026-03-draft",
+ status=CommitFest.STATUS_OPEN,
+ startdate=date(2026, 3, 1),
+ enddate=date(2026, 3, 31),
+ draft=True,
+ )
+
+ patch = Patch.objects.create(
+ name="Draft Patch",
+ lastmail=datetime.now() - timedelta(days=5),
+ )
+ patch.authors.add(alice)
+ patch.subscribers.add(bob) # Bob subscribes to get notifications
+ PatchOnCommitFest.objects.create(
+ patch=patch,
+ commitfest=closing_draft_cf,
+ enterdate=datetime.now(),
+ status=PatchOnCommitFest.STATUS_REVIEW,
+ )
+
+ closing_draft_cf.auto_move_active_patches()
+ closing_draft_cf.send_closure_notifications()
+
+ # Patch should be moved to the next draft CF
+ patch.refresh_from_db()
+ assert patch.current_commitfest().id == next_draft_cf.id
+
+ # Move should create a history entry with by_cfbot=True
+ history = PatchHistory.objects.filter(patch=patch).first()
+ assert history is not None
+ assert history.by_cfbot is True
+
+ # PendingNotification should be created for author and subscriber
+ assert PendingNotification.objects.filter(history=history, user=alice).exists()
+ assert PendingNotification.objects.filter(history=history, user=bob).exists()
+
+ # No closure email for moved patches
+ assert QueuedMail.objects.count() == 0
diff --git a/pgcommitfest/commitfest/tests/test_lookups.py b/pgcommitfest/commitfest/tests/test_lookups.py
new file mode 100644
index 00000000..816a0462
--- /dev/null
+++ b/pgcommitfest/commitfest/tests/test_lookups.py
@@ -0,0 +1,200 @@
+import json
+from datetime import datetime
+
+import pytest
+
+from pgcommitfest.commitfest.models import Committer, Patch, PatchOnCommitFest
+
+pytestmark = pytest.mark.django_db
+
+
+@pytest.fixture
+def patches_with_users(users, open_cf):
+ """Create patches with authors and reviewers in a commitfest."""
+ # Alice is an author on patch 1
+ patch1 = Patch.objects.create(name="Test Patch 1")
+ patch1.authors.add(users["alice"])
+ PatchOnCommitFest.objects.create(
+ patch=patch1, commitfest=open_cf, enterdate=datetime.now()
+ )
+
+ # Bob is a reviewer on patch 2
+ patch2 = Patch.objects.create(name="Test Patch 2")
+ patch2.reviewers.add(users["bob"])
+ PatchOnCommitFest.objects.create(
+ patch=patch2, commitfest=open_cf, enterdate=datetime.now()
+ )
+
+ # Dave is a committer on patch 3
+ dave_committer = Committer.objects.create(user=users["dave"])
+ patch3 = Patch.objects.create(name="Test Patch 3", committer=dave_committer)
+ PatchOnCommitFest.objects.create(
+ patch=patch3, commitfest=open_cf, enterdate=datetime.now()
+ )
+
+ # Charlie has no involvement in this commitfest
+ return {"patch1": patch1, "patch2": patch2, "patch3": patch3}
+
+
+def test_userlookup_without_cf_requires_login(client, alice):
+ """Test that userlookup without cf parameter requires login."""
+ response = client.get("/lookups/user/", {"query": "alice"})
+
+ assert response.status_code == 403
+ assert b"Login required" in response.content
+
+
+def test_userlookup_without_cf_works_when_logged_in(client, alice, bob):
+ """Test that userlookup without cf parameter works when logged in."""
+ client.force_login(bob)
+ response = client.get("/lookups/user/", {"query": "alice"})
+
+ assert response.status_code == 200
+ assert json.loads(response.content) == {
+ "values": [
+ {
+ "id": alice.id,
+ "value": "Alice Anderson (alice)",
+ }
+ ]
+ }
+
+
+def test_userlookup_with_cf_no_login_required(
+ client, alice, open_cf, patches_with_users
+):
+ """Test that userlookup with cf parameter works without login."""
+ response = client.get("/lookups/user/", {"query": "alice", "cf": open_cf.id})
+
+ assert response.status_code == 200
+ assert json.loads(response.content) == {
+ "values": [
+ {
+ "id": alice.id,
+ "value": "Alice Anderson (alice)",
+ }
+ ]
+ }
+
+
+def test_userlookup_with_cf_filters_to_commitfest_participants(
+ client, alice, bob, dave, open_cf, patches_with_users
+):
+ """Test that userlookup with cf parameter only returns users in that commitfest."""
+ # Search for all users with 'a' in their name
+ response = client.get("/lookups/user/", {"query": "a", "cf": open_cf.id})
+
+ assert response.status_code == 200
+ # Should return Alice and Dave (both involved) but not Charlie (has 'a' but not involved)
+ # Results are returned in order by user ID
+ data = json.loads(response.content)
+ # Sort by id to ensure consistent ordering
+ data["values"].sort(key=lambda x: x["id"])
+ expected_values = [
+ {
+ "id": alice.id,
+ "value": "Alice Anderson (alice)",
+ },
+ {
+ "id": dave.id,
+ "value": "Dave Davis (dave)",
+ },
+ ]
+ expected_values.sort(key=lambda x: x["id"])
+ assert data == {"values": expected_values}
+
+
+def test_userlookup_with_cf_includes_reviewers(
+ client, bob, open_cf, patches_with_users
+):
+ """Test that userlookup with cf parameter includes reviewers."""
+ response = client.get("/lookups/user/", {"query": "bob", "cf": open_cf.id})
+
+ assert response.status_code == 200
+ assert json.loads(response.content) == {
+ "values": [
+ {
+ "id": bob.id,
+ "value": "Bob Brown (b)",
+ }
+ ]
+ }
+
+
+def test_userlookup_with_cf_includes_committers(
+ client, dave, open_cf, patches_with_users
+):
+ """Test that userlookup with cf parameter includes committers."""
+ response = client.get("/lookups/user/", {"query": "dave", "cf": open_cf.id})
+
+ assert response.status_code == 200
+ assert json.loads(response.content) == {
+ "values": [
+ {
+ "id": dave.id,
+ "value": "Dave Davis (dave)",
+ }
+ ]
+ }
+
+
+def test_userlookup_excludes_uninvolved_users(
+ client, charlie, open_cf, patches_with_users
+):
+ """Test that users not involved in the commitfest are excluded."""
+ response = client.get("/lookups/user/", {"query": "charlie", "cf": open_cf.id})
+
+ assert response.status_code == 200
+ assert json.loads(response.content) == {"values": []}
+
+
+def test_userlookup_requires_query_parameter(client, commitfests):
+ """Test that userlookup returns 404 without query parameter."""
+ response = client.get("/lookups/user/")
+
+ assert response.status_code == 404
+
+
+def test_userlookup_searches_first_name(client, bob, open_cf, patches_with_users):
+ """Test that userlookup searches by first name."""
+ response = client.get("/lookups/user/", {"query": "Bob", "cf": open_cf.id})
+
+ assert response.status_code == 200
+ assert json.loads(response.content) == {
+ "values": [
+ {
+ "id": bob.id,
+ "value": "Bob Brown (b)",
+ }
+ ]
+ }
+
+
+def test_userlookup_searches_last_name(client, bob, open_cf, patches_with_users):
+ """Test that userlookup searches by last name."""
+ response = client.get("/lookups/user/", {"query": "Brown", "cf": open_cf.id})
+
+ assert response.status_code == 200
+ assert json.loads(response.content) == {
+ "values": [
+ {
+ "id": bob.id,
+ "value": "Bob Brown (b)",
+ }
+ ]
+ }
+
+
+def test_userlookup_case_insensitive(client, alice, open_cf, patches_with_users):
+ """Test that userlookup is case insensitive."""
+ response = client.get("/lookups/user/", {"query": "ALICE", "cf": open_cf.id})
+
+ assert response.status_code == 200
+ assert json.loads(response.content) == {
+ "values": [
+ {
+ "id": alice.id,
+ "value": "Alice Anderson (alice)",
+ }
+ ]
+ }
diff --git a/pgcommitfest/commitfest/tests/test_refresh_commitfests.py b/pgcommitfest/commitfest/tests/test_refresh_commitfests.py
new file mode 100644
index 00000000..dda1fc9d
--- /dev/null
+++ b/pgcommitfest/commitfest/tests/test_refresh_commitfests.py
@@ -0,0 +1,158 @@
+from datetime import datetime
+
+import pytest
+from freezegun import freeze_time
+
+from pgcommitfest.commitfest.models import (
+ CommitFest,
+ Patch,
+ PatchOnCommitFest,
+)
+
+pytestmark = pytest.mark.django_db
+
+
+@freeze_time("2024-12-05")
+def test_inprogress_cf_closes_when_enddate_passed(commitfests, alice):
+ """When an in_progress CF's enddate has passed, it should be closed."""
+ in_progress_cf = commitfests["in_progress"]
+ open_cf = commitfests["open"]
+
+ patch = Patch.objects.create(
+ name="Test Patch",
+ lastmail=datetime(2024, 11, 25),
+ )
+ patch.authors.add(alice)
+ PatchOnCommitFest.objects.create(
+ patch=patch,
+ commitfest=in_progress_cf,
+ enterdate=datetime.now(),
+ status=PatchOnCommitFest.STATUS_REVIEW,
+ )
+
+ CommitFest._refresh_relevant_commitfests(for_update=False)
+
+ in_progress_cf.refresh_from_db()
+ assert in_progress_cf.status == CommitFest.STATUS_CLOSED
+
+ # Patch should be auto-moved
+ patch.refresh_from_db()
+ assert patch.current_commitfest().id == open_cf.id
+
+
+@freeze_time("2025-01-15")
+def test_open_cf_becomes_inprogress_when_startdate_reached(commitfests):
+ """When an open CF's startdate is reached, it becomes in_progress."""
+ open_cf = commitfests["open"]
+
+ CommitFest._refresh_relevant_commitfests(for_update=False)
+
+ open_cf.refresh_from_db()
+ assert open_cf.status == CommitFest.STATUS_INPROGRESS
+
+ new_open = CommitFest.objects.filter(
+ status=CommitFest.STATUS_OPEN, draft=False
+ ).first()
+ assert new_open is not None
+ assert new_open.startdate > open_cf.enddate
+
+
+@freeze_time("2025-02-05")
+def test_open_cf_closes_when_enddate_passed(commitfests, alice):
+ """When an open CF's enddate has passed (skipping in_progress), it closes."""
+ open_cf = commitfests["open"]
+
+ patch = Patch.objects.create(
+ name="Test Patch",
+ lastmail=datetime(2025, 1, 25),
+ )
+ patch.authors.add(alice)
+ PatchOnCommitFest.objects.create(
+ patch=patch,
+ commitfest=open_cf,
+ enterdate=datetime.now(),
+ status=PatchOnCommitFest.STATUS_REVIEW,
+ )
+
+ CommitFest._refresh_relevant_commitfests(for_update=False)
+
+ open_cf.refresh_from_db()
+ assert open_cf.status == CommitFest.STATUS_CLOSED
+
+ new_open = CommitFest.objects.filter(
+ status=CommitFest.STATUS_OPEN, draft=False
+ ).first()
+ assert new_open is not None
+
+ # Patch should be auto-moved
+ patch.refresh_from_db()
+ assert patch.current_commitfest().id == new_open.id
+
+
+@freeze_time("2025-01-15")
+def test_draft_cf_created_when_missing(commitfests):
+ """When no draft CF exists, one should be created."""
+ # Delete the draft CF
+ commitfests["draft"].delete()
+
+ assert not CommitFest.objects.filter(draft=True).exists()
+
+ CommitFest._refresh_relevant_commitfests(for_update=False)
+
+ draft_cf = CommitFest.objects.filter(draft=True).first()
+ assert draft_cf is not None
+ assert draft_cf.status == CommitFest.STATUS_OPEN
+
+
+@freeze_time("2025-04-05")
+def test_draft_cf_closes_when_enddate_passed(commitfests, alice):
+ """When a draft CF's enddate has passed, it should be closed."""
+ draft_cf = commitfests["draft"]
+
+ patch = Patch.objects.create(
+ name="Draft Patch",
+ lastmail=datetime(2025, 3, 25),
+ )
+ patch.authors.add(alice)
+ PatchOnCommitFest.objects.create(
+ patch=patch,
+ commitfest=draft_cf,
+ enterdate=datetime.now(),
+ status=PatchOnCommitFest.STATUS_REVIEW,
+ )
+
+ CommitFest._refresh_relevant_commitfests(for_update=False)
+
+ draft_cf.refresh_from_db()
+ assert draft_cf.status == CommitFest.STATUS_CLOSED
+
+ new_draft = CommitFest.objects.filter(
+ draft=True, status=CommitFest.STATUS_OPEN
+ ).first()
+ assert new_draft is not None
+ assert new_draft.startdate > draft_cf.enddate
+
+ # Patch should be auto-moved
+ patch.refresh_from_db()
+ assert patch.current_commitfest().id == new_draft.id
+
+
+@freeze_time("2024-11-15")
+def test_no_changes_when_up_to_date(commitfests):
+ """When commitfests are up to date, no changes should be made."""
+ in_progress_cf = commitfests["in_progress"]
+ open_cf = commitfests["open"]
+ draft_cf = commitfests["draft"]
+
+ initial_cf_count = CommitFest.objects.count()
+
+ CommitFest._refresh_relevant_commitfests(for_update=False)
+
+ in_progress_cf.refresh_from_db()
+ open_cf.refresh_from_db()
+ draft_cf.refresh_from_db()
+
+ assert in_progress_cf.status == CommitFest.STATUS_INPROGRESS
+ assert open_cf.status == CommitFest.STATUS_OPEN
+ assert draft_cf.status == CommitFest.STATUS_OPEN
+ assert CommitFest.objects.count() == initial_cf_count
diff --git a/pgcommitfest/commitfest/tests/test_refresh_thread.py b/pgcommitfest/commitfest/tests/test_refresh_thread.py
new file mode 100644
index 00000000..55d22a22
--- /dev/null
+++ b/pgcommitfest/commitfest/tests/test_refresh_thread.py
@@ -0,0 +1,51 @@
+from datetime import datetime
+from unittest.mock import patch
+
+import pytest
+
+from pgcommitfest.commitfest.ajax import refresh_single_thread
+from pgcommitfest.commitfest.models import MailThread, Patch
+
+pytestmark = pytest.mark.django_db
+
+
+def test_refresh_single_thread_updates_patch_lastmail():
+ """Regression test: patch.lastmail should get the new date, not the old one."""
+ old_date = datetime(2024, 1, 1)
+ new_date = datetime(2024, 6, 15)
+
+ thread = MailThread.objects.create(
+ messageid="old@example.com",
+ subject="Test",
+ firstmessage=old_date,
+ firstauthor="a@example.com",
+ latestmessage=old_date,
+ latestauthor="a@example.com",
+ latestsubject="Test",
+ latestmsgid="old@example.com",
+ )
+ p = Patch.objects.create(name="Test Patch", lastmail=old_date)
+ p.mailthread_set.add(thread)
+
+ api_response = [
+ {
+ "msgid": "old@example.com",
+ "date": old_date,
+ "from": "a",
+ "subj": "T",
+ "atts": [],
+ },
+ {
+ "msgid": "new@example.com",
+ "date": new_date,
+ "from": "b",
+ "subj": "T",
+ "atts": [],
+ },
+ ]
+
+ with patch("pgcommitfest.commitfest.ajax._archivesAPI", return_value=api_response):
+ refresh_single_thread(thread)
+
+ p.refresh_from_db()
+ assert p.lastmail == new_date
diff --git a/pgcommitfest/commitfest/views.py b/pgcommitfest/commitfest/views.py
index 6b3bd403..4af316bd 100644
--- a/pgcommitfest/commitfest/views.py
+++ b/pgcommitfest/commitfest/views.py
@@ -94,7 +94,7 @@ def home(request):
# Use existing cfs data instead of querying again
cf = cfs.get("in_progress") or cfs.get("open")
- form = CommitFestFilterForm(request.GET)
+ form = CommitFestFilterForm(request.GET, commitfest=cf)
patch_list = patchlist(request, cf, personalized=True)
if patch_list.redirect:
@@ -174,6 +174,8 @@ def help(request):
"help.html",
{
"title": "What is the Commitfest app?",
+ "auto_move_email_activity_days": settings.AUTO_MOVE_EMAIL_ACTIVITY_DAYS,
+ "auto_move_max_failing_days": settings.AUTO_MOVE_MAX_FAILING_DAYS,
},
)
@@ -407,6 +409,10 @@ def patchlist(request, cf, personalized=False):
whereclauses.append("poc.status=ANY(%(openstatuses)s)")
else:
whereclauses.append("poc.commitfest_id=%(cid)s")
+ # Exclude "Moved to other CF" patches from draft commitfests
+ if cf.draft:
+ whereclauses.append("poc.status != %(status_moved)s")
+ whereparams["status_moved"] = PatchOnCommitFest.STATUS_MOVED
if personalized:
# For now we can just order by these names in descending order, because
@@ -438,7 +444,7 @@ def patchlist(request, cf, personalized=False):
)
THEN 'Patches that are ready for your review'
ELSE 'Blocked on others'
- END AS topic,
+ END AS group_name,
cf.id AS cf_id,
cf.name AS cf_name,
cf.status AS cf_status,
@@ -461,7 +467,7 @@ def patchlist(request, cf, personalized=False):
joins_str = "INNER JOIN commitfest_commitfest cf ON poc.commitfest_id=cf.id"
groupby_str = "cf.id,"
else:
- columns_str = "t.topic as topic,"
+ columns_str = ""
joins_str = ""
groupby_str = ""
@@ -503,7 +509,7 @@ def patchlist(request, cf, personalized=False):
orderby_str = "poc.commitfest_id DESC, lastmail"
else:
if personalized:
- # First we sort by topic, to have the grouping work.
+ # First we sort by group_name, to have the grouping work.
# Then we show non-failing patches first, and the ones that are
# shortest failing we show first. We consider patches in a closed
# commitfest, as if they are failing since that commitfest was
@@ -512,7 +518,7 @@ def patchlist(request, cf, personalized=False):
# progress" commitfest before ones in the "Open" commitfest.
# And then to break ties, we put ones with the most recent email at
# the top.
- orderby_str = """topic DESC,
+ orderby_str = """group_name DESC,
COALESCE(
branch.failing_since,
CASE WHEN cf.status = %(cf_closed_status)s
@@ -522,7 +528,7 @@ def patchlist(request, cf, personalized=False):
lastmail DESC"""
whereparams["cf_closed_status"] = CommitFest.STATUS_CLOSED
else:
- orderby_str = "topic, created"
+ orderby_str = "created"
sortkey = 0
if not has_filter and sortkey == 0 and request.GET:
@@ -564,6 +570,7 @@ def patchlist(request, cf, personalized=False):
count(*) FILTER (WHERE task.status in ('COMPLETED', 'PAUSED')) as completed,
count(*) FILTER (WHERE task.status in ('CREATED', 'SCHEDULED', 'EXECUTING')) running,
count(*) FILTER (WHERE task.status in ('ABORTED', 'ERRORED', 'FAILED')) failed,
+ count(*) FILTER (WHERE task.status in ('ABORTED', 'ERRORED', 'FAILED') AND task.task_name != 'FormattingCheck') as failed_non_formatting,
count(*) total,
string_agg(task.task_name, ', ') FILTER (WHERE task.status in ('ABORTED', 'ERRORED', 'FAILED')) as failed_task_names,
branch.status as branch_status,
@@ -579,13 +586,12 @@ def patchlist(request, cf, personalized=False):
)
FROM commitfest_patch p
INNER JOIN commitfest_patchoncommitfest poc ON poc.patch_id=p.id
-INNER JOIN commitfest_topic t ON t.id=p.topic_id
{joins_str}
LEFT JOIN auth_user committer ON committer.id=p.committer_id
LEFT JOIN commitfest_targetversion v ON p.targetversion_id=v.id
LEFT JOIN commitfest_cfbotbranch branch ON branch.patch_id=p.id
WHERE {where_str}
-GROUP BY p.id, poc.id, {groupby_str} committer.id, t.id, v.version, branch.patch_id
+GROUP BY p.id, poc.id, {groupby_str} committer.id, v.version, branch.patch_id
ORDER BY is_open DESC, {orderby_str}""",
params,
)
@@ -615,10 +621,13 @@ def commitfest(request, cfid):
return patch_list.redirect
# Generate patch status summary.
+ # Exclude "Moved to other CF" status from draft commitfests
+ status_filter = "AND poc.status != %(status_moved)s" if cf.draft else ""
curs.execute(
- "SELECT ps.status, ps.statusstring, count(*) FROM commitfest_patchoncommitfest poc INNER JOIN commitfest_patchstatus ps ON ps.status=poc.status WHERE commitfest_id=%(id)s GROUP BY ps.status ORDER BY ps.sortkey",
+ f"SELECT ps.status, ps.statusstring, count(*) FROM commitfest_patchoncommitfest poc INNER JOIN commitfest_patchstatus ps ON ps.status=poc.status WHERE commitfest_id=%(id)s {status_filter} GROUP BY ps.status ORDER BY ps.sortkey",
{
"id": cf.id,
+ "status_moved": PatchOnCommitFest.STATUS_MOVED,
},
)
statussummary = curs.fetchall()
@@ -626,7 +635,7 @@ def commitfest(request, cfid):
# Generates a fairly expensive query, which we shouldn't do unless
# the user is logged in. XXX: Figure out how to avoid doing that..
- form = CommitFestFilterForm(request.GET)
+ form = CommitFestFilterForm(request.GET, commitfest=cf)
return render(
request,
@@ -640,7 +649,6 @@ def commitfest(request, cfid):
"all_tags": {t.id: t for t in Tag.objects.all()},
"has_filter": patch_list.has_filter,
"title": f"{cf.title} ({cf.periodstring})",
- "grouping": patch_list.sortkey == 0,
"sortkey": patch_list.sortkey,
"openpatchids": [p["id"] for p in patch_list.patches if p["is_open"]],
"header_activity": "Activity log",
@@ -686,6 +694,11 @@ def patches_by_messageid(messageid):
)
+# We require login for this page primarily so that the author/reviewer filter
+# boxes can always be searched. Since searching for users outside of a
+# commitfest requires users to be logged in to not make the data too easy to
+# scrape.
+@login_required
def global_search(request):
if "searchterm" not in request.GET:
return HttpResponseRedirect("/")
@@ -815,7 +828,7 @@ def global_search(request):
patch = patches[0]
return HttpResponseRedirect(f"/patch/{patch.id}/")
- # Use the existing filter form
+ # Use the existing filter form (no cf parameter, will require login for user lookups)
form = CommitFestFilterForm(request.GET)
# Get user profile for timestamp preferences
@@ -1246,7 +1259,11 @@ def close(request, patchid, status):
request.user,
)
- committer = get_object_or_404(Committer, user__username=request.GET["c"])
+ committer_username = request.GET.get("c")
+ if committer_username is None:
+ messages.error(request, "No committer specified.")
+ return HttpResponseRedirect(f"/patch/{patchid}/")
+ committer = get_object_or_404(Committer, user__username=committer_username)
if committer != poc.patch.committer:
# Committer changed!
prevcommitter = poc.patch.committer
@@ -1649,10 +1666,15 @@ def cfbot_ingest(message):
failing = branch_status["status"] in ("failed", "timeout") or needs_rebase
finished = branch_status["status"] == "finished"
- if "task_status" in message and message["task_status"]["status"] in (
- "ABORTED",
- "ERRORED",
- "FAILED",
+ if (
+ "task_status" in message
+ and message["task_status"]["status"]
+ in (
+ "ABORTED",
+ "ERRORED",
+ "FAILED",
+ )
+ and message["task_status"]["task_name"] != "FormattingCheck"
):
failing = True
@@ -1694,3 +1716,35 @@ def thread_notify(request):
refresh_single_thread(t)
return HttpResponse(status=200)
+
+
+@login_required
+def cfbot_requeue(request, patchid):
+ """Trigger a requeue of a patch in the cfbot."""
+ if request.method != "POST":
+ return HttpResponseForbidden(b"Invalid method")
+
+ patch = get_object_or_404(Patch, pk=patchid)
+ cf = patch.current_commitfest()
+
+ # Make API call to cfbot
+ import requests
+
+ payload = {
+ "commitfest_id": cf.id,
+ "submission_id": patchid,
+ "shared_secret": settings.CFBOT_SECRET,
+ }
+
+ try:
+ response = requests.post(
+ f"{settings.CFBOT_API_URL}/requeue-patch", json=payload, timeout=10
+ )
+ if response.status_code == 200:
+ messages.success(request, "Patch requeued successfully")
+ else:
+ messages.error(request, f"Failed to requeue patch: {response.status_code}")
+ except requests.exceptions.RequestException as e:
+ messages.error(request, f"Failed to requeue patch: {e}")
+
+ return HttpResponseRedirect(f"/patch/{patchid}/")
diff --git a/pgcommitfest/local_settings_example.py b/pgcommitfest/local_settings_example.py
index b4ad8016..392277b5 100644
--- a/pgcommitfest/local_settings_example.py
+++ b/pgcommitfest/local_settings_example.py
@@ -32,6 +32,7 @@
)
CFBOT_SECRET = "INSECURE"
+CFBOT_API_URL = "http://localhost:5000/api"
# There are already commitfests in the default dummy database data.
# Automatically creating new ones would cause the ones that are visible on the
diff --git a/pgcommitfest/settings.py b/pgcommitfest/settings.py
index 30e5d1cf..07e4adaf 100644
--- a/pgcommitfest/settings.py
+++ b/pgcommitfest/settings.py
@@ -30,6 +30,9 @@
# system time zone.
TIME_ZONE = "GMT"
+# Our code currently compares naive datetimes
+USE_TZ = False
+
# Language code for this installation. All choices can be found here:
# http://www.i18nguy.com/unicode/language-identifiers.html
LANGUAGE_CODE = "en-us"
@@ -40,10 +43,6 @@
# to load the internationalization machinery.
USE_I18N = False
-# If you set this to False, Django will not format dates, numbers and
-# calendars according to the current locale
-USE_L10N = False
-
# Absolute filesystem path to the directory that will hold user-uploaded files.
# Example: "/home/media/media.lawrence.com/media/"
MEDIA_ROOT = ""
@@ -167,6 +166,14 @@
AUTO_CREATE_COMMITFESTS = True
+CFBOT_API_URL = "https://cfbot.cputube.org/api"
+
+# Auto-move settings for commitfest closure
+# Patches with email activity within this many days are considered active
+AUTO_MOVE_EMAIL_ACTIVITY_DAYS = 30
+# Patches failing CI for longer than this many days will NOT be auto-moved
+AUTO_MOVE_MAX_FAILING_DAYS = 21
+
# Load local settings overrides
try:
from .local_settings import * # noqa: F403
diff --git a/pgcommitfest/test_settings.py b/pgcommitfest/test_settings.py
new file mode 100644
index 00000000..7fd6341f
--- /dev/null
+++ b/pgcommitfest/test_settings.py
@@ -0,0 +1,7 @@
+"""Test settings for pgcommitfest."""
+
+from pgcommitfest.settings import * # noqa: F403
+
+# Disable automatic creation of commitfests during tests
+# Tests should explicitly create the commitfests they need
+AUTO_CREATE_COMMITFESTS = False
diff --git a/pgcommitfest/urls.py b/pgcommitfest/urls.py
index 7165fffc..67920a01 100644
--- a/pgcommitfest/urls.py
+++ b/pgcommitfest/urls.py
@@ -17,6 +17,8 @@
urlpatterns = [
re_path(r"^$", views.home),
re_path(r"^api/v1/commitfests/needs_ci$", apiv1.commitfestst_that_need_ci),
+ re_path(r"^api/v1/commitfests/(\d+)/patches$", apiv1.commitfest_patches),
+ re_path(r"^api/v1/patches/(\d+)/threads$", apiv1.patch_threads),
re_path(r"^help/$", views.help),
re_path(r"^commitfest_history/$", views.commitfest_history),
re_path(r"^me/$", views.me_legacy_redirect),
@@ -36,6 +38,7 @@
re_path(r"^patch/(\d+)/committer/(become|remove)/$", views.committer),
re_path(r"^patch/(\d+)/(un)?subscribe/$", views.subscribe),
re_path(r"^patch/(\d+)/(comment|review)/", views.comment),
+ re_path(r"^patch/(\d+)/cfbot_requeue/$", views.cfbot_requeue),
re_path(r"^(\d+)/send_email/$", views.send_email),
re_path(r"^patch/(\d+)/send_email/$", views.send_patch_email),
re_path(r"^(\d+)/reports/authorstats/$", reports.authorstats),
diff --git a/pgcommitfest/userprofile/admin.py b/pgcommitfest/userprofile/admin.py
index bc847464..54ffe714 100644
--- a/pgcommitfest/userprofile/admin.py
+++ b/pgcommitfest/userprofile/admin.py
@@ -1,10 +1,40 @@
from django.contrib import admin
+from django.db.models import Count, Q
from .models import UserProfile
class UserProfileAdmin(admin.ModelAdmin):
- list_display = ("user",)
+ list_display = (
+ "user",
+ "notify_all_author",
+ "notify_all_reviewer",
+ "notify_all_committer",
+ "show_relative_timestamps",
+ )
+ list_filter = (
+ "notify_all_author",
+ "notify_all_reviewer",
+ "notify_all_committer",
+ "show_relative_timestamps",
+ )
+ search_fields = ("user__username", "user__first_name", "user__last_name")
+
+ def changelist_view(self, request, extra_context=None):
+ stats = UserProfile.objects.aggregate(
+ total=Count("id"),
+ author_on=Count("id", filter=Q(notify_all_author=True)),
+ author_off=Count("id", filter=Q(notify_all_author=False)),
+ reviewer_on=Count("id", filter=Q(notify_all_reviewer=True)),
+ reviewer_off=Count("id", filter=Q(notify_all_reviewer=False)),
+ committer_on=Count("id", filter=Q(notify_all_committer=True)),
+ committer_off=Count("id", filter=Q(notify_all_committer=False)),
+ timestamps_on=Count("id", filter=Q(show_relative_timestamps=True)),
+ timestamps_off=Count("id", filter=Q(show_relative_timestamps=False)),
+ )
+ extra_context = extra_context or {}
+ extra_context["notification_stats"] = stats
+ return super().changelist_view(request, extra_context=extra_context)
admin.site.register(UserProfile, UserProfileAdmin)
diff --git a/pgcommitfest/userprofile/migrations/0002_notifications.py b/pgcommitfest/userprofile/migrations/0002_notifications.py
index 69eaf03a..0d4b0357 100644
--- a/pgcommitfest/userprofile/migrations/0002_notifications.py
+++ b/pgcommitfest/userprofile/migrations/0002_notifications.py
@@ -15,7 +15,7 @@ class Migration(migrations.Migration):
model_name="userprofile",
name="notify_all_author",
field=models.BooleanField(
- default=False, verbose_name="Notify on all where author"
+ default=True, verbose_name="Notify on all where author"
),
),
migrations.AddField(
diff --git a/pgcommitfest/userprofile/models.py b/pgcommitfest/userprofile/models.py
index 03cbbb8a..5bd2e1cc 100644
--- a/pgcommitfest/userprofile/models.py
+++ b/pgcommitfest/userprofile/models.py
@@ -36,7 +36,7 @@ class UserProfile(models.Model):
notify_all_author = models.BooleanField(
null=False,
blank=False,
- default=False,
+ default=True,
verbose_name="Notify on all where author",
)
notify_all_reviewer = models.BooleanField(
diff --git a/pgcommitfest/userprofile/templates/admin/userprofile/userprofile/change_list.html b/pgcommitfest/userprofile/templates/admin/userprofile/userprofile/change_list.html
new file mode 100644
index 00000000..7e8aa3f4
--- /dev/null
+++ b/pgcommitfest/userprofile/templates/admin/userprofile/userprofile/change_list.html
@@ -0,0 +1,41 @@
+{% extends "admin/change_list.html" %}
+
+{% block content %}
+{% if notification_stats %}
+
+ Notification Settings Statistics ({{ notification_stats.total }} profiles)
+
+
+
+ | Setting |
+ On |
+ Off |
+
+
+
+
+ | Notify on all where author |
+ {{ notification_stats.author_on }} |
+ {{ notification_stats.author_off }} |
+
+
+ | Notify on all where reviewer |
+ {{ notification_stats.reviewer_on }} |
+ {{ notification_stats.reviewer_off }} |
+
+
+ | Notify on all where committer |
+ {{ notification_stats.committer_on }} |
+ {{ notification_stats.committer_off }} |
+
+
+ | Show relative timestamps |
+ {{ notification_stats.timestamps_on }} |
+ {{ notification_stats.timestamps_off }} |
+
+
+
+ |