@ngocsangairvds/vsaf 4.1.9 → 4.1.10

package/skills/vds-skill/runtime/sonarqube_orchestrator/tests/test_batch.py

@@ -0,0 +1,419 @@
+"""Tests for batch operations with multi-project SonarQube analysis."""
+
+from __future__ import annotations
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from vds_sonarqube_orchestrator.batch import (
+    BatchError,
+    BatchExecutor,
+    BatchResult,
+    ProjectResult,
+)
+from vds_sonarqube_orchestrator.config import SonarqubeSettings
+
+
+@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_qg_response() -> dict:
+    """Mock quality gate response."""
+    return {
+        "projectStatus": {
+            "status": "OK",
+            "conditions": [
+                {
+                    "metric": "coverage",
+                    "status": "OK",
+                    "actualValue": "85.5",
+                }
+            ],
+        }
+    }
+
+
+@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": "MAJOR", "message": "Another issue"},
+    ]
+
+
+@pytest.fixture
+def mock_measures_response() -> dict:
+    """Mock measures response."""
+    return {
+        "bugs": "0",
+        "vulnerabilities": "1",
+        "code_smells": "5",
+        "coverage": "75.5",
+    }
+
+
+class TestProjectResult:
+    def test_to_dict_success(self) -> None:
+        """Test ProjectResult serialization for successful result."""
+        result = ProjectResult(
+            project_key="test-project",
+            success=True,
+            data={"status": "OK", "passed": True},
+        )
+
+        data = result.to_dict()
+        assert data["project_key"] == "test-project"
+        assert data["success"] is True
+        assert data["data"]["status"] == "OK"
+        assert data["error"] is None
+
+    def test_to_dict_failure(self) -> None:
+        """Test ProjectResult serialization for failed result."""
+        result = ProjectResult(
+            project_key="test-project",
+            success=False,
+            error="Connection timeout",
+        )
+
+        data = result.to_dict()
+        assert data["project_key"] == "test-project"
+        assert data["success"] is False
+        assert data["error"] == "Connection timeout"
+        assert data["data"] == {}
+
+
+class TestBatchResult:
+    def test_success_rate_all_pass(self) -> None:
+        """Test success rate calculation when all projects pass."""
+        results = [
+            ProjectResult(project_key="proj1", success=True),
+            ProjectResult(project_key="proj2", success=True),
+            ProjectResult(project_key="proj3", success=True),
+        ]
+
+        batch_result = BatchResult(total=3, successful=3, failed=0, results=results)
+
+        assert batch_result.success_rate == 100.0
+
+    def test_success_rate_partial(self) -> None:
+        """Test success rate calculation with mixed results."""
+        results = [
+            ProjectResult(project_key="proj1", success=True),
+            ProjectResult(project_key="proj2", success=False),
+            ProjectResult(project_key="proj3", success=True),
+            ProjectResult(project_key="proj4", success=False),
+        ]
+
+        batch_result = BatchResult(total=4, successful=2, failed=2, results=results)
+
+        assert batch_result.success_rate == 50.0
+
+    def test_success_rate_empty(self) -> None:
+        """Test success rate calculation with no projects."""
+        batch_result = BatchResult(total=0, successful=0, failed=0, results=[])
+
+        assert batch_result.success_rate == 0.0
+
+    def test_to_dict(self) -> None:
+        """Test BatchResult serialization."""
+        results = [
+            ProjectResult(project_key="proj1", success=True, data={"status": "OK"}),
+            ProjectResult(project_key="proj2", success=False, error="Timeout"),
+        ]
+
+        batch_result = BatchResult(total=2, successful=1, failed=1, results=results)
+
+        data = batch_result.to_dict()
+        assert data["total"] == 2
+        assert data["successful"] == 1
+        assert data["failed"] == 1
+        assert data["success_rate"] == 50.0
+        assert len(data["results"]) == 2
+
+
+class TestBatchError:
+    def test_error_with_context(self) -> None:
+        """Test BatchError includes context."""
+        error = BatchError(
+            "Batch operation failed",
+            context={"projects": ["proj1", "proj2"], "error": "timeout"},
+        )
+
+        assert "Batch operation failed" in str(error)
+        assert error.context["projects"] == ["proj1", "proj2"]
+
+    def test_error_without_context(self) -> None:
+        """Test BatchError works without context."""
+        error = BatchError("Batch operation failed")
+        assert "Batch operation failed" in str(error)
+        assert error.context == {}
+
+
+class TestBatchExecutor:
+    def test_init_default_concurrency(self, mock_settings: SonarqubeSettings) -> None:
+        """Test initialization with default concurrency."""
+        executor = BatchExecutor(mock_settings)
+        assert executor._concurrency == BatchExecutor.DEFAULT_CONCURRENCY
+
+    def test_init_custom_concurrency(self, mock_settings: SonarqubeSettings) -> None:
+        """Test initialization with custom concurrency."""
+        executor = BatchExecutor(mock_settings, concurrency=5)
+        assert executor._concurrency == 5
+
+    def test_batch_quality_gates_all_success(
+        self, mock_settings: SonarqubeSettings, mock_qg_response: dict
+    ) -> None:
+        """Test batch quality gate check with all projects passing."""
+        project_keys = ["project-a", "project-b", "project-c"]
+
+        with patch("vds_sonarqube_orchestrator.client.SonarqubeClient") as mock_client_cls:
+            mock_client = MagicMock()
+            mock_client.__enter__ = MagicMock(return_value=mock_client)
+            mock_client.__exit__ = MagicMock(return_value=False)
+            mock_client.get_quality_gate_status.return_value = mock_qg_response
+            mock_client_cls.return_value = mock_client
+
+            executor = BatchExecutor(mock_settings)
+            result = executor.batch_quality_gates(project_keys)
+
+        assert result.total == 3
+        assert result.successful == 3
+        assert result.failed == 0
+        assert result.success_rate == 100.0
+        assert len(result.results) == 3
+
+        for project_result in result.results:
+            assert project_result.success is True
+            assert project_result.data["status"] == "OK"
+            assert project_result.data["passed"] is True
+
+    def test_batch_quality_gates_partial_failure(
+        self, mock_settings: SonarqubeSettings, mock_qg_response: dict
+    ) -> None:
+        """Test batch quality gate check with some projects failing."""
+        project_keys = ["project-a", "project-b", "project-c"]
+
+        def mock_get_qg(project_key: str, _branch: str | None = None) -> dict:
+            if project_key == "project-b":
+                raise Exception("Connection timeout")
+            return mock_qg_response
+
+        with patch("vds_sonarqube_orchestrator.client.SonarqubeClient") as mock_client_cls:
+            mock_client = MagicMock()
+            mock_client.__enter__ = MagicMock(return_value=mock_client)
+            mock_client.__exit__ = MagicMock(return_value=False)
+            mock_client.get_quality_gate_status.side_effect = mock_get_qg
+            mock_client_cls.return_value = mock_client
+
+            executor = BatchExecutor(mock_settings)
+            result = executor.batch_quality_gates(project_keys)
+
+        assert result.total == 3
+        assert result.successful == 2
+        assert result.failed == 1
+        assert result.success_rate == pytest.approx(66.67, rel=1e-2)
+
+        # Find the failed result
+        failed_result = next(r for r in result.results if not r.success)
+        assert failed_result.project_key == "project-b"
+        assert "Connection timeout" in failed_result.error
+
+    def test_batch_quality_gates_with_branch(
+        self, mock_settings: SonarqubeSettings, mock_qg_response: dict
+    ) -> None:
+        """Test batch quality gate check with branch parameter."""
+        project_keys = ["project-a"]
+
+        with patch("vds_sonarqube_orchestrator.client.SonarqubeClient") as mock_client_cls:
+            mock_client = MagicMock()
+            mock_client.__enter__ = MagicMock(return_value=mock_client)
+            mock_client.__exit__ = MagicMock(return_value=False)
+            mock_client.get_quality_gate_status.return_value = mock_qg_response
+            mock_client_cls.return_value = mock_client
+
+            executor = BatchExecutor(mock_settings)
+            result = executor.batch_quality_gates(project_keys, branch="develop")
+
+        mock_client.get_quality_gate_status.assert_called_once_with("project-a", "develop")
+        assert result.successful == 1
+
+    def test_batch_issues_success(
+        self, mock_settings: SonarqubeSettings, mock_issues_response: list
+    ) -> None:
+        """Test batch issues fetch with all projects succeeding."""
+        project_keys = ["project-a", "project-b"]
+
+        with patch("vds_sonarqube_orchestrator.client.SonarqubeClient") as mock_client_cls:
+            mock_client = MagicMock()
+            mock_client.__enter__ = MagicMock(return_value=mock_client)
+            mock_client.__exit__ = MagicMock(return_value=False)
+            mock_client.get_issues.return_value = mock_issues_response
+            mock_client_cls.return_value = mock_client
+
+            executor = BatchExecutor(mock_settings)
+            result = executor.batch_issues(project_keys)
+
+        assert result.total == 2
+        assert result.successful == 2
+        assert result.failed == 0
+
+        for project_result in result.results:
+            assert project_result.success is True
+            assert project_result.data["total_issues"] == 3
+            assert project_result.data["by_severity"]["MAJOR"] == 2
+            assert project_result.data["by_severity"]["MINOR"] == 1
+
+    def test_batch_issues_with_severities(self, mock_settings: SonarqubeSettings) -> None:
+        """Test batch issues fetch with severity filter."""
+        project_keys = ["project-a"]
+
+        filtered_issues = [
+            {"key": "AX-1", "severity": "MAJOR", "message": "Fix this"},
+        ]
+
+        with patch("vds_sonarqube_orchestrator.client.SonarqubeClient") as mock_client_cls:
+            mock_client = MagicMock()
+            mock_client.__enter__ = MagicMock(return_value=mock_client)
+            mock_client.__exit__ = MagicMock(return_value=False)
+            mock_client.get_issues.return_value = filtered_issues
+            mock_client_cls.return_value = mock_client
+
+            executor = BatchExecutor(mock_settings)
+            result = executor.batch_issues(project_keys, severities=["MAJOR", "CRITICAL"])
+
+        mock_client.get_issues.assert_called_once_with(
+            project_key="project-a", severities=["MAJOR", "CRITICAL"], per_page=100
+        )
+        assert result.successful == 1
+
+    def test_batch_issues_with_limit(self, mock_settings: SonarqubeSettings) -> None:
+        """Test batch issues fetch with custom limit."""
+        project_keys = ["project-a"]
+
+        with patch("vds_sonarqube_orchestrator.client.SonarqubeClient") as mock_client_cls:
+            mock_client = MagicMock()
+            mock_client.__enter__ = MagicMock(return_value=mock_client)
+            mock_client.__exit__ = MagicMock(return_value=False)
+            mock_client.get_issues.return_value = []
+            mock_client_cls.return_value = mock_client
+
+            executor = BatchExecutor(mock_settings)
+            result = executor.batch_issues(project_keys, limit_per_project=500)
+
+        mock_client.get_issues.assert_called_once_with(
+            project_key="project-a", severities=None, per_page=500
+        )
+        assert result.successful == 1
+
+    def test_batch_measures_success(
+        self, mock_settings: SonarqubeSettings, mock_measures_response: dict
+    ) -> None:
+        """Test batch measures fetch with all projects succeeding."""
+        project_keys = ["project-a", "project-b"]
+
+        with patch("vds_sonarqube_orchestrator.client.SonarqubeClient") as mock_client_cls:
+            mock_client = MagicMock()
+            mock_client.__enter__ = MagicMock(return_value=mock_client)
+            mock_client.__exit__ = MagicMock(return_value=False)
+            mock_client.get_measures.return_value = mock_measures_response
+            mock_client_cls.return_value = mock_client
+
+            executor = BatchExecutor(mock_settings)
+            result = executor.batch_measures(project_keys)
+
+        assert result.total == 2
+        assert result.successful == 2
+        assert result.failed == 0
+
+        for project_result in result.results:
+            assert project_result.success is True
+            assert project_result.data["measures"]["bugs"] == "0"
+            assert project_result.data["measures"]["coverage"] == "75.5"
+
+    def test_batch_measures_custom_metrics(self, mock_settings: SonarqubeSettings) -> None:
+        """Test batch measures fetch with custom metrics."""
+        project_keys = ["project-a"]
+
+        custom_measures = {
+            "complexity": "125",
+            "cognitive_complexity": "85",
+        }
+
+        with patch("vds_sonarqube_orchestrator.client.SonarqubeClient") as mock_client_cls:
+            mock_client = MagicMock()
+            mock_client.__enter__ = MagicMock(return_value=mock_client)
+            mock_client.__exit__ = MagicMock(return_value=False)
+            mock_client.get_measures.return_value = custom_measures
+            mock_client_cls.return_value = mock_client
+
+            executor = BatchExecutor(mock_settings)
+            result = executor.batch_measures(
+                project_keys, metrics=["complexity", "cognitive_complexity"]
+            )
+
+        mock_client.get_measures.assert_called_once_with(
+            "project-a", ["complexity", "cognitive_complexity"], None
+        )
+        assert result.successful == 1
+
+    def test_batch_measures_with_branch(
+        self, mock_settings: SonarqubeSettings, mock_measures_response: dict
+    ) -> None:
+        """Test batch measures fetch with branch parameter."""
+        project_keys = ["project-a"]
+
+        with patch("vds_sonarqube_orchestrator.client.SonarqubeClient") as mock_client_cls:
+            mock_client = MagicMock()
+            mock_client.__enter__ = MagicMock(return_value=mock_client)
+            mock_client.__exit__ = MagicMock(return_value=False)
+            mock_client.get_measures.return_value = mock_measures_response
+            mock_client_cls.return_value = mock_client
+
+            executor = BatchExecutor(mock_settings)
+            result = executor.batch_measures(project_keys, branch="feature/new")
+
+        mock_client.get_measures.assert_called_once()
+        call_args = mock_client.get_measures.call_args
+        assert call_args[0][0] == "project-a"
+        assert call_args[0][2] == "feature/new"
+        assert result.successful == 1
+
+    def test_concurrent_execution(
+        self, mock_settings: SonarqubeSettings, mock_qg_response: dict
+    ) -> None:
+        """Test that batch operations execute concurrently."""
+        import time
+
+        project_keys = ["project-a", "project-b", "project-c"]
+        execution_times = []
+
+        def mock_get_qg(project_key: str, _branch: str | None = None) -> dict:
+            start = time.time()
+            time.sleep(0.1)  # Simulate work
+            execution_times.append((project_key, time.time() - start))
+            return mock_qg_response
+
+        with patch("vds_sonarqube_orchestrator.client.SonarqubeClient") as mock_client_cls:
+            mock_client = MagicMock()
+            mock_client.__enter__ = MagicMock(return_value=mock_client)
+            mock_client.__exit__ = MagicMock(return_value=False)
+            mock_client.get_quality_gate_status.side_effect = mock_get_qg
+            mock_client_cls.return_value = mock_client
+
+            executor = BatchExecutor(mock_settings, concurrency=3)
+            result = executor.batch_quality_gates(project_keys)
+
+        # With concurrency=3 and 3 projects, total time should be ~0.1s not ~0.3s
+        _total_time = sum(t for _, t in execution_times)
+        assert result.successful == 3
+        assert len(execution_times) == 3

package/skills/vds-skill/runtime/sonarqube_orchestrator/tests/test_config.py

@@ -0,0 +1,145 @@
+"""Tests for SonarQube configuration loading."""
+
+from __future__ import annotations
+
+import os
+
+import pytest
+
+from vds_sonarqube_orchestrator.config import SettingsError, SonarqubeSettings, load_settings
+
+
+@pytest.fixture(autouse=True)
+def clear_sonar_env_vars() -> None:
+    """Clear SonarQube environment variables before each test."""
+    # Save and clear VDS_SONAR_* from os.environ
+    sonar_vars = [k for k in os.environ if k.startswith("VDS_SONAR_")]
+    saved_vars = {var: os.environ[var] for var in sonar_vars if var in os.environ}
+    for var in sonar_vars:
+        os.environ.pop(var, None)
+
+    yield
+
+    # Restore original values
+    for var, value in saved_vars.items():
+        os.environ[var] = value
+
+
+def test_sonarqube_settings_minimal() -> None:
+    """Test creating settings with minimal required fields."""
+    settings = SonarqubeSettings(
+        host_url="http://sonar-test.example.com",
+    )
+    assert settings.host_url == "http://sonar-test.example.com"
+    assert settings.base_url == "http://sonar-test.example.com"
+    # Note: These may be loaded from .env file, so we just check the object exists
+    assert hasattr(settings, "token")
+    assert hasattr(settings, "user")
+
+
+def test_sonarqube_settings_with_token() -> None:
+    """Test creating settings with token authentication."""
+    settings = SonarqubeSettings(
+        host_url="http://sonar-test.example.com",
+        token_secret="test_token_123",
+    )
+    assert settings.token == "test_token_123"
+
+
+def test_sonarqube_settings_with_user_password() -> None:
+    """Test creating settings with username/password authentication."""
+    settings = SonarqubeSettings(
+        host_url="http://sonar-test.example.com",
+        user="testuser",
+        password_secret="testpass",
+    )
+    assert settings.user == "testuser"
+    assert settings.password == "testpass"
+
+
+def test_sonarqube_settings_defaults() -> None:
+    """Test that default values are applied correctly."""
+    settings = SonarqubeSettings(
+        host_url="http://sonar-test.example.com",
+    )
+    assert settings.connect_timeout == 10.0
+    assert settings.request_timeout == 30.0
+    assert settings.max_retries == 3
+    assert settings.retry_backoff == 1.5
+    assert settings.verify_certs is False
+
+
+def test_sonarqube_settings_require_credentials(monkeypatch: pytest.MonkeyPatch, tmp_path) -> None:
+    """Test credential validation."""
+    for key in list(os.environ):
+        if key.startswith("VDS_SONAR_"):
+            monkeypatch.delenv(key, raising=False)
+    empty_env = tmp_path / "empty.env"
+    empty_env.write_text("", encoding="utf-8")
+    monkeypatch.setattr(
+        "vds_sonarqube_orchestrator.config.DEFAULT_ENV_PATHS",
+        (empty_env,),
+    )
+    # Settings with token should pass
+    settings = SonarqubeSettings(
+        _env_file=empty_env,
+        host_url="http://sonar-test.example.com",
+        token_secret="test_token",
+    )
+    settings.require_credentials()  # Should not raise
+
+    # Settings with user/password should pass
+    settings = SonarqubeSettings(
+        _env_file=empty_env,
+        host_url="http://sonar-test.example.com",
+        user="testuser",
+        password_secret="testpass",
+    )
+    settings.require_credentials()  # Should not raise
+
+    # Settings without credentials should fail
+    settings = SonarqubeSettings(
+        _env_file=empty_env,
+        host_url="http://sonar-test.example.com",
+    )
+    with pytest.raises(ValueError, match="Missing SonarQube credentials"):
+        settings.require_credentials()
+
+
+def test_load_settings_from_dict(sample_env_file) -> None:
+    """Test loading settings from a dict (for testing)."""
+    # Use env_path to load from sample .env file
+    settings = load_settings(env_path=sample_env_file)
+    assert settings.host_url == "http://sonar-test.example.com"
+    assert settings.token == "test_token_12345"
+
+
+def test_load_settings_strict_mode(monkeypatch: pytest.MonkeyPatch, tmp_path) -> None:
+    """Test load_settings with strict=True when host_url is missing."""
+    for key in list(os.environ):
+        if key.startswith("VDS_SONAR_"):
+            monkeypatch.delenv(key, raising=False)
+    fake_env = tmp_path / "empty.env"
+    fake_env.write_text("", encoding="utf-8")
+    with pytest.raises(SettingsError, match="VDS_SONAR_HOST_URL"):
+        load_settings(env_path=fake_env, strict=True)
+
+
+def test_settings_base_url_normalization() -> None:
+    """Test that base_url normalizes trailing slashes."""
+    settings = SonarqubeSettings(
+        host_url="http://sonar-test.example.com/",
+    )
+    assert settings.base_url == "http://sonar-test.example.com"
+
+
+def test_settings_alias_mapping() -> None:
+    """Test that environment variable aliases work correctly."""
+    settings = SonarqubeSettings(
+        **{
+            "VDS_SONAR_HOST_URL": "http://sonar-test.example.com",
+            "VDS_SONAR_TOKEN": "test_token",
+        }
+    )
+    assert settings.host_url == "http://sonar-test.example.com"
+    assert settings.token == "test_token"

package/skills/vds-skill/runtime/sonarqube_orchestrator/tests/test_errors.py

@@ -0,0 +1,78 @@
+"""Tests for vds_sonarqube_orchestrator error re-exports from vds_platform_core."""
+
+from __future__ import annotations
+
+from vds_platform_core.errors import (
+    AuthError as PlatformAuthError,
+)
+from vds_platform_core.errors import (
+    ClientPermissionError as PlatformPermissionError,
+)
+from vds_platform_core.errors import (
+    ClientTimeoutError as PlatformTimeoutError,
+)
+from vds_platform_core.errors import (
+    NotFoundError as PlatformNotFoundError,
+)
+from vds_platform_core.errors import (
+    RateLimitError as PlatformRateLimitError,
+)
+from vds_platform_core.errors import (
+    ResponseError as PlatformResponseError,
+)
+from vds_platform_core.errors import (
+    RetryError as PlatformRetryError,
+)
+from vds_platform_core.errors import (
+    TransportError as PlatformTransportError,
+)
+from vds_platform_core.errors import (
+    VDSClientError as PlatformVDSClientError,
+)
+
+from vds_sonarqube_orchestrator.errors import (
+    SERVICE_NAME,
+    AuthError,
+    ClientPermissionError,
+    ClientTimeoutError,
+    NotFoundError,
+    RateLimitError,
+    ResponseError,
+    RetryError,
+    TransportError,
+    VDSClientError,
+)
+
+
+def test_service_name() -> None:
+    assert SERVICE_NAME == "sonarqube"
+
+
+def test_re_exports_are_platform_core_classes() -> None:
+    assert AuthError is PlatformAuthError
+    assert VDSClientError is PlatformVDSClientError
+    assert RateLimitError is PlatformRateLimitError
+    assert NotFoundError is PlatformNotFoundError
+    assert ResponseError is PlatformResponseError
+    assert RetryError is PlatformRetryError
+    assert TransportError is PlatformTransportError
+    assert ClientPermissionError is PlatformPermissionError
+    assert ClientTimeoutError is PlatformTimeoutError
+
+
+def test_errors_are_catchable_as_vds_client_error() -> None:
+    errors = [AuthError("auth"), RateLimitError("rate"), NotFoundError("nf")]
+    for error in errors:
+        assert isinstance(error, VDSClientError)
+        assert isinstance(error, RuntimeError)
+
+
+def test_timeout_inherits_transport() -> None:
+    assert issubclass(ClientTimeoutError, TransportError)
+    assert issubclass(TransportError, VDSClientError)
+
+
+def test_error_instantiation_with_context() -> None:
+    error = VDSClientError("test", context={"service": "sonarqube"})
+    assert error.context == {"service": "sonarqube"}
+    assert "test" in str(error)