@ngocsangairvds/vsaf 4.1.8 → 4.1.9

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

@@ -1,419 +0,0 @@
-"""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/vds-scripts/sonarqube_orchestrator/tests/test_config.py

@@ -1,145 +0,0 @@
-"""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/vds-scripts/sonarqube_orchestrator/tests/test_errors.py

@@ -1,78 +0,0 @@
-"""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)