Merge remote-tracking branch 'upstream/main' into RAG

Author: Dishant1804

.github/workflows/run-ci-cd.yaml

@@ -444,6 +444,7 @@ jobs:
 
           # Frontend
           touch .env.frontend
+          echo "NEXT_SENTRY_AUTH_TOKEN=${{ secrets.SENTRY_AUTH_TOKEN }}" >> .env.frontend
           echo "NEXT_SERVER_CSRF_URL=${{ secrets.NEXT_SERVER_CSRF_URL }}" >> .env.frontend
           echo "NEXT_SERVER_GITHUB_CLIENT_ID=${{ secrets.GITHUB_CLIENT_ID }}" >> .env.frontend
           echo "NEXT_SERVER_GITHUB_CLIENT_SECRET=${{ secrets.GITHUB_CLIENT_SECRET }}" >> .env.frontend
@@ -675,6 +676,7 @@ jobs:
 
           # Frontend
           touch .env.frontend
+          echo "NEXT_SENTRY_AUTH_TOKEN=${{ secrets.SENTRY_AUTH_TOKEN }}" >> .env.frontend
           echo "NEXT_SERVER_CSRF_URL=${{ secrets.NEXT_SERVER_CSRF_URL }}" >> .env.frontend
           echo "NEXT_SERVER_GITHUB_CLIENT_ID=${{ secrets.GITHUB_CLIENT_ID }}" >> .env.frontend
           echo "NEXT_SERVER_GITHUB_CLIENT_SECRET=${{ secrets.GITHUB_CLIENT_SECRET }}" >> .env.frontend

backend/apps/owasp/models/common.py

@@ -179,12 +179,13 @@ def get_metadata(self):
                 get_repository_file_content(self.index_md_url),
                 re.DOTALL,
             )
-            return yaml.safe_load(yaml_content.group(1)) or {} if yaml_content else {}
+            return yaml.safe_load(content) if (content := yaml_content.group(1)) else {}
         except (AttributeError, yaml.scanner.ScannerError):
             logger.exception(
                 "Unable to parse entity metadata",
                 extra={"repository": getattr(self.owasp_repository, "name", None)},
             )
+            return {}
 
     def get_related_url(self, url, exclude_domains=(), include_domains=()) -> str | None:
         """Get OWASP entity related URL."""

backend/poetry.lock

@@ -0,0 +1,33 @@
+from unittest.mock import MagicMock
+
+import pytest
+from django.contrib.admin.sites import AdminSite
+
+from apps.github.admin.issue import IssueAdmin
+from apps.github.models.issue import Issue
+
+
+@pytest.fixture
+def issue_admin_instance():
+    return IssueAdmin(model=Issue, admin_site=AdminSite())
+
+
+class TestIssueAdmin:
+    """Test suite for the IssueAdmin class."""
+
+    def test_custom_field_github_url(self, issue_admin_instance):
+        """Test that custom_field_github_url generates the correct HTML link."""
+        mock_issue = MagicMock()
+        mock_issue.url = "https://github.com/mock-org/mock-repo/issues/1"
+
+        result = issue_admin_instance.custom_field_github_url(mock_issue)
+
+        expected_html = (
+            "<a href='https://github.com/mock-org/mock-repo/issues/1' target='_blank'>↗️</a>"
+        )
+
+        assert result == expected_html
+
+    def test_list_display_contains_custom_field(self, issue_admin_instance):
+        """Test that the list_display includes custom fields."""
+        assert "custom_field_github_url" in issue_admin_instance.list_display

backend/tests/apps/github/admin/__init__.py

@@ -0,0 +1,33 @@
+from unittest.mock import MagicMock
+
+import pytest
+from django.contrib.admin.sites import AdminSite
+
+from apps.github.admin.pull_request import PullRequestAdmin
+from apps.github.models.pull_request import PullRequest
+
+
+@pytest.fixture
+def pull_request_admin_instance():
+    return PullRequestAdmin(model=PullRequest, admin_site=AdminSite())
+
+
+class TestPullRequestAdmin:
+    """Test suite for the PullRequestAdmin class."""
+
+    def test_custom_field_github_url(self, pull_request_admin_instance):
+        """Test that custom_field_github_url generates the correct HTML link."""
+        mock_pull_request = MagicMock()
+        mock_pull_request.url = "https://github.com/mock-org/mock-repo/pull/42"
+
+        result = pull_request_admin_instance.custom_field_github_url(mock_pull_request)
+
+        expected_html = (
+            "<a href='https://github.com/mock-org/mock-repo/pull/42' target='_blank'>↗️</a>"
+        )
+
+        assert result == expected_html
+
+    def test_list_display_contains_custom_field(self, pull_request_admin_instance):
+        """Test that the list_display includes custom fields."""
+        assert "custom_field_github_url" in pull_request_admin_instance.list_display

backend/tests/apps/github/admin/issue_test.py

@@ -0,0 +1,43 @@
+from unittest.mock import MagicMock
+
+import pytest
+from django.contrib.admin.sites import AdminSite
+
+from apps.github.admin.repository import RepositoryAdmin
+from apps.github.models.repository import Repository
+
+
+@pytest.fixture
+def repository_admin_instance():
+    return RepositoryAdmin(model=Repository, admin_site=AdminSite())
+
+
+class TestRepositoryAdmin:
+    """Test suite for the RepositoryAdmin class."""
+
+    def test_custom_field_title(self, repository_admin_instance):
+        mock_repository = MagicMock()
+        mock_repository.owner.login = "mock-owner"
+        mock_repository.name = "mock-repo"
+
+        result = repository_admin_instance.custom_field_title(mock_repository)
+
+        assert result == "mock-owner/mock-repo"
+
+    def test_custom_field_github_url(self, repository_admin_instance):
+        """Test that custom_field_github_url generates the correct HTML link."""
+        mock_repository = MagicMock()
+        mock_repository.owner.login = "mock-owner"
+        mock_repository.name = "mock-repo"
+
+        result = repository_admin_instance.custom_field_github_url(mock_repository)
+        expected_html = "<a href='https://github.com/mock-owner/mock-repo' target='_blank'>↗️</a>"
+
+        assert result == expected_html
+
+    def test_list_display_contains_custom_fields(self, repository_admin_instance):
+        """Test that the list_display includes custom fields."""
+        admin_list_display = repository_admin_instance.list_display
+
+        assert "custom_field_title" in admin_list_display
+        assert "custom_field_github_url" in admin_list_display

backend/tests/apps/github/admin/pull_request_test.py

@@ -75,3 +75,116 @@ def test_recent_issues_limit(self, mock_select_related, mock_issue):
         mock_select_related.assert_called_once()
         mock_queryset.order_by.assert_called_once_with("-created_at")
         assert result == [mock_issue]
+
+    @patch("apps.github.api.internal.queries.issue.Subquery")
+    @patch("apps.github.models.issue.Issue.objects.select_related")
+    def test_recent_issues_distinct(self, mock_select_related, mock_subquery, mock_issue):
+        """Test distinct filtering with Subquery for issues."""
+        mock_queryset = MagicMock()
+        mock_queryset.order_by.return_value = mock_queryset
+        mock_queryset.filter.return_value = mock_queryset
+        mock_queryset.__getitem__.return_value = [mock_issue]
+        mock_select_related.return_value = mock_queryset
+
+        mock_subquery_instance = MagicMock()
+        mock_subquery.return_value = mock_subquery_instance
+
+        result = IssueQuery().recent_issues(distinct=True)
+
+        assert result == [mock_issue]
+        mock_subquery.assert_called_once()
+        mock_queryset.filter.assert_called()
+
+    @patch("apps.github.models.issue.Issue.objects.select_related")
+    def test_recent_issues_combined_filters(self, mock_select_related, mock_issue):
+        mock_queryset = MagicMock()
+        mock_queryset.order_by.return_value.filter.return_value.filter.return_value = [mock_issue]
+        mock_select_related.return_value = mock_queryset
+
+        result = IssueQuery().recent_issues(login="alice", organization="owasp")
+
+        mock_select_related.assert_called_once()
+        mock_queryset.order_by.assert_called_once()
+        assert result == [mock_issue]
+
+    @patch("apps.github.api.internal.queries.issue.OuterRef")
+    @patch("apps.github.api.internal.queries.issue.Subquery")
+    @patch("apps.github.models.issue.Issue.objects.select_related")
+    def test_recent_issues_distinct_with_organization(
+        self, mock_select_related, mock_subquery, mock_outer_ref, mock_issue
+    ):
+        """Test distinct filtering with organization filter."""
+        mock_queryset = MagicMock()
+        mock_queryset.order_by.return_value = mock_queryset
+        mock_queryset.filter.return_value = mock_queryset
+        mock_queryset.__getitem__.return_value = [mock_issue]
+        mock_select_related.return_value = mock_queryset
+
+        mock_subquery_instance = Mock()
+        mock_subquery.return_value = mock_subquery_instance
+        mock_outer_ref_instance = Mock()
+        mock_outer_ref.return_value = mock_outer_ref_instance
+
+        result = IssueQuery().recent_issues(distinct=True, organization="owasp")
+
+        assert result == [mock_issue]
+        mock_subquery.assert_called_once()
+        mock_outer_ref.assert_called_once_with("author_id")
+
+    @patch("apps.github.api.internal.queries.issue.OuterRef")
+    @patch("apps.github.api.internal.queries.issue.Subquery")
+    @patch("apps.github.models.issue.Issue.objects.select_related")
+    def test_recent_issues_distinct_with_all_filters(
+        self, mock_select_related, mock_subquery, mock_outer_ref, mock_issue
+    ):
+        """Test distinct filtering with all filters."""
+        mock_queryset = MagicMock()
+        mock_queryset.order_by.return_value = mock_queryset
+        mock_queryset.filter.return_value = mock_queryset
+        mock_queryset.__getitem__.return_value = [mock_issue]
+        mock_select_related.return_value = mock_queryset
+
+        mock_subquery_instance = Mock()
+        mock_subquery.return_value = mock_subquery_instance
+        mock_outer_ref_instance = Mock()
+        mock_outer_ref.return_value = mock_outer_ref_instance
+
+        result = IssueQuery().recent_issues(
+            distinct=True, login="alice", organization="owasp", limit=3
+        )
+
+        assert result == [mock_issue]
+        mock_subquery.assert_called_once()
+        mock_outer_ref.assert_called_once_with("author_id")
+        # Verify both login and organization filters were applied
+        assert mock_queryset.filter.call_count >= 3  # login, organization, distinct
+
+    @patch("apps.github.models.issue.Issue.objects.select_related")
+    def test_recent_issues_organization_only(self, mock_select_related, mock_issue):
+        """Test filtering issues by organization only."""
+        mock_queryset = MagicMock()
+        mock_queryset.order_by.return_value = mock_queryset
+        mock_queryset.filter.return_value = mock_queryset
+        mock_queryset.__getitem__.return_value = [mock_issue]
+        mock_select_related.return_value = mock_queryset
+
+        result = IssueQuery().recent_issues(organization="owasp")
+
+        assert result == [mock_issue]
+        assert len(mock_queryset.filter.call_args_list) >= 1
+
+    @patch("apps.github.models.issue.Issue.objects.select_related")
+    def test_recent_issues_multiple_filters(self, mock_select_related, mock_issue):
+        """Test issues with multiple filters applied."""
+        mock_queryset = MagicMock()
+        mock_queryset.order_by.return_value = mock_queryset
+        mock_queryset.filter.return_value = mock_queryset
+        mock_queryset.__getitem__.return_value = [mock_issue]
+        mock_select_related.return_value = mock_queryset
+
+        result = IssueQuery().recent_issues(organization="owasp", limit=10)
+
+        assert result == [mock_issue]
+        # Verify organization filter was applied
+        assert len(mock_queryset.filter.call_args_list) >= 1
+        mock_queryset.__getitem__.assert_called_with(slice(None, 10))

backend/tests/apps/github/admin/repository_test.py

@@ -3,6 +3,7 @@
 from unittest.mock import MagicMock, Mock, patch
 
 import pytest
+from django.core.exceptions import ValidationError
 
 from apps.github.api.internal.queries.milestone import MilestoneQuery
 from apps.github.models.milestone import Milestone
@@ -94,3 +95,25 @@ def test_recent_milestones_distinct(self):
 
             assert isinstance(result, list)
             assert filtered_queryset.__getitem__.called
+
+    def test_recent_milestones_invalid_state(self):
+        """Test ValidationError for invalid state parameter."""
+        with pytest.raises(ValidationError) as exc_info:
+            MilestoneQuery().recent_milestones(state="invalid")
+
+        assert "Invalid state: invalid" in str(exc_info.value)
+        assert "Valid states are 'open', 'closed', or 'all'" in str(exc_info.value)
+
+    def test_recent_milestones_with_all_parameters(self, get_queryset):
+        """Test recent milestones with all parameters provided."""
+        with patch.object(Milestone, "closed_milestones", new_callable=Mock) as mock_manager:
+            mock_manager.all.return_value = get_queryset
+
+            result = MilestoneQuery().recent_milestones(
+                distinct=False, limit=10, login="testuser", organization="owasp", state="closed"
+            )
+
+        assert isinstance(result, list)
+        get_queryset.filter.assert_any_call(author__login="testuser")
+        get_queryset.filter.assert_any_call(repository__organization__login="owasp")
+        get_queryset.__getitem__.assert_called_with(slice(None, 10))

backend/tests/apps/github/api/internal/queries/issue_test.py

@@ -0,0 +1,50 @@
+"""Test cases for OrganizationQuery."""
+
+from unittest.mock import Mock, patch
+
+import pytest
+
+from apps.github.api.internal.queries.organization import OrganizationQuery
+from apps.github.models.organization import Organization
+
+
+class TestOrganizationQuery:
+    """Test cases for OrganizationQuery class."""
+
+    @pytest.fixture
+    def mock_organization(self):
+        """Mock Organization instance."""
+        org = Mock(spec=Organization)
+        org.id = 1
+        org.login = "owasp"
+        return org
+
+    @patch("apps.github.models.organization.Organization.objects.get")
+    def test_organization_found(self, mock_get, mock_organization):
+        """Test fetching organization when it exists."""
+        mock_get.return_value = mock_organization
+
+        result = OrganizationQuery().organization(login="owasp")
+
+        assert result == mock_organization
+        mock_get.assert_called_once_with(is_owasp_related_organization=True, login="owasp")
+
+    @patch("apps.github.models.organization.Organization.objects.get")
+    def test_organization_not_found(self, mock_get):
+        """Test fetching organization when it doesn't exist."""
+        mock_get.side_effect = Organization.DoesNotExist()
+
+        result = OrganizationQuery().organization(login="nonexistent")
+
+        assert result is None
+        mock_get.assert_called_once_with(is_owasp_related_organization=True, login="nonexistent")
+
+    @patch("apps.github.models.organization.Organization.objects.get")
+    def test_organization_with_different_login(self, mock_get, mock_organization):
+        """Test fetching organization with different login."""
+        mock_get.return_value = mock_organization
+
+        result = OrganizationQuery().organization(login="test-org")
+
+        assert result == mock_organization
+        mock_get.assert_called_once_with(is_owasp_related_organization=True, login="test-org")