@ngocsangairvds/vsaf 4.1.8 → 4.1.9

package/skills/vds-skill/vds-scripts/sonarqube_orchestrator/tests/test_reports.py

@@ -1,511 +0,0 @@
-"""Tests for report generation from SonarQube analysis results."""
-
-from __future__ import annotations
-
-from pathlib import Path
-from unittest.mock import MagicMock, patch
-
-import pytest
-
-from vds_sonarqube_orchestrator.config import SonarqubeSettings
-from vds_sonarqube_orchestrator.reports import (
-    ReportData,
-    ReportError,
-    SonarqubeReportGenerator,
-    TrendData,
-    TrendDataPoint,
-)
-
-
-@pytest.fixture
-def mock_settings() -> SonarqubeSettings:
-    """Mock SonarQube settings for testing."""
-    settings = MagicMock(spec=SonarqubeSettings)
-    settings.base_url = "http://sonar-test.example.com"
-    settings.token = "test_token_12345"
-    return settings
-
-
-@pytest.fixture
-def mock_project_response() -> dict:
-    """Mock project response."""
-    return {
-        "key": "test-project",
-        "name": "Test Project",
-        "description": "A test project",
-        "qualityProfile": "Sonar way",
-    }
-
-
-@pytest.fixture
-def mock_qg_response() -> dict:
-    """Mock quality gate response."""
-    return {
-        "projectStatus": {
-            "status": "OK",
-            "conditions": [
-                {
-                    "metric": "coverage",
-                    "status": "OK",
-                    "actualValue": "85.5",
-                    "errorThreshold": "80.0",
-                },
-                {
-                    "metric": "bugs",
-                    "status": "OK",
-                    "actualValue": "0",
-                    "errorThreshold": "0",
-                },
-            ],
-        }
-    }
-
-
-@pytest.fixture
-def mock_measures_response() -> dict:
-    """Mock measures response."""
-    return {
-        "bugs": "0",
-        "vulnerabilities": "1",
-        "code_smells": "5",
-        "coverage": "85.5",
-        "duplicated_lines_density": "2.3",
-        "ncloc": "15000",
-    }
-
-
-@pytest.fixture
-def mock_issues_response() -> list:
-    """Mock issues response."""
-    return [
-        {"key": "AX-1", "severity": "MAJOR", "message": "Fix this"},
-        {"key": "AX-2", "severity": "MINOR", "message": "Improve that"},
-        {"key": "AX-3", "severity": "CRITICAL", "message": "Security issue"},
-    ]
-
-
-@pytest.fixture
-def mock_history_response() -> list:
-    """Mock measures history response."""
-    return [
-        {
-            "metric": "bugs",
-            "history": [
-                {"date": "2025-01-01", "value": "5"},
-                {"date": "2025-01-08", "value": "3"},
-                {"date": "2025-01-15", "value": "0"},
-            ],
-        },
-        {
-            "metric": "coverage",
-            "history": [
-                {"date": "2025-01-01", "value": "70.5"},
-                {"date": "2025-01-08", "value": "78.2"},
-                {"date": "2025-01-15", "value": "85.5"},
-            ],
-        },
-    ]
-
-
-class TestTrendDataPoint:
-    def test_to_dict(self) -> None:
-        """Test TrendDataPoint serialization."""
-        point = TrendDataPoint(date="2025-01-15", value=85.5)
-        data = point.to_dict()
-
-        assert data["date"] == "2025-01-15"
-        assert data["value"] == 85.5
-
-
-class TestTrendData:
-    def test_to_dict(self) -> None:
-        """Test TrendData serialization."""
-        trend = TrendData(
-            metric="coverage",
-            data_points=[
-                TrendDataPoint(date="2025-01-01", value=70.5),
-                TrendDataPoint(date="2025-01-08", value=78.2),
-                TrendDataPoint(date="2025-01-15", value=85.5),
-            ],
-        )
-
-        data = trend.to_dict()
-        assert data["metric"] == "coverage"
-        assert len(data["data_points"]) == 3
-        assert data["data_points"][0]["value"] == 70.5
-
-
-class TestReportData:
-    def test_to_dict(self) -> None:
-        """Test ReportData serialization."""
-        report = ReportData(
-            project_key="test-project",
-            project_name="Test Project",
-            generated_at="2025-01-15T10:30:00",
-            quality_gate_status="OK",
-            metrics={"bugs": "0", "coverage": "85.5"},
-            issues_summary={"MAJOR": 1, "MINOR": 1, "CRITICAL": 1},
-            conditions=[{"metric": "coverage", "status": "OK", "actualValue": "85.5"}],
-        )
-
-        data = report.to_dict()
-        assert data["project_key"] == "test-project"
-        assert data["project_name"] == "Test Project"
-        assert data["quality_gate_status"] == "OK"
-        assert data["metrics"]["bugs"] == "0"
-        assert data["issues_summary"]["MAJOR"] == 1
-        assert len(data["conditions"]) == 1
-
-
-class TestReportError:
-    def test_error_with_context(self) -> None:
-        """Test ReportError includes context."""
-        error = ReportError(
-            "Report generation failed",
-            context={"project": "test-project", "error": "timeout"},
-        )
-
-        assert "Report generation failed" in str(error)
-        assert error.context["project"] == "test-project"
-
-    def test_error_without_context(self) -> None:
-        """Test ReportError works without context."""
-        error = ReportError("Report generation failed")
-        assert "Report generation failed" in str(error)
-        assert error.context == {}
-
-
-class TestSonarqubeReportGenerator:
-    def test_init_default_template_dir(self, mock_settings: SonarqubeSettings) -> None:
-        """Test initialization with default template directory."""
-        generator = SonarqubeReportGenerator(mock_settings)
-        assert generator._settings == mock_settings
-        assert generator._template_dir.name == "templates"
-
-    def test_init_custom_template_dir(
-        self, mock_settings: SonarqubeSettings, tmp_path: Path
-    ) -> None:
-        """Test initialization with custom template directory."""
-        custom_dir = tmp_path / "custom_templates"
-        custom_dir.mkdir()
-
-        generator = SonarqubeReportGenerator(mock_settings, template_dir=custom_dir)
-        assert generator._template_dir == custom_dir
-
-    def test_fetch_report_data(
-        self,
-        mock_settings: SonarqubeSettings,
-        mock_project_response: dict,
-        mock_qg_response: dict,
-        mock_measures_response: dict,
-        mock_issues_response: list,
-    ) -> None:
-        """Test fetching report data from SonarQube."""
-        with patch("vds_sonarqube_orchestrator.client.SonarqubeClient") as mock_client_cls:
-            mock_client = MagicMock()
-            mock_client.get_project.return_value = mock_project_response
-            mock_client.get_quality_gate_status.return_value = mock_qg_response
-            mock_client.get_measures.return_value = mock_measures_response
-            mock_client.get_issues.return_value = mock_issues_response
-            mock_client.__enter__ = MagicMock(return_value=mock_client)
-            mock_client.__exit__ = MagicMock(return_value=False)
-            mock_client_cls.return_value = mock_client
-
-            generator = SonarqubeReportGenerator(mock_settings)
-            report_data = generator._fetch_report_data("test-project")
-
-        assert report_data.project_key == "test-project"
-        assert report_data.project_name == "Test Project"
-        assert report_data.quality_gate_status == "OK"
-        assert report_data.metrics["bugs"] == "0"
-        assert report_data.metrics["coverage"] == "85.5"
-        assert report_data.issues_summary["CRITICAL"] == 1
-        assert report_data.issues_summary["MAJOR"] == 1
-        assert len(report_data.conditions) == 2
-
-    def test_fetch_report_data_with_branch(
-        self,
-        mock_settings: SonarqubeSettings,
-        mock_project_response: dict,
-        mock_qg_response: dict,
-        mock_measures_response: dict,
-        mock_issues_response: list,
-    ) -> None:
-        """Test fetching report data with branch parameter."""
-        with patch("vds_sonarqube_orchestrator.client.SonarqubeClient") as mock_client_cls:
-            mock_client = MagicMock()
-            mock_client.get_project.return_value = mock_project_response
-            mock_client.get_quality_gate_status.return_value = mock_qg_response
-            mock_client.get_measures.return_value = mock_measures_response
-            mock_client.get_issues.return_value = mock_issues_response
-            mock_client.__enter__ = MagicMock(return_value=mock_client)
-            mock_client.__exit__ = MagicMock(return_value=False)
-            mock_client_cls.return_value = mock_client
-
-            generator = SonarqubeReportGenerator(mock_settings)
-            generator._fetch_report_data("test-project", branch="develop")
-
-        mock_client.get_quality_gate_status.assert_called_once_with("test-project", "develop")
-        mock_client.get_measures.assert_called_once()
-        call_args = mock_client.get_measures.call_args
-        assert call_args[0][2] == "develop"
-
-    def test_get_trend_data(
-        self,
-        mock_settings: SonarqubeSettings,
-        mock_history_response: list,
-    ) -> None:
-        """Test fetching trend data."""
-        with patch("vds_sonarqube_orchestrator.client.SonarqubeClient") as mock_client_cls:
-            mock_client = MagicMock()
-            mock_client.get_measures_history.return_value = mock_history_response
-            mock_client.__enter__ = MagicMock(return_value=mock_client)
-            mock_client.__exit__ = MagicMock(return_value=False)
-            mock_client_cls.return_value = mock_client
-
-            generator = SonarqubeReportGenerator(mock_settings)
-            trends = generator.get_trend_data("test-project", metrics=["bugs", "coverage"])
-
-        assert len(trends) == 2
-        assert trends[0].metric == "bugs"
-        assert len(trends[0].data_points) == 3
-        assert trends[0].data_points[0].value == 5
-
-        assert trends[1].metric == "coverage"
-        assert trends[1].data_points[-1].value == 85.5
-
-    def test_get_trend_data_default_metrics(
-        self, mock_settings: SonarqubeSettings, mock_history_response: list
-    ) -> None:
-        """Test fetching trend data with default metrics."""
-        with patch("vds_sonarqube_orchestrator.client.SonarqubeClient") as mock_client_cls:
-            mock_client = MagicMock()
-            mock_client.get_measures_history.return_value = mock_history_response
-            mock_client.__enter__ = MagicMock(return_value=mock_client)
-            mock_client.__exit__ = MagicMock(return_value=False)
-            mock_client_cls.return_value = mock_client
-
-            generator = SonarqubeReportGenerator(mock_settings)
-            generator.get_trend_data("test-project")
-
-        mock_client.get_measures_history.assert_called_once()
-        call_args = mock_client.get_measures_history.call_args
-        assert call_args[0][1] == ["bugs", "vulnerabilities", "coverage"]
-
-    def test_get_trend_data_failure(self, mock_settings: SonarqubeSettings) -> None:
-        """Test trend data fetch failure handling."""
-        with patch("vds_sonarqube_orchestrator.client.SonarqubeClient") as mock_client_cls:
-            mock_client = MagicMock()
-            mock_client.get_measures_history.side_effect = Exception("API error")
-            mock_client.__enter__ = MagicMock(return_value=mock_client)
-            mock_client.__exit__ = MagicMock(return_value=False)
-            mock_client_cls.return_value = mock_client
-
-            generator = SonarqubeReportGenerator(mock_settings)
-            trends = generator.get_trend_data("test-project")
-
-        # Should return empty list on error
-        assert trends == []
-
-    def test_generate_html_report(
-        self,
-        mock_settings: SonarqubeSettings,
-        mock_project_response: dict,
-        mock_qg_response: dict,
-        mock_measures_response: dict,
-        mock_issues_response: list,
-        tmp_path: Path,
-    ) -> None:
-        """Test HTML report generation."""
-        with patch("vds_sonarqube_orchestrator.client.SonarqubeClient") as mock_client_cls:
-            mock_client = MagicMock()
-            mock_client.get_project.return_value = mock_project_response
-            mock_client.get_quality_gate_status.return_value = mock_qg_response
-            mock_client.get_measures.return_value = mock_measures_response
-            mock_client.get_issues.return_value = mock_issues_response
-            mock_client.__enter__ = MagicMock(return_value=mock_client)
-            mock_client.__exit__ = MagicMock(return_value=False)
-            mock_client_cls.return_value = mock_client
-
-            generator = SonarqubeReportGenerator(mock_settings)
-            output_path = tmp_path / "report.html"
-            result_path = generator.generate_html_report("test-project", output_path)
-
-        assert result_path == output_path
-        assert output_path.exists()
-
-        content = output_path.read_text()
-        assert "Test Project" in content
-        assert "test-project" in content
-        assert "OK" in content
-        assert "85.5" in content
-
-    def test_generate_html_report_with_trends(
-        self,
-        mock_settings: SonarqubeSettings,
-        mock_project_response: dict,
-        mock_qg_response: dict,
-        mock_measures_response: dict,
-        mock_issues_response: list,
-        mock_history_response: list,
-        tmp_path: Path,
-    ) -> None:
-        """Test HTML report generation with trend data."""
-        with patch("vds_sonarqube_orchestrator.client.SonarqubeClient") as mock_client_cls:
-            mock_client = MagicMock()
-            mock_client.get_project.return_value = mock_project_response
-            mock_client.get_quality_gate_status.return_value = mock_qg_response
-            mock_client.get_measures.return_value = mock_measures_response
-            mock_client.get_issues.return_value = mock_issues_response
-            mock_client.get_measures_history.return_value = mock_history_response
-            mock_client.__enter__ = MagicMock(return_value=mock_client)
-            mock_client.__exit__ = MagicMock(return_value=False)
-            mock_client_cls.return_value = mock_client
-
-            generator = SonarqubeReportGenerator(mock_settings)
-            output_path = tmp_path / "report_with_trends.html"
-            result_path = generator.generate_html_report(
-                "test-project", output_path, include_trends=True, trend_days=30
-            )
-
-        assert result_path == output_path
-        content = output_path.read_text()
-        assert "bugs" in content.lower()
-
-    def test_generate_html_report_creates_directory(
-        self,
-        mock_settings: SonarqubeSettings,
-        mock_project_response: dict,
-        mock_qg_response: dict,
-        mock_measures_response: dict,
-        mock_issues_response: list,
-        tmp_path: Path,
-    ) -> None:
-        """Test that HTML report generation creates output directory."""
-        with patch("vds_sonarqube_orchestrator.client.SonarqubeClient") as mock_client_cls:
-            mock_client = MagicMock()
-            mock_client.get_project.return_value = mock_project_response
-            mock_client.get_quality_gate_status.return_value = mock_qg_response
-            mock_client.get_measures.return_value = mock_measures_response
-            mock_client.get_issues.return_value = mock_issues_response
-            mock_client.__enter__ = MagicMock(return_value=mock_client)
-            mock_client.__exit__ = MagicMock(return_value=False)
-            mock_client_cls.return_value = mock_client
-
-            generator = SonarqubeReportGenerator(mock_settings)
-            output_path = tmp_path / "reports" / "nested" / "report.html"
-            result_path = generator.generate_html_report("test-project", output_path)
-
-        assert result_path.exists()
-        assert output_path.parent.exists()
-
-    @pytest.mark.skipif(
-        True,  # Skip if vds_pdf_orchestrator is not available
-        reason="PDF generation requires vds-pdf-orchestrator package",
-    )
-    def test_generate_pdf_report_success(
-        self,
-        mock_settings: SonarqubeSettings,
-        mock_project_response: dict,
-        mock_qg_response: dict,
-        mock_measures_response: dict,
-        mock_issues_response: list,
-        tmp_path: Path,
-    ) -> None:
-        """Test PDF report generation success."""
-        # This test is skipped because vds_pdf_orchestrator is not available in test env
-        # In production with pdf_orchestrator installed, this would test PDF generation
-        pass
-
-    def test_generate_pdf_report_without_pdf_orchestrator(
-        self,
-        mock_settings: SonarqubeSettings,
-        tmp_path: Path,
-    ) -> None:
-        """Test PDF report generation when PDF Orchestrator is not available."""
-        generator = SonarqubeReportGenerator(mock_settings)
-        output_path = tmp_path / "report.pdf"
-
-        # Test should raise ReportError because vds_pdf_orchestrator is not installed
-        with pytest.raises(ReportError) as exc_info:
-            generator.generate_pdf_report("test-project", output_path)
-
-        assert "vds-pdf-orchestrator is required" in str(exc_info.value)
-
-    @pytest.mark.skipif(
-        True,  # Skip if vds_pdf_orchestrator is not available
-        reason="PDF generation requires vds-pdf-orchestrator package",
-    )
-    def test_generate_pdf_report_with_custom_template(
-        self,
-        mock_settings: SonarqubeSettings,
-        mock_project_response: dict,
-        mock_qg_response: dict,
-        mock_measures_response: dict,
-        mock_issues_response: list,
-        tmp_path: Path,
-    ) -> None:
-        """Test PDF report generation with custom template name."""
-        # This test is skipped because vds_pdf_orchestrator is not available in test env
-        pass
-
-    def test_context_manager(self, mock_settings: SonarqubeSettings) -> None:
-        """Test SonarqubeReportGenerator as context manager."""
-        with SonarqubeReportGenerator(mock_settings) as generator:
-            assert generator is not None
-            # Client should be created on first use
-            assert generator._sonar_client is None
-
-        # Client should be cleaned up after exit
-        # Note: The actual client is created lazily, so this just verifies
-        # the context manager protocol works
-
-    def test_client_reuse(
-        self,
-        mock_settings: SonarqubeSettings,
-        mock_project_response: dict,
-    ) -> None:
-        """Test that client is reused across multiple calls."""
-        with patch("vds_sonarqube_orchestrator.client.SonarqubeClient") as mock_client_cls:
-            mock_client = MagicMock()
-            mock_client.get_project.return_value = mock_project_response
-            mock_client.get_quality_gate_status.return_value = {"projectStatus": {"status": "OK"}}
-            mock_client.get_measures.return_value = {}
-            mock_client.get_issues.return_value = []
-            mock_client.__enter__ = MagicMock(return_value=mock_client)
-            mock_client.__exit__ = MagicMock(return_value=False)
-            mock_client_cls.return_value = mock_client
-
-            generator = SonarqubeReportGenerator(mock_settings)
-            generator._fetch_report_data("test-project")
-            generator._fetch_report_data("test-project")
-
-        # Client should be created only once
-        mock_client_cls.assert_called_once()
-
-    def test_default_html_template_structure(self) -> None:
-        """Test that default HTML template contains expected elements."""
-        generator = SonarqubeReportGenerator(mock_settings)
-        template = generator._get_default_html_template()
-
-        assert "<!DOCTYPE html>" in template
-        assert "<title>" in template
-        assert "Quality Report" in template
-        assert "{{ report.project_name }}" in template
-        assert "status-OK" in template
-        assert "status-ERROR" in template
-        assert "metric-card" in template
-
-    def test_close(self, mock_settings: SonarqubeSettings) -> None:
-        """Test close method cleans up client."""
-        with patch("vds_sonarqube_orchestrator.client.SonarqubeClient") as mock_client_cls:
-            mock_client = MagicMock()
-            mock_client.close = MagicMock()
-            mock_client_cls.return_value = mock_client
-
-            generator = SonarqubeReportGenerator(mock_settings)
-            generator._get_client()  # Create client
-            generator.close()
-
-        mock_client.close.assert_called_once()
-        assert generator._sonar_client is None