@ngocsangairvds/vsaf 3.2.13 → 3.2.15

package/tools/vds-scripts/audit_orchestrator/tests/test_models/test_findings.py

@@ -1,1159 +0,0 @@
-"""Tests for CheckFinding, SectionResult, and RepositoryAuditResult models.
-
-Tests audit result models, grade computation, and property methods.
-"""
-
-from __future__ import annotations
-
-import pytest
-from vds_audit_orchestrator.models.enums import (
-    CheckStatus,
-    MigrationEffort,
-    Priority,
-    Severity,
-)
-from vds_audit_orchestrator.models.findings import (
-    CheckFinding,
-    RepositoryAuditResult,
-    SectionResult,
-    compute_grade,
-)
-
-
-class TestCheckFinding:
-    """Tests for CheckFinding model."""
-
-    def test_create_minimal_finding(self) -> None:
-        """Test creating finding with minimal required fields."""
-        finding = CheckFinding(
-            check_id="check-001",
-            check_name="Test Check",
-            status=CheckStatus.PASS,
-            points_awarded=100.0,
-            max_points=100,
-            score_percentage=100.0,
-            severity=Severity.MEDIUM,
-            priority=Priority.P3,
-            migration_effort=MigrationEffort.LOW,
-        )
-        assert finding.check_id == "check-001"
-        assert finding.check_name == "Test Check"
-        assert finding.status == CheckStatus.PASS
-        assert finding.points_awarded == 100.0
-        assert finding.score_percentage == 100.0
-
-    def test_create_full_finding(self) -> None:
-        """Test creating finding with all fields."""
-        finding = CheckFinding(
-            check_id="check-001",
-            check_name="Test Check",
-            status=CheckStatus.FAIL,
-            points_awarded=0.0,
-            max_points=100,
-            score_percentage=0.0,
-            severity=Severity.CRITICAL,
-            priority=Priority.P1,
-            migration_effort=MigrationEffort.HIGH,
-            evidence=["Evidence 1", "Evidence 2"],
-            recommendation="Fix the issue",
-            confidence=0.9,
-            tags=["security", "git"],
-            metadata={"duration_ms": 100},
-        )
-        assert finding.evidence == ["Evidence 1", "Evidence 2"]
-        assert finding.recommendation == "Fix the issue"
-        assert finding.confidence == 0.9
-        assert finding.tags == ["security", "git"]
-        assert finding.metadata["duration_ms"] == 100
-
-    def test_score_percentage_validation(self) -> None:
-        """Test score_percentage must be between 0 and 100."""
-        with pytest.raises(ValueError):
-            CheckFinding(
-                check_id="check-001",
-                check_name="Test",
-                status=CheckStatus.PASS,
-                points_awarded=100.0,
-                max_points=100,
-                score_percentage=101.0,
-                severity=Severity.MEDIUM,
-                priority=Priority.P3,
-                migration_effort=MigrationEffort.LOW,
-            )
-
-        with pytest.raises(ValueError):
-            CheckFinding(
-                check_id="check-001",
-                check_name="Test",
-                status=CheckStatus.PASS,
-                points_awarded=100.0,
-                max_points=100,
-                score_percentage=-1.0,
-                severity=Severity.MEDIUM,
-                priority=Priority.P3,
-                migration_effort=MigrationEffort.LOW,
-            )
-
-    def test_points_awarded_validation(self) -> None:
-        """Test points_awarded must be non-negative."""
-        with pytest.raises(ValueError):
-            CheckFinding(
-                check_id="check-001",
-                check_name="Test",
-                status=CheckStatus.PASS,
-                points_awarded=-1.0,
-                max_points=100,
-                score_percentage=0.0,
-                severity=Severity.MEDIUM,
-                priority=Priority.P3,
-                migration_effort=MigrationEffort.LOW,
-            )
-
-    def test_max_points_validation(self) -> None:
-        """Test max_points must be non-negative."""
-        with pytest.raises(ValueError):
-            CheckFinding(
-                check_id="check-001",
-                check_name="Test",
-                status=CheckStatus.PASS,
-                points_awarded=0.0,
-                max_points=-1,
-                score_percentage=0.0,
-                severity=Severity.MEDIUM,
-                priority=Priority.P3,
-                migration_effort=MigrationEffort.LOW,
-            )
-
-    def test_confidence_validation(self) -> None:
-        """Test confidence must be between 0 and 1."""
-        with pytest.raises(ValueError):
-            CheckFinding(
-                check_id="check-001",
-                check_name="Test",
-                status=CheckStatus.PASS,
-                points_awarded=100.0,
-                max_points=100,
-                score_percentage=100.0,
-                severity=Severity.MEDIUM,
-                priority=Priority.P3,
-                migration_effort=MigrationEffort.LOW,
-                confidence=1.5,
-            )
-
-        with pytest.raises(ValueError):
-            CheckFinding(
-                check_id="check-001",
-                check_name="Test",
-                status=CheckStatus.PASS,
-                points_awarded=100.0,
-                max_points=100,
-                score_percentage=100.0,
-                severity=Severity.MEDIUM,
-                priority=Priority.P3,
-                migration_effort=MigrationEffort.LOW,
-                confidence=-0.1,
-            )
-
-    def test_passed_property(self) -> None:
-        """Test passed property returns True for PASS status."""
-        finding = CheckFinding(
-            check_id="check-001",
-            check_name="Test",
-            status=CheckStatus.PASS,
-            points_awarded=100.0,
-            max_points=100,
-            score_percentage=100.0,
-            severity=Severity.MEDIUM,
-            priority=Priority.P3,
-            migration_effort=MigrationEffort.LOW,
-        )
-        assert finding.passed is True
-
-    def test_passed_property_false(self) -> None:
-        """Test passed property returns False for non-PASS status."""
-        finding = CheckFinding(
-            check_id="check-001",
-            check_name="Test",
-            status=CheckStatus.FAIL,
-            points_awarded=0.0,
-            max_points=100,
-            score_percentage=0.0,
-            severity=Severity.MEDIUM,
-            priority=Priority.P3,
-            migration_effort=MigrationEffort.LOW,
-        )
-        assert finding.passed is False
-
-    def test_failed_property(self) -> None:
-        """Test failed property returns True for FAIL status."""
-        finding = CheckFinding(
-            check_id="check-001",
-            check_name="Test",
-            status=CheckStatus.FAIL,
-            points_awarded=0.0,
-            max_points=100,
-            score_percentage=0.0,
-            severity=Severity.MEDIUM,
-            priority=Priority.P3,
-            migration_effort=MigrationEffort.LOW,
-        )
-        assert finding.failed is True
-
-    def test_failed_property_for_warning(self) -> None:
-        """Test failed property returns True for WARNING status."""
-        finding = CheckFinding(
-            check_id="check-001",
-            check_name="Test",
-            status=CheckStatus.WARNING,
-            points_awarded=50.0,
-            max_points=100,
-            score_percentage=50.0,
-            severity=Severity.MEDIUM,
-            priority=Priority.P3,
-            migration_effort=MigrationEffort.LOW,
-        )
-        assert finding.failed is True
-
-    def test_is_applicable_property(self) -> None:
-        """Test is_applicable for different statuses."""
-        pass_finding = CheckFinding(
-            check_id="check-001",
-            check_name="Test",
-            status=CheckStatus.PASS,
-            points_awarded=100.0,
-            max_points=100,
-            score_percentage=100.0,
-            severity=Severity.MEDIUM,
-            priority=Priority.P3,
-            migration_effort=MigrationEffort.LOW,
-        )
-        assert pass_finding.is_applicable is True
-
-        na_finding = CheckFinding(
-            check_id="check-002",
-            check_name="Test",
-            status=CheckStatus.NA,
-            points_awarded=0.0,
-            max_points=100,
-            score_percentage=0.0,
-            severity=Severity.MEDIUM,
-            priority=Priority.P3,
-            migration_effort=MigrationEffort.LOW,
-        )
-        assert na_finding.is_applicable is False
-
-        error_finding = CheckFinding(
-            check_id="check-003",
-            check_name="Test",
-            status=CheckStatus.ERROR,
-            points_awarded=0.0,
-            max_points=100,
-            score_percentage=0.0,
-            severity=Severity.MEDIUM,
-            priority=Priority.P3,
-            migration_effort=MigrationEffort.LOW,
-        )
-        assert error_finding.is_applicable is False
-
-    def test_is_critical_property(self) -> None:
-        """Test is_critical property."""
-        critical_fail = CheckFinding(
-            check_id="check-001",
-            check_name="Test",
-            status=CheckStatus.FAIL,
-            points_awarded=0.0,
-            max_points=100,
-            score_percentage=0.0,
-            severity=Severity.CRITICAL,
-            priority=Priority.P1,
-            migration_effort=MigrationEffort.HIGH,
-        )
-        assert critical_fail.is_critical is True
-
-        critical_pass = CheckFinding(
-            check_id="check-002",
-            check_name="Test",
-            status=CheckStatus.PASS,
-            points_awarded=100.0,
-            max_points=100,
-            score_percentage=100.0,
-            severity=Severity.CRITICAL,
-            priority=Priority.P1,
-            migration_effort=MigrationEffort.HIGH,
-        )
-        assert critical_pass.is_critical is False  # Passed, not failed
-
-        high_fail = CheckFinding(
-            check_id="check-003",
-            check_name="Test",
-            status=CheckStatus.FAIL,
-            points_awarded=0.0,
-            max_points=100,
-            score_percentage=0.0,
-            severity=Severity.HIGH,
-            priority=Priority.P2,
-            migration_effort=MigrationEffort.MEDIUM,
-        )
-        assert high_fail.is_critical is False
-
-    def test_requires_action_property(self) -> None:
-        """Test requires_action property."""
-        fail_finding = CheckFinding(
-            check_id="check-001",
-            check_name="Test",
-            status=CheckStatus.FAIL,
-            points_awarded=0.0,
-            max_points=100,
-            score_percentage=0.0,
-            severity=Severity.HIGH,
-            priority=Priority.P2,
-            migration_effort=MigrationEffort.MEDIUM,
-        )
-        assert fail_finding.requires_action is True
-
-        error_finding = CheckFinding(
-            check_id="check-002",
-            check_name="Test",
-            status=CheckStatus.ERROR,
-            points_awarded=0.0,
-            max_points=100,
-            score_percentage=0.0,
-            severity=Severity.MEDIUM,
-            priority=Priority.P3,
-            migration_effort=MigrationEffort.LOW,
-        )
-        assert error_finding.requires_action is False  # ERROR doesn't require action
-
-        pass_finding = CheckFinding(
-            check_id="check-003",
-            check_name="Test",
-            status=CheckStatus.PASS,
-            points_awarded=100.0,
-            max_points=100,
-            score_percentage=100.0,
-            severity=Severity.LOW,
-            priority=Priority.P4,
-            migration_effort=MigrationEffort.LOW,
-        )
-        assert pass_finding.requires_action is False
-
-
-class TestSectionResult:
-    """Tests for SectionResult model."""
-
-    def test_create_minimal_section_result(self) -> None:
-        """Test creating section result with minimal fields."""
-        result = SectionResult(
-            section_id="security",
-            section_name="Security",
-            score_percentage=75.0,
-            weighted_contribution=37.5,
-        )
-        assert result.section_id == "security"
-        assert result.section_name == "Security"
-        assert result.score_percentage == 75.0
-        assert result.weighted_contribution == 37.5
-        assert result.confidence_factor == 1.0
-        assert result.coverage_factor == 1.0
-        assert result.passed_checks == 0
-        assert result.failed_checks == 0
-
-    def test_create_full_section_result(self) -> None:
-        """Test creating section result with all fields."""
-        findings = [
-            CheckFinding(
-                check_id="c1",
-                check_name="Check 1",
-                status=CheckStatus.PASS,
-                points_awarded=100.0,
-                max_points=100,
-                score_percentage=100.0,
-                severity=Severity.MEDIUM,
-                priority=Priority.P3,
-                migration_effort=MigrationEffort.LOW,
-            ),
-        ]
-        result = SectionResult(
-            section_id="security",
-            section_name="Security",
-            score_percentage=80.0,
-            weighted_contribution=40.0,
-            confidence_factor=0.9,
-            coverage_factor=0.95,
-            score_cap_applied=60.0,
-            passed_checks=1,
-            failed_checks=0,
-            findings=findings,
-            scoring_policy="weighted_mean",
-            target_score=90.0,
-            percent_to_target=88.9,
-            required_checks_passed=True,
-            metadata={"duration_ms": 500},
-        )
-        assert result.confidence_factor == 0.9
-        assert result.coverage_factor == 0.95
-        assert result.score_cap_applied == 60.0
-        assert result.target_score == 90.0
-
-    def test_total_checks_property(self) -> None:
-        """Test total_counts property."""
-        result = SectionResult(
-            section_id="security",
-            section_name="Security",
-            score_percentage=75.0,
-            weighted_contribution=37.5,
-            passed_checks=3,
-            failed_checks=1,
-        )
-        assert result.total_checks == 4
-
-    def test_total_checks_with_zero(self) -> None:
-        """Test total_checks when no checks run."""
-        result = SectionResult(
-            section_id="security",
-            section_name="Security",
-            score_percentage=0.0,
-            weighted_contribution=0.0,
-            passed_checks=0,
-            failed_checks=0,
-        )
-        assert result.total_checks == 0
-
-    def test_pass_rate_property(self) -> None:
-        """Test pass_rate calculation."""
-        result = SectionResult(
-            section_id="security",
-            section_name="Security",
-            score_percentage=75.0,
-            weighted_contribution=37.5,
-            passed_checks=3,
-            failed_checks=1,
-        )
-        assert result.pass_rate == 75.0
-
-    def test_pass_rate_with_zero_total(self) -> None:
-        """Test pass_rate returns 100 when no checks."""
-        result = SectionResult(
-            section_id="security",
-            section_name="Security",
-            score_percentage=0.0,
-            weighted_contribution=0.0,
-            passed_checks=0,
-            failed_checks=0,
-        )
-        assert result.pass_rate == 100.0
-
-    def test_critical_findings_property(self) -> None:
-        """Test critical_findings filters correctly."""
-        findings = [
-            CheckFinding(
-                check_id="c1",
-                check_name="Critical Fail",
-                status=CheckStatus.FAIL,
-                points_awarded=0.0,
-                max_points=100,
-                score_percentage=0.0,
-                severity=Severity.CRITICAL,
-                priority=Priority.P1,
-                migration_effort=MigrationEffort.HIGH,
-            ),
-            CheckFinding(
-                check_id="c2",
-                check_name="High Fail",
-                status=CheckStatus.FAIL,
-                points_awarded=0.0,
-                max_points=100,
-                score_percentage=0.0,
-                severity=Severity.HIGH,
-                priority=Priority.P2,
-                migration_effort=MigrationEffort.MEDIUM,
-            ),
-            CheckFinding(
-                check_id="c3",
-                check_name="Critical Pass",
-                status=CheckStatus.PASS,
-                points_awarded=100.0,
-                max_points=100,
-                score_percentage=100.0,
-                severity=Severity.CRITICAL,
-                priority=Priority.P1,
-                migration_effort=MigrationEffort.HIGH,
-            ),
-        ]
-        result = SectionResult(
-            section_id="security",
-            section_name="Security",
-            score_percentage=33.3,
-            weighted_contribution=16.7,
-            findings=findings,
-        )
-        critical = result.critical_findings
-        assert len(critical) == 1
-        assert critical[0].check_id == "c1"
-
-    def test_failed_required_checks_property(self) -> None:
-        """Test failed_required_checks filters by tag."""
-        findings = [
-            CheckFinding(
-                check_id="c1",
-                check_name="Required Fail",
-                status=CheckStatus.FAIL,
-                points_awarded=0.0,
-                max_points=100,
-                score_percentage=0.0,
-                severity=Severity.HIGH,
-                priority=Priority.P2,
-                migration_effort=MigrationEffort.MEDIUM,
-                tags=["required"],
-            ),
-            CheckFinding(
-                check_id="c2",
-                check_name="Optional Fail",
-                status=CheckStatus.FAIL,
-                points_awarded=0.0,
-                max_points=100,
-                score_percentage=0.0,
-                severity=Severity.LOW,
-                priority=Priority.P4,
-                migration_effort=MigrationEffort.LOW,
-                tags=["optional"],
-            ),
-        ]
-        result = SectionResult(
-            section_id="security",
-            section_name="Security",
-            score_percentage=0.0,
-            weighted_contribution=0.0,
-            findings=findings,
-        )
-        failed_required = result.failed_required_checks
-        assert len(failed_required) == 1
-        assert failed_required[0].check_id == "c1"
-
-    def test_error_findings_property(self) -> None:
-        """Test error_findings filters ERROR status."""
-        findings = [
-            CheckFinding(
-                check_id="c1",
-                check_name="Error",
-                status=CheckStatus.ERROR,
-                points_awarded=0.0,
-                max_points=100,
-                score_percentage=0.0,
-                severity=Severity.MEDIUM,
-                priority=Priority.P3,
-                migration_effort=MigrationEffort.LOW,
-            ),
-            CheckFinding(
-                check_id="c2",
-                check_name="Fail",
-                status=CheckStatus.FAIL,
-                points_awarded=0.0,
-                max_points=100,
-                score_percentage=0.0,
-                severity=Severity.MEDIUM,
-                priority=Priority.P3,
-                migration_effort=MigrationEffort.LOW,
-            ),
-        ]
-        result = SectionResult(
-            section_id="security",
-            section_name="Security",
-            score_percentage=0.0,
-            weighted_contribution=0.0,
-            findings=findings,
-        )
-        errors = result.error_findings
-        assert len(errors) == 1
-        assert errors[0].check_id == "c1"
-
-    def test_is_excluded_from_scoring_property(self) -> None:
-        """Test is_excluded_from_scoring when all ERROR."""
-        findings = [
-            CheckFinding(
-                check_id="c1",
-                check_name="Error 1",
-                status=CheckStatus.ERROR,
-                points_awarded=0.0,
-                max_points=100,
-                score_percentage=0.0,
-                severity=Severity.MEDIUM,
-                priority=Priority.P3,
-                migration_effort=MigrationEffort.LOW,
-            ),
-            CheckFinding(
-                check_id="c2",
-                check_name="Error 2",
-                status=CheckStatus.ERROR,
-                points_awarded=0.0,
-                max_points=100,
-                score_percentage=0.0,
-                severity=Severity.MEDIUM,
-                priority=Priority.P3,
-                migration_effort=MigrationEffort.LOW,
-            ),
-        ]
-        result = SectionResult(
-            section_id="security",
-            section_name="Security",
-            score_percentage=0.0,
-            weighted_contribution=0.0,
-            findings=findings,
-        )
-        assert result.is_excluded_from_scoring is True
-
-    def test_not_excluded_with_partial_errors(self) -> None:
-        """Test is_excluded_from_scoring when not all ERROR."""
-        findings = [
-            CheckFinding(
-                check_id="c1",
-                check_name="Pass",
-                status=CheckStatus.PASS,
-                points_awarded=100.0,
-                max_points=100,
-                score_percentage=100.0,
-                severity=Severity.MEDIUM,
-                priority=Priority.P3,
-                migration_effort=MigrationEffort.LOW,
-            ),
-            CheckFinding(
-                check_id="c2",
-                check_name="Error",
-                status=CheckStatus.ERROR,
-                points_awarded=0.0,
-                max_points=100,
-                score_percentage=0.0,
-                severity=Severity.MEDIUM,
-                priority=Priority.P3,
-                migration_effort=MigrationEffort.LOW,
-            ),
-        ]
-        result = SectionResult(
-            section_id="security",
-            section_name="Security",
-            score_percentage=50.0,
-            weighted_contribution=25.0,
-            findings=findings,
-        )
-        assert result.is_excluded_from_scoring is False
-
-
-class TestRepositoryAuditResult:
-    """Tests for RepositoryAuditResult model."""
-
-    def test_create_minimal_result(self) -> None:
-        """Test creating minimal repository result."""
-        result = RepositoryAuditResult(
-            repository_name="test-repo",
-            project_key="TEST",
-            overall_score=75.0,
-            grade="B",
-        )
-        assert result.repository_name == "test-repo"
-        assert result.project_key == "TEST"
-        assert result.overall_score == 75.0
-        assert result.grade == "B"
-        assert result.sections == []
-        assert result.total_checks == 0
-
-    def test_create_full_result(self) -> None:
-        """Test creating full repository result."""
-        sections = [
-            SectionResult(
-                section_id="security",
-                section_name="Security",
-                score_percentage=90.0,
-                weighted_contribution=45.0,
-                passed_checks=2,
-                failed_checks=0,
-            ),
-            SectionResult(
-                section_id="quality",
-                section_name="Quality",
-                score_percentage=60.0,
-                weighted_contribution=30.0,
-                passed_checks=1,
-                failed_checks=1,
-            ),
-        ]
-        result = RepositoryAuditResult(
-            repository_name="test-repo",
-            project_key="TEST",
-            overall_score=75.0,
-            grade="B",
-            sections=sections,
-            total_checks=4,
-            passed_checks=3,
-            failed_checks=1,
-            critical_issues=0,
-            high_issues=1,
-            medium_issues=0,
-            low_issues=0,
-            template_name="VDS Audit",
-            template_version="1.0.0",
-            audit_metadata={"duration_seconds": 300},
-        )
-        assert len(result.sections) == 2
-        assert result.template_name == "VDS Audit"
-        assert result.audit_metadata["duration_seconds"] == 300
-
-    def test_overall_score_validation(self) -> None:
-        """Test overall_score must be between 0 and 100."""
-        with pytest.raises(ValueError):
-            RepositoryAuditResult(
-                repository_name="test-repo",
-                project_key="TEST",
-                overall_score=101.0,
-                grade="A",
-            )
-
-        with pytest.raises(ValueError):
-            RepositoryAuditResult(
-                repository_name="test-repo",
-                project_key="TEST",
-                overall_score=-1.0,
-                grade="F",
-            )
-
-    def test_grade_validation(self) -> None:
-        """Test grade validation accepts valid values."""
-        valid_grades = ["A", "B", "C", "D", "F", "N/A"]
-        for grade in valid_grades:
-            result = RepositoryAuditResult(
-                repository_name="test-repo",
-                project_key="TEST",
-                overall_score=75.0,
-                grade=grade,
-            )
-            assert result.grade == grade
-
-    def test_grade_validation_rejects_invalid(self) -> None:
-        """Test grade validation rejects invalid values."""
-        with pytest.raises(ValueError, match="Invalid grade"):
-            RepositoryAuditResult(
-                repository_name="test-repo",
-                project_key="TEST",
-                overall_score=75.0,
-                grade="E",
-            )
-
-    def test_pass_rate_property(self) -> None:
-        """Test pass_rate calculation."""
-        result = RepositoryAuditResult(
-            repository_name="test-repo",
-            project_key="TEST",
-            overall_score=75.0,
-            grade="B",
-            total_checks=10,
-            passed_checks=8,
-            failed_checks=2,
-        )
-        assert result.pass_rate == 80.0
-
-    def test_pass_rate_with_zero_total(self) -> None:
-        """Test pass_rate returns 100 when no checks."""
-        result = RepositoryAuditResult(
-            repository_name="test-repo",
-            project_key="TEST",
-            overall_score=100.0,
-            grade="A",
-            total_checks=0,
-            passed_checks=0,
-            failed_checks=0,
-        )
-        assert result.pass_rate == 100.0
-
-    def test_all_critical_findings_property(self) -> None:
-        """Test all_critical_findings aggregates across sections."""
-        sections = [
-            SectionResult(
-                section_id="security",
-                section_name="Security",
-                score_percentage=50.0,
-                weighted_contribution=25.0,
-                findings=[
-                    CheckFinding(
-                        check_id="c1",
-                        check_name="Critical Fail",
-                        status=CheckStatus.FAIL,
-                        points_awarded=0.0,
-                        max_points=100,
-                        score_percentage=0.0,
-                        severity=Severity.CRITICAL,
-                        priority=Priority.P1,
-                        migration_effort=MigrationEffort.HIGH,
-                    ),
-                    CheckFinding(
-                        check_id="c2",
-                        check_name="Critical Pass",
-                        status=CheckStatus.PASS,
-                        points_awarded=100.0,
-                        max_points=100,
-                        score_percentage=100.0,
-                        severity=Severity.CRITICAL,
-                        priority=Priority.P1,
-                        migration_effort=MigrationEffort.HIGH,
-                    ),
-                ],
-            ),
-            SectionResult(
-                section_id="quality",
-                section_name="Quality",
-                score_percentage=100.0,
-                weighted_contribution=50.0,
-                findings=[
-                    CheckFinding(
-                        check_id="c3",
-                        check_name="High Fail",
-                        status=CheckStatus.FAIL,
-                        points_awarded=0.0,
-                        max_points=100,
-                        score_percentage=0.0,
-                        severity=Severity.HIGH,
-                        priority=Priority.P2,
-                        migration_effort=MigrationEffort.MEDIUM,
-                    ),
-                ],
-            ),
-        ]
-        result = RepositoryAuditResult(
-            repository_name="test-repo",
-            project_key="TEST",
-            overall_score=75.0,
-            grade="C",
-            sections=sections,
-        )
-        critical = result.critical_findings
-        assert len(critical) == 1
-        assert critical[0].check_id == "c1"
-
-    def test_all_failed_findings_property(self) -> None:
-        """Test all_failed_findings aggregates across sections."""
-        sections = [
-            SectionResult(
-                section_id="security",
-                section_name="Security",
-                score_percentage=66.7,
-                weighted_contribution=33.3,
-                findings=[
-                    CheckFinding(
-                        check_id="c1",
-                        check_name="Fail",
-                        status=CheckStatus.FAIL,
-                        points_awarded=0.0,
-                        max_points=100,
-                        score_percentage=0.0,
-                        severity=Severity.HIGH,
-                        priority=Priority.P2,
-                        migration_effort=MigrationEffort.MEDIUM,
-                    ),
-                    CheckFinding(
-                        check_id="c2",
-                        check_name="Pass",
-                        status=CheckStatus.PASS,
-                        points_awarded=100.0,
-                        max_points=100,
-                        score_percentage=100.0,
-                        severity=Severity.LOW,
-                        priority=Priority.P4,
-                        migration_effort=MigrationEffort.LOW,
-                    ),
-                ],
-            ),
-        ]
-        result = RepositoryAuditResult(
-            repository_name="test-repo",
-            project_key="TEST",
-            overall_score=66.7,
-            grade="C",
-            sections=sections,
-        )
-        failed = result.all_failed_findings
-        assert len(failed) == 1
-        assert failed[0].check_id == "c1"
-
-    def test_sections_by_score_property(self) -> None:
-        """Test sections_by_score sorts ascending."""
-        sections = [
-            SectionResult(
-                section_id="quality",
-                section_name="Quality",
-                score_percentage=60.0,
-                weighted_contribution=30.0,
-            ),
-            SectionResult(
-                section_id="security",
-                section_name="Security",
-                score_percentage=90.0,
-                weighted_contribution=45.0,
-            ),
-            SectionResult(
-                section_id="docs",
-                section_name="Docs",
-                score_percentage=75.0,
-                weighted_contribution=37.5,
-            ),
-        ]
-        result = RepositoryAuditResult(
-            repository_name="test-repo",
-            project_key="TEST",
-            overall_score=75.0,
-            grade="B",
-            sections=sections,
-        )
-        sorted_sections = result.sections_by_score
-        assert sorted_sections[0][0] == "quality"
-        assert sorted_sections[0][1] == 60.0
-        assert sorted_sections[-1][0] == "security"
-        assert sorted_sections[-1][1] == 90.0
-
-    def test_weakest_sections_property(self) -> None:
-        """Test weakest_sections returns bottom 3."""
-        sections = [
-            SectionResult(
-                section_id="s1",
-                section_name="Section 1",
-                score_percentage=50.0,
-                weighted_contribution=25.0,
-            ),
-            SectionResult(
-                section_id="s2",
-                section_name="Section 2",
-                score_percentage=60.0,
-                weighted_contribution=30.0,
-            ),
-            SectionResult(
-                section_id="s3",
-                section_name="Section 3",
-                score_percentage=70.0,
-                weighted_contribution=35.0,
-            ),
-            SectionResult(
-                section_id="s4",
-                section_name="Section 4",
-                score_percentage=90.0,
-                weighted_contribution=45.0,
-            ),
-        ]
-        result = RepositoryAuditResult(
-            repository_name="test-repo",
-            project_key="TEST",
-            overall_score=67.5,
-            grade="C",
-            sections=sections,
-        )
-        weakest = result.weakest_sections
-        assert len(weakest) == 3
-        assert weakest[0][1] == 50.0
-        assert weakest[1][1] == 60.0
-        assert weakest[2][1] == 70.0
-
-    def test_strongest_sections_property(self) -> None:
-        """Test strongest_sections returns top 3."""
-        sections = [
-            SectionResult(
-                section_id="s1",
-                section_name="Section 1",
-                score_percentage=50.0,
-                weighted_contribution=25.0,
-            ),
-            SectionResult(
-                section_id="s2",
-                section_name="Section 2",
-                score_percentage=95.0,
-                weighted_contribution=47.5,
-            ),
-            SectionResult(
-                section_id="s3",
-                section_name="Section 3",
-                score_percentage=85.0,
-                weighted_contribution=42.5,
-            ),
-            SectionResult(
-                section_id="s4",
-                section_name="Section 4",
-                score_percentage=90.0,
-                weighted_contribution=45.0,
-            ),
-        ]
-        result = RepositoryAuditResult(
-            repository_name="test-repo",
-            project_key="TEST",
-            overall_score=80.0,
-            grade="B",
-            sections=sections,
-        )
-        strongest = result.strongest_sections
-        assert len(strongest) == 3
-        assert strongest[0][1] == 85.0
-        assert strongest[1][1] == 90.0
-        assert strongest[2][1] == 95.0
-
-    def test_get_section_result(self) -> None:
-        """Test get_section_result retrieves by ID."""
-        sections = [
-            SectionResult(
-                section_id="security",
-                section_name="Security",
-                score_percentage=90.0,
-                weighted_contribution=45.0,
-            ),
-            SectionResult(
-                section_id="quality",
-                section_name="Quality",
-                score_percentage=60.0,
-                weighted_contribution=30.0,
-            ),
-        ]
-        result = RepositoryAuditResult(
-            repository_name="test-repo",
-            project_key="TEST",
-            overall_score=75.0,
-            grade="B",
-            sections=sections,
-        )
-        section = result.get_section_result("security")
-        assert section is not None
-        assert section.section_id == "security"
-
-        not_found = result.get_section_result("missing")
-        assert not_found is None
-
-    def test_get_findings_by_severity(self) -> None:
-        """Test get_findings_by_severity filters correctly."""
-        sections = [
-            SectionResult(
-                section_id="security",
-                section_name="Security",
-                score_percentage=33.3,
-                weighted_contribution=16.7,
-                findings=[
-                    CheckFinding(
-                        check_id="c1",
-                        check_name="Critical",
-                        status=CheckStatus.FAIL,
-                        points_awarded=0.0,
-                        max_points=100,
-                        score_percentage=0.0,
-                        severity=Severity.CRITICAL,
-                        priority=Priority.P1,
-                        migration_effort=MigrationEffort.HIGH,
-                    ),
-                    CheckFinding(
-                        check_id="c2",
-                        check_name="High",
-                        status=CheckStatus.FAIL,
-                        points_awarded=0.0,
-                        max_points=100,
-                        score_percentage=0.0,
-                        severity=Severity.HIGH,
-                        priority=Priority.P2,
-                        migration_effort=MigrationEffort.MEDIUM,
-                    ),
-                ],
-            ),
-        ]
-        result = RepositoryAuditResult(
-            repository_name="test-repo",
-            project_key="TEST",
-            overall_score=33.3,
-            grade="F",
-            sections=sections,
-        )
-        critical = result.get_findings_by_severity(Severity.CRITICAL)
-        assert len(critical) == 1
-        assert critical[0].check_id == "c1"
-
-        high = result.get_findings_by_severity(Severity.HIGH)
-        assert len(high) == 1
-        assert high[0].check_id == "c2"
-
-        low = result.get_findings_by_severity(Severity.LOW)
-        assert len(low) == 0
-
-    def test_get_findings_by_tag(self) -> None:
-        """Test get_findings_by_tag filters correctly."""
-        sections = [
-            SectionResult(
-                section_id="security",
-                section_name="Security",
-                score_percentage=50.0,
-                weighted_contribution=25.0,
-                findings=[
-                    CheckFinding(
-                        check_id="c1",
-                        check_name="Security Finding",
-                        status=CheckStatus.FAIL,
-                        points_awarded=0.0,
-                        max_points=100,
-                        score_percentage=0.0,
-                        severity=Severity.HIGH,
-                        priority=Priority.P2,
-                        migration_effort=MigrationEffort.MEDIUM,
-                        tags=["security"],
-                    ),
-                    CheckFinding(
-                        check_id="c2",
-                        check_name="Quality Finding",
-                        status=CheckStatus.FAIL,
-                        points_awarded=0.0,
-                        max_points=100,
-                        score_percentage=0.0,
-                        severity=Severity.MEDIUM,
-                        priority=Priority.P3,
-                        migration_effort=MigrationEffort.LOW,
-                        tags=["quality"],
-                    ),
-                ],
-            ),
-        ]
-        result = RepositoryAuditResult(
-            repository_name="test-repo",
-            project_key="TEST",
-            overall_score=50.0,
-            grade="F",
-            sections=sections,
-        )
-        security = result.get_findings_by_tag("security")
-        assert len(security) == 1
-        assert security[0].check_id == "c1"
-
-        quality = result.get_findings_by_tag("quality")
-        assert len(quality) == 1
-        assert quality[0].check_id == "c2"
-
-
-class TestComputeGrade:
-    """Tests for compute_grade function."""
-
-    @pytest.mark.parametrize(
-        ("score", "expected_grade"),
-        [
-            (100, "A"),
-            (95, "A"),
-            (90, "A"),
-            (89, "B"),
-            (85, "B"),
-            (80, "B"),
-            (79, "C"),
-            (75, "C"),
-            (70, "C"),
-            (69, "D"),
-            (65, "D"),
-            (60, "D"),
-            (59, "F"),
-            (50, "F"),
-            (0, "F"),
-        ],
-    )
-    def test_compute_grade_boundaries(self, score: float, expected_grade: str) -> None:
-        """Test grade computation at score boundaries."""
-        assert compute_grade(score) == expected_grade
-
-    def test_compute_grade_exact_boundaries(self) -> None:
-        """Test exact grade boundary values."""
-        assert compute_grade(90.0) == "A"
-        assert compute_grade(80.0) == "B"
-        assert compute_grade(70.0) == "C"
-        assert compute_grade(60.0) == "D"
-        assert compute_grade(59.99) == "F"