@ngocsangairvds/vsaf 3.2.14 → 3.2.16

package/tools/vds-scripts/audit_orchestrator/tests/test_engine/test_phase145a_completion.py

@@ -1,209 +0,0 @@
-"""Tests for Phase 145a completion: TSK-145.4, TSK-145.5, TSK-145.12."""
-
-from __future__ import annotations
-
-import contextlib
-from unittest.mock import MagicMock, patch
-
-import pytest
-from vds_audit_orchestrator.engine.batch_processor import BatchConfig, BatchRowProcessor
-from vds_audit_orchestrator.engine.row_evaluator_types import (
-    ConsistencyRetryMode,
-    RowEvaluationResult,
-    RowEvaluatorConfig,
-)
-from vds_audit_orchestrator.models.checklist import RowProvenance, RowStatus, ScoreBreakdown
-
-# ---------------------------------------------------------------------------
-# Helpers
-# ---------------------------------------------------------------------------
-
-
-def _build_processor(*, row_concurrency: int = 1, batch_error_retry_limit: int = 0) -> BatchRowProcessor:
-    """Build a minimal BatchRowProcessor for test use."""
-    check = MagicMock()
-    check.id = "CL-001"
-    template = MagicMock()
-    template.sections = [MagicMock(id="SEC-1", checks=[check])]
-
-    evaluator = MagicMock()
-    evaluator.get_row_runtime_progress.return_value = None
-    evaluator.clear_row_runtime_progress.return_value = None
-    evaluator.template_hash = "template-hash"
-    evaluator.evidence_hash = "evidence-hash"
-    evaluator.config = MagicMock()
-    evaluator.config.mode.value = "test"
-
-    evidence_context = MagicMock()
-    evidence_context.format_for_llm.return_value = "evidence"
-    evidence_context.evidence_refs = []
-    evidence_context.retrieval_trace = None
-
-    matcher = MagicMock()
-    matcher.match_row.return_value = evidence_context
-
-    return BatchRowProcessor(
-        template=template,
-        evaluator=evaluator,
-        evidence_matcher=matcher,
-        config=BatchConfig(
-            batch_size=1,
-            row_timeout_ms=500,
-            row_concurrency=row_concurrency,
-            batch_error_retry_limit=batch_error_retry_limit,
-        ),
-    )
-
-
-def _error_result(row_id: str = "CL-001:row_0", check_id: str = "CL-001") -> RowEvaluationResult:
-    from datetime import UTC, datetime
-
-    return RowEvaluationResult(
-        row_id=row_id,
-        check_id=check_id,
-        status=RowStatus.ERROR,
-        score=0.0,
-        score_breakdown=ScoreBreakdown.compute(0.0),
-        reason="provider_error",
-        finding="error",
-        evidence_anchors=[],
-        provenance=RowProvenance(
-            row_llm_mode="test",
-            protocol=None,
-            model=None,
-            template_hash="hash",
-            rubric_version="1",
-            evidence_hash="hash",
-            evaluated_at=datetime.now(UTC),
-            failover_count=0,
-            failover_chain=[],
-        ),
-        retry_metadata={"reason_code": "transient_error"},
-    )
-
-
-# ---------------------------------------------------------------------------
-# TSK-145.4 — provider_failover_auto_enabled telemetry
-# ---------------------------------------------------------------------------
-
-
-def test_provider_failover_auto_enabled_telemetry(monkeypatch: pytest.MonkeyPatch) -> None:
-    """Auto-derived failover profiles emit provider_failover_auto_enabled log."""
-    monkeypatch.delenv("VDS_AUDIT_LLM__ROW_FAILOVER_PROFILES", raising=False)
-    monkeypatch.setenv("VDS_AUDIT_ACTIVE_PROFILE", "primary-profile")
-
-    auto_profiles = ["fallback-openai", "fallback-azure"]
-
-    def fake_resolve(active: str | None) -> list[str]:
-        return auto_profiles
-
-    import asyncio
-
-    import vds_audit_orchestrator.engine.batch_processor as bp_mod
-
-    processor = _build_processor()
-
-    with (
-        patch.object(bp_mod, "resolve_default_failover_profiles", side_effect=fake_resolve),
-        patch.object(bp_mod, "logger") as mock_logger,
-    ):
-        with contextlib.suppress(Exception):
-            asyncio.run(processor.process_all(thread_id="test-145-4"))
-
-        info_calls = [
-            call
-            for call in mock_logger.info.call_args_list
-            if call.args and call.args[0] == "provider_failover_auto_enabled"
-        ]
-
-    assert info_calls, "Expected 'provider_failover_auto_enabled' info log to be emitted"
-    first_call = info_calls[0]
-    assert first_call.kwargs.get("source") == "auto_derived"
-    assert first_call.kwargs.get("failover_profiles") == auto_profiles
-
-
-# ---------------------------------------------------------------------------
-# TSK-145.12 — consistency_retry_enabled default True
-# ---------------------------------------------------------------------------
-
-
-def test_consistency_retry_enabled_default_true() -> None:
-    """RowEvaluatorConfig() should have consistency_retry_enabled=True by default."""
-    config = RowEvaluatorConfig()
-    assert config.consistency_retry_enabled is True, "consistency_retry_enabled must default to True (TSK-145.12)"
-
-
-def test_consistency_retry_mode_default_auto() -> None:
-    """RowEvaluatorConfig() should keep consistency_retry_mode=AUTO by default."""
-    config = RowEvaluatorConfig()
-    assert config.consistency_retry_mode == ConsistencyRetryMode.AUTO, (
-        "consistency_retry_mode must default to ConsistencyRetryMode.AUTO"
-    )
-
-
-# ---------------------------------------------------------------------------
-# TSK-145.5 — _retry_error_rows wired into parallel path
-# ---------------------------------------------------------------------------
-
-
-@pytest.mark.asyncio
-async def test_process_batch_parallel_calls_retry_sweep(monkeypatch: pytest.MonkeyPatch) -> None:
-    """_retry_error_rows must be called in the parallel path when error rows exist."""
-    monkeypatch.delenv("VDS_AUDIT_LLM__ROW_FAILOVER_PROFILES", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_ACTIVE_PROFILE", raising=False)
-
-    processor = _build_processor(row_concurrency=2, batch_error_retry_limit=3)
-
-    # Pre-set the batch-level attributes that _process_batch would normally populate
-    from vds_audit_orchestrator.engine.provider_failure_classifier import ProviderHealthMemory
-
-    processor._batch_health_memory = ProviderHealthMemory()
-    processor._batch_failover_profiles = ["fallback-profile"]
-
-    # Make the evaluator return an ERROR result so the retry sweep is triggered
-    error_res = _error_result()
-
-    async def _fake_aevaluate(**_: object) -> RowEvaluationResult:
-        return error_res
-
-    processor.evaluator.aevaluate_row.side_effect = _fake_aevaluate
-
-    retry_called_with: list[dict] = []
-
-    async def _fake_retry_error_rows(
-        results,
-        health_memory,
-        budget,
-        failover_profiles,
-        project_profile,
-        stats=None,
-    ) -> list[RowEvaluationResult]:
-        retry_called_with.append(
-            {
-                "results": list(results),
-                "failover_profiles": list(failover_profiles),
-                "project_profile": project_profile,
-            }
-        )
-        # Return the same results unchanged (no actual retry needed for this test)
-        return list(results)
-
-    processor._retry_error_rows = _fake_retry_error_rows  # type: ignore[method-assign]
-
-    # Wire the parallel path by patching resolve_default_failover_profiles
-    import vds_audit_orchestrator.engine.batch_processor as bp_mod
-
-    with patch.object(bp_mod, "resolve_default_failover_profiles", return_value=["fallback-profile"]):
-        await processor._process_batch_parallel(
-            batch_idx=0,
-            start_idx=0,
-            end_idx=1,
-            project_profile=None,
-            checkpoint=MagicMock(results_by_row_id={}),
-            thread_id="test-145-5",
-        )
-
-    assert retry_called_with, (
-        "_retry_error_rows was NOT called in _process_batch_parallel despite error rows and retry limit > 0"
-    )
-    assert retry_called_with[0]["failover_profiles"] == ["fallback-profile"]

package/tools/vds-scripts/audit_orchestrator/tests/test_engine/test_phase31_row_consistency_retry_benchmark.py

@@ -1,150 +0,0 @@
-"""Phase 31 benchmark/regression tests for row consistency retry policy."""
-
-from __future__ import annotations
-
-import json
-import time
-from pathlib import Path
-
-import pytest
-from vds_audit_orchestrator.engine.llm_row_evaluator import LLMRowEvaluator
-from vds_audit_orchestrator.engine.row_evaluator_types import (
-    ConsistencyRetryMode,
-    RowEvaluatorConfig,
-    RowLLMMode,
-)
-from vds_audit_orchestrator.llm.audit_schemas import RowEvaluationRequest, RowEvaluationResponse
-from vds_audit_orchestrator.models.template import AuditCheck
-
-
-def _build_semantic_check() -> AuditCheck:
-    return AuditCheck(
-        id="CHK-RETRY-001",
-        name="README quality",
-        description="README quality must be adequate",
-        check_type="readme_quality",
-        weight=2.0,
-        section_id="documentation",
-        max_points=100,
-    )
-
-
-def _build_contradictory_response() -> RowEvaluationResponse:
-    return RowEvaluationResponse(
-        reasoning="Thiếu bằng chứng.",
-        reason="Không có bằng chứng để đánh giá.",
-        score=30.0,
-        confidence=0.8,
-        finding="Cần bổ sung bằng chứng.",
-        evidence_anchors=[],
-        priority="P1",
-        effort="M",
-        fix_suggestions=[],
-    )
-
-
-def _build_consistent_response() -> RowEvaluationResponse:
-    return RowEvaluationResponse(
-        reasoning="Đã đánh giá theo refs.",
-        reason="Có bằng chứng trong refs nhưng mức độ đáp ứng còn một phần.",
-        score=65.0,
-        confidence=0.8,
-        finding="Cần tăng độ bao phủ bằng chứng liên quan trực tiếp.",
-        evidence_anchors=[{"ref_type": "path", "ref_value": "README.md", "excerpt": ""}],
-        priority="P2",
-        effort="M",
-        fix_suggestions=[],
-    )
-
-
-def _build_evaluator(mode: ConsistencyRetryMode) -> LLMRowEvaluator:
-    return LLMRowEvaluator(
-        config=RowEvaluatorConfig(
-            mode=RowLLMMode.SELECTIVE,
-            cache_enabled=False,
-            consistency_retry_enabled=(mode != ConsistencyRetryMode.OFF),
-            consistency_retry_mode=mode,
-        ),
-        template_hash="phase31-template-hash",
-    )
-
-
-def _run_timed_evaluate(mode: ConsistencyRetryMode, delay_seconds: float = 0.01) -> dict[str, float | int | str]:
-    evaluator = _build_evaluator(mode)
-    check = _build_semantic_check()
-    call_count = 0
-
-    def _fake_call_llm(_request: RowEvaluationRequest, **kwargs) -> RowEvaluationResponse:
-        nonlocal call_count
-        call_count += 1
-        time.sleep(delay_seconds)
-        if call_count == 1:
-            return _build_contradictory_response()
-        return _build_consistent_response()
-
-    evaluator._call_llm = _fake_call_llm  # type: ignore[method-assign]
-
-    started = time.perf_counter()
-    result = evaluator.evaluate(
-        check=check,
-        evidence_context="Evidence exists for this requirement.",
-        evidence_refs=["README.md"],
-        row_id=f"row-{mode.value}",
-    )
-    elapsed_ms = (time.perf_counter() - started) * 1000
-
-    return {
-        "mode": mode.value,
-        "call_count": call_count,
-        "elapsed_ms": round(elapsed_ms, 3),
-        "reason": result.reason,
-    }
-
-
-@pytest.mark.skip(
-    reason=(
-        "_should_consistency_retry was removed from LLMRowEvaluator during FR-92 "
-        "decomposition. Phase 31 retry policy decision matrix is no longer testable "
-        "at this level."
-    )
-)
-def test_phase31_retry_policy_decision_matrix_artifact(tmp_path: Path) -> None:
-    """Document decision-level policy behavior for off/auto/always."""
-    pytest.fail("_should_consistency_retry no longer exists on LLMRowEvaluator")
-
-
-def test_phase31_retry_policy_timing_regression_artifact(tmp_path: Path) -> None:
-    """Benchmark contradiction path: off should be faster than auto/always."""
-    delay_seconds = 0.01
-    off = _run_timed_evaluate(ConsistencyRetryMode.OFF, delay_seconds=delay_seconds)
-    auto = _run_timed_evaluate(ConsistencyRetryMode.AUTO, delay_seconds=delay_seconds)
-    always = _run_timed_evaluate(ConsistencyRetryMode.ALWAYS, delay_seconds=delay_seconds)
-
-    assert off["call_count"] == 2
-    # AUTO fires consistency retry when the primary response contains an evidence-absence claim
-    # ("không có bằng chứng"). With the unverified-ref retry also active (ratio=1.0),
-    # AUTO accumulates 4 calls: primary (1) + unverified-ref retry (2) — both rejected by
-    # the guardrail — then consistency retry (3) + its own unverified-ref retry (4).
-    assert auto["call_count"] == 4
-    assert always["call_count"] == 4
-    assert "có bằng chứng" in str(off["reason"]).lower()
-
-    # `always` and `auto` both make 4 calls; `off` makes 2.
-    # Both are guaranteed slower than `off`.
-    min_expected_delta_ms = delay_seconds * 1000 * 0.7
-    assert float(auto["elapsed_ms"]) - float(off["elapsed_ms"]) >= min_expected_delta_ms
-    assert float(always["elapsed_ms"]) - float(off["elapsed_ms"]) >= min_expected_delta_ms
-
-    artifact = {
-        "phase": 31,
-        "kind": "row_consistency_retry_timing",
-        "delay_per_llm_call_ms": int(delay_seconds * 1000),
-        "results": [off, auto, always],
-    }
-    artifact_path = tmp_path / "phase31_retry_timing.json"
-    artifact_path.write_text(json.dumps(artifact, indent=2, ensure_ascii=False), encoding="utf-8")
-
-    payload = json.loads(artifact_path.read_text(encoding="utf-8"))
-    assert payload["phase"] == 31
-    assert payload["kind"] == "row_consistency_retry_timing"
-    assert [item["mode"] for item in payload["results"]] == ["off", "auto", "always"]

package/tools/vds-scripts/audit_orchestrator/tests/test_engine/test_profile_detector.py

@@ -1,286 +0,0 @@
-"""Unit tests for ProfileDetector (TSK-026).
-
-Tests the profile detection engine for automatic project profiling
-based on repository structure, build files, and manifest configurations.
-"""
-
-from __future__ import annotations
-
-from pathlib import Path
-
-import pytest
-import yaml
-from vds_audit_orchestrator.profiles.detection import ProfileDetector
-from vds_audit_orchestrator.profiles.models import (
-    BusinessCriticality,
-    ChangeVelocity,
-    DataSensitivity,
-    Domain,
-    Exposure,
-    ProjectType,
-    RiskLevel,
-    ServiceType,
-    TechStack,
-    default_profile,
-)
-
-
-class TestProfileDetectorInit:
-    """Tests for ProfileDetector initialization."""
-
-    def test_init_with_repo_path(self, tmp_path: Path) -> None:
-        """ProfileDetector should initialize with repo_path."""
-        detector = ProfileDetector(repo_path=tmp_path)
-        assert detector.repo_path == tmp_path
-        assert detector._profile is None
-
-
-class TestProfileDetectorDomainDetection:
-    """Tests for domain detection from repository path."""
-
-    def test_detect_lending_domain_from_lep_path(self, tmp_path: Path) -> None:
-        """LEP in path should detect LENDING domain."""
-        repo_path = tmp_path / "LEP-project" / "lending-service"
-        repo_path.mkdir(parents=True)
-
-        detector = ProfileDetector(repo_path=repo_path)
-        domain = detector._detect_domain()
-
-        assert domain == Domain.LENDING
-
-    def test_detect_insurance_domain_from_path(self, tmp_path: Path) -> None:
-        """INSURANCE in path should detect INSURANCE domain."""
-        repo_path = tmp_path / "INSURANCE-project" / "insurance-claim-service"
-        repo_path.mkdir(parents=True)
-
-        detector = ProfileDetector(repo_path=repo_path)
-        domain = detector._detect_domain()
-
-        assert domain == Domain.INSURANCE
-
-    def test_detect_savings_domain_from_path(self, tmp_path: Path) -> None:
-        """SAVING in path should detect SAVINGS domain."""
-        repo_path = tmp_path / "SAVING-project" / "saving-account"
-        repo_path.mkdir(parents=True)
-
-        detector = ProfileDetector(repo_path=repo_path)
-        domain = detector._detect_domain()
-
-        assert domain == Domain.SAVINGS
-
-    def test_detect_ekyc_domain_from_path(self, tmp_path: Path) -> None:
-        """EKYC in path should detect EKYC domain."""
-        repo_path = tmp_path / "EKYC-project" / "ekyc-service"
-        repo_path.mkdir(parents=True)
-
-        detector = ProfileDetector(repo_path=repo_path)
-        domain = detector._detect_domain()
-
-        assert domain == Domain.EKYC
-
-    def test_detect_platform_domain_from_path(self, tmp_path: Path) -> None:
-        """PLATFORM in path should detect PLATFORM domain."""
-        repo_path = tmp_path / "platform" / "common-service"
-        repo_path.mkdir(parents=True)
-
-        detector = ProfileDetector(repo_path=repo_path)
-        domain = detector._detect_domain()
-
-        assert domain == Domain.PLATFORM
-
-    def test_detect_unknown_domain_for_generic_path(self, tmp_path: Path) -> None:
-        """Unknown path should detect UNKNOWN domain."""
-        repo_path = tmp_path / "some-project" / "my-service"
-        repo_path.mkdir(parents=True)
-
-        detector = ProfileDetector(repo_path=repo_path)
-        domain = detector._detect_domain()
-
-        assert domain == Domain.UNKNOWN
-
-
-class TestProfileDetectorRiskInference:
-    """Tests for risk level and data sensitivity inference."""
-
-    def test_infer_critical_risk_for_lending_with_financial_data(self) -> None:
-        """LENDING domain should infer CRITICAL risk."""
-        from vds_audit_orchestrator.profiles.models import FeatureFlags
-
-        detector = ProfileDetector(repo_path=Path("/tmp"))
-        features = FeatureFlags(has_financial_data=True)
-        risk = detector._infer_risk_level(Domain.LENDING, features)
-
-        assert risk == RiskLevel.CRITICAL
-
-    def test_infer_high_risk_for_insurance(self) -> None:
-        """INSURANCE domain should infer HIGH risk."""
-        from vds_audit_orchestrator.profiles.models import FeatureFlags
-
-        detector = ProfileDetector(repo_path=Path("/tmp"))
-        features = FeatureFlags()
-        risk = detector._infer_risk_level(Domain.INSURANCE, features)
-
-        assert risk == RiskLevel.HIGH
-
-    def test_infer_high_risk_for_ekyc_with_pii_data(self) -> None:
-        """EKYC domain with PII data should infer HIGH risk."""
-        from vds_audit_orchestrator.profiles.models import FeatureFlags
-
-        detector = ProfileDetector(repo_path=Path("/tmp"))
-        features = FeatureFlags(has_pii_data=True)
-        risk = detector._infer_risk_level(Domain.EKYC, features)
-
-        assert risk == RiskLevel.HIGH
-
-    def test_infer_medium_risk_for_ekyc_without_features(self) -> None:
-        """EKYC domain without features should infer MEDIUM risk."""
-        from vds_audit_orchestrator.profiles.models import FeatureFlags
-
-        detector = ProfileDetector(repo_path=Path("/tmp"))
-        features = FeatureFlags()
-        risk = detector._infer_risk_level(Domain.EKYC, features)
-
-        assert risk == RiskLevel.MEDIUM
-
-    def test_infer_pii_sensitivity_for_ekyc_with_pii_data(self) -> None:
-        """EKYC domain with PII data should have PII sensitivity."""
-        from vds_audit_orchestrator.profiles.models import FeatureFlags
-
-        detector = ProfileDetector(repo_path=Path("/tmp"))
-        sensitivity = detector._infer_data_sensitivity(Domain.EKYC, FeatureFlags(has_pii_data=True))
-
-        assert sensitivity == DataSensitivity.PII
-
-    def test_infer_internal_sensitivity_for_ekyc_without_features(self) -> None:
-        """EKYC domain without PII data should have INTERNAL sensitivity."""
-        from vds_audit_orchestrator.profiles.models import FeatureFlags
-
-        detector = ProfileDetector(repo_path=Path("/tmp"))
-        sensitivity = detector._infer_data_sensitivity(Domain.EKYC, FeatureFlags())
-
-        assert sensitivity == DataSensitivity.INTERNAL
-
-    def test_infer_financial_sensitivity_for_lending(self) -> None:
-        """LENDING domain should have FINANCIAL sensitivity."""
-        from vds_audit_orchestrator.profiles.models import FeatureFlags
-
-        detector = ProfileDetector(repo_path=Path("/tmp"))
-        sensitivity = detector._infer_data_sensitivity(Domain.LENDING, FeatureFlags())
-
-        assert sensitivity == DataSensitivity.FINANCIAL
-
-    def test_infer_internal_sensitivity_for_unknown(self) -> None:
-        """UNKNOWN domain should have INTERNAL sensitivity."""
-        from vds_audit_orchestrator.profiles.models import FeatureFlags
-
-        detector = ProfileDetector(repo_path=Path("/tmp"))
-        sensitivity = detector._infer_data_sensitivity(Domain.UNKNOWN, FeatureFlags())
-
-        assert sensitivity == DataSensitivity.INTERNAL
-
-
-class TestProfileDetectorIntegration:
-    """Integration tests for full profile detection."""
-
-    @pytest.mark.asyncio
-    async def test_detect_profile_java_microservice(self, tmp_path: Path) -> None:
-        """Full detection for Java Spring Boot microservice."""
-        # Setup Java Spring Boot project structure
-        java_src = tmp_path / "src" / "main" / "java" / "com" / "vds" / "insurance"
-        java_src.mkdir(parents=True)
-
-        (tmp_path / "pom.xml").write_text(
-            """
-            <project>
-                <dependencies>
-                    <dependency>
-                        <groupId>org.springframework.boot</groupId>
-                        <artifactId>spring-boot-starter-web</artifactId>
-                    </dependency>
-                </dependencies>
-            </project>
-            """
-        )
-
-        (java_src / "Application.java").write_text(
-            """
-            @SpringBootApplication
-            public class Application {
-                public static void main(String[] args) {}
-            }
-            """
-        )
-
-        (java_src / "controller").mkdir()
-        (java_src / "controller" / "ClaimController.java").touch()
-
-        resources = tmp_path / "src" / "main" / "resources"
-        resources.mkdir(parents=True)
-        (resources / "application.yml").write_text(
-            """
-            spring:
-              datasource:
-                url: jdbc:postgresql://localhost/db
-            """
-        )
-
-        detector = ProfileDetector(repo_path=tmp_path)
-        profile = await detector.detect(project_id="INS-CLAIM")
-
-        # Domain detection uses path-based pattern matching
-        # tmp_path doesn't have "INSURANCE" in path, so it will be UNKNOWN
-        assert profile.project_type == ProjectType.MICROSERVICE
-        assert profile.domain == Domain.UNKNOWN
-        assert profile.risk_level == RiskLevel.MEDIUM
-        assert profile.data_sensitivity == DataSensitivity.INTERNAL
-
-    @pytest.mark.asyncio
-    async def test_detect_profile_uses_repo_local_profile(self, tmp_path: Path) -> None:
-        """Profile detection should use audit_profile.yaml when available."""
-        profile_data = {
-            "project_id": "TEST-001",
-            "name": "Test Service",
-            "domain": "lending",
-            "project_type": "bff",
-            "risk_level": "medium",
-            "data_sensitivity": "financial",
-        }
-
-        (tmp_path / "audit_profile.yaml").write_text(yaml.dump(profile_data))
-        (tmp_path / "pom.xml").touch()
-
-        detector = ProfileDetector(repo_path=tmp_path)
-        profile = await detector.detect(project_id="TEST-001")
-
-        # Should use profile file values
-        assert profile.name == "Test Service"
-        assert profile.domain == Domain.LENDING
-        assert profile.project_type == ProjectType.BFF
-
-
-class TestDefaultProfile:
-    """Tests for default_profile function."""
-
-    def test_default_profile_returns_expected_defaults(self) -> None:
-        """default_profile should return profile with expected defaults."""
-        profile = default_profile(project_id="TEST-001", name="Test Project")
-
-        assert profile.project_id == "TEST-001"
-        assert profile.name == "Test Project"
-        assert profile.repository == "Test Project"
-        assert profile.domain == Domain.UNKNOWN
-        assert profile.project_type == ProjectType.MICROSERVICE
-        assert profile.tech_stack == TechStack.UNKNOWN
-        assert profile.risk_level == RiskLevel.MEDIUM
-        assert profile.business_criticality == BusinessCriticality.MEDIUM
-        assert profile.data_sensitivity == DataSensitivity.INTERNAL
-        assert profile.exposure == Exposure.PRIVATE
-        assert profile.service_type == ServiceType.CORE
-        assert profile.change_velocity == ChangeVelocity.MEDIUM
-
-    def test_default_profile_uses_project_id_as_name_when_empty(self) -> None:
-        """default_profile should use project_id as name when name is empty."""
-        profile = default_profile(project_id="TEST-001")
-
-        assert profile.name == "TEST-001"
-        assert profile.repository == "TEST-001"