@ngocsangairvds/vsaf 3.2.14 → 3.2.16

package/tools/vds-scripts/audit_orchestrator/tests/unit/engine/test_requirement_classification_nlp.py

@@ -1,670 +0,0 @@
-"""Tests for Phase 114 Package B: NLP Enrichment Layer (FR-114.4, FR-114.5, FR-114.6, FR-114.7).
-
-Test coverage:
-- Vietnamese cross-language signal enrichment (FR-114.7, TSK-114.7)
-- Exemplar-based classification algorithm (FR-114.4, FR-114.5, TSK-114.4, TSK-114.5)
-- Heuristic-NLP arbitration logic (FR-114.6, TSK-114.6)
-- Integration with existing requirement analysis
-
-Feature flags required:
-- VDS_AUDIT_REQUIREMENT_NLP_ENABLED=true for NLP classification tests
-- VDS_AUDIT_REQUIREMENT_VN_ENRICHMENT_ENABLED=true for Vietnamese enrichment tests
-"""
-
-from __future__ import annotations
-
-from pathlib import Path
-from unittest.mock import Mock, patch
-
-from vds_audit_orchestrator.engine.requirement_analysis import RequirementAnalysisResult
-from vds_audit_orchestrator.engine.requirement_classification import (
-    # Arbitration (FR-114.6)
-    ArbitrationResult,
-    ClassificationSource,
-    # Exemplar classification (FR-114.4, FR-114.5)
-    ExemplarClassificationResult,
-    ExemplarEmbeddingCache,
-    arbitrate_heuristic_nlp,
-    # Integration
-    classify_requirement_with_nlp_enrichment,
-    enrich_requirement_with_vietnamese_signals,
-    extract_cross_language_signals,
-    is_vietnamese_text,
-    # Vietnamese enrichment (FR-114.7)
-    normalize_vietnamese_for_matching,
-    strip_vietnamese_diacritics,
-)
-
-# ============================================================================
-# Vietnamese Cross-Language Signal Enrichment Tests (FR-114.7, TSK-114.7)
-# ============================================================================
-
-
-class TestVietnameseNormalization:
-    """Tests for Vietnamese text normalization (DD-114.11)."""
-
-    def test_normalize_vietnamese_nfc_converts_diacritics(self) -> None:
-        """NFC normalization should convert decomposed Vietnamese to composed form."""
-        # Pre-composed è should stay as single codepoint
-        text = "tài liệu"
-        normalized = normalize_vietnamese_for_matching(text)
-        assert normalized == text
-
-    def test_normalize_vietnamese_handles_empty_string(self) -> None:
-        """Should handle empty string gracefully."""
-        assert normalize_vietnamese_for_matching("") == ""
-
-    def test_normalize_vietnamese_handles_mixed_encoding(self) -> None:
-        """Should normalize mixed encoding Vietnamese text."""
-        mixed = "Kiểm tra tài liệu API"
-        normalized = normalize_vietnamese_for_matching(mixed)
-        # NFC normalization should preserve diacritics
-        assert len(normalized) > 0
-        assert normalized == mixed  # NFC doesn't change already-composed text
-
-    def test_strip_vietnamese_diacritics_removes_acute(self) -> None:
-        """Should remove acute accent marks."""
-        assert strip_vietnamese_diacritics("tài") == "tai"
-        assert strip_vietnamese_diacritics("kiểm") == "kiem"
-
-    def test_strip_vietnamese_diacritics_removes_grave(self) -> None:
-        """Should remove grave accent marks."""
-        assert strip_vietnamese_diacritics("tại") == "tai"
-
-    def test_strip_vietnamese_diacritics_removes_circumflex(self) -> None:
-        """Should remove circumflex marks."""
-        assert strip_vietnamese_diacritics("kiến") == "kien"
-
-    def test_strip_vietnamese_diacritics_preserves_non_vietnamese(self) -> None:
-        """Should preserve ASCII and non-Vietnamese text."""
-        assert strip_vietnamese_diacritics("API documentation") == "API documentation"
-        assert strip_vietnamese_diacritics("123 test") == "123 test"
-
-
-class TestCrossLanguageSignalExtraction:
-    """Tests for Vietnamese-to-English concept mapping (FR-114.7, DD-114.6)."""
-
-    def test_extract_database_signals(self) -> None:
-        """Should extract database concepts from Vietnamese text."""
-        text = "Kiểm tra kết nối cơ sở dữ liệu"
-        signals = extract_cross_language_signals(text)
-        assert "database" in signals
-        assert "data store" in signals
-
-    def test_extract_authentication_signals(self) -> None:
-        """Should extract authentication concepts from Vietnamese text."""
-        text = "Xác thực người dùng"
-        signals = extract_cross_language_signals(text)
-        assert "authentication" in signals or "auth" in signals
-
-    def test_extract_authorization_signals(self) -> None:
-        """Should extract authorization concepts from Vietnamese text."""
-        text = "Phân quyền truy cập"
-        signals = extract_cross_language_signals(text)
-        assert "authorization" in signals
-        assert "access control" in signals
-
-    def test_extract_architecture_signals(self) -> None:
-        """Should extract architecture concepts from Vietnamese text."""
-        text = "Kiến trúc hexagonal"
-        signals = extract_cross_language_signals(text)
-        assert "architecture" in signals or "design" in signals
-
-    def test_extract_deployment_signals(self) -> None:
-        """Should extract deployment concepts from Vietnamese text."""
-        text = "Triển khai Docker và Kubernetes"
-        signals = extract_cross_language_signals(text)
-        assert "deployment" in signals or "deploy" in signals
-
-    def test_extract_documentation_signals(self) -> None:
-        """Should extract documentation concepts from Vietnamese text."""
-        text = "Cần có tài liệu hướng dẫn"
-        signals = extract_cross_language_signals(text)
-        assert "documentation" in signals or "docs" in signals
-
-    def test_extract_signals_handles_diacritic_variants(self) -> None:
-        """Should extract signals from text with different diacritic forms."""
-        # With diacritics
-        signals1 = extract_cross_language_signals("xác thực")
-        # Without diacritics
-        signals2 = extract_cross_language_signals("xac thuc")
-        # Should find same signals
-        assert set(signals1) == set(signals2)
-
-    def test_extract_signals_deduplicates(self) -> None:
-        """Should deduplicate signals while preserving order."""
-        text = "cơ sở dữ liệu database"
-        signals = extract_cross_language_signals(text)
-        # Check "database" appears only once
-        db_count = sum(1 for s in signals if "database" in s.lower())
-        assert db_count == 1
-
-    def test_extract_signals_returns_empty_for_no_match(self) -> None:
-        """Should return empty list when no Vietnamese concepts found."""
-        text = "Random English text with no Vietnamese"
-        signals = extract_cross_language_signals(text)
-        assert signals == []
-
-    def test_extract_signals_case_insensitive(self) -> None:
-        """Should be case-insensitive for matching."""
-        signals1 = extract_cross_language_signals("CƠ SỞ DỮ LIỆU")
-        signals2 = extract_cross_language_signals("cơ sở dữ liệu")
-        signals3 = extract_cross_language_signals("Co So Du Lieu")
-        # All should find database signals
-        for signals in (signals1, signals2, signals3):
-            assert "database" in signals
-
-
-class TestVietnameseDetection:
-    """Tests for Vietnamese text detection."""
-
-    def test_is_vietnamese_detects_diacritics(self) -> None:
-        """Should detect Vietnamese via diacritic ranges."""
-        assert is_vietnamese_text("tài liệu")
-        assert is_vietnamese_text("Kiểm tra")
-
-    def test_is_vietnamese_detects_common_words(self) -> None:
-        """Should detect Vietnamese via common words."""
-        assert is_vietnamese_text("kiểm tra")
-        assert is_vietnamese_text("tai lieu")
-
-    def test_is_vietnamese_false_for_english(self) -> None:
-        """Should return False for pure English text."""
-        assert not is_vietnamese_text("Check API documentation")
-
-    def test_is_vietnamese_true_for_mixed(self) -> None:
-        """Should detect mixed Vietnamese/English text."""
-        assert is_vietnamese_text("API documentation tài liệu")
-
-
-class TestVietnameseEnrichmentIntegration:
-    """Integration tests for Vietnamese enrichment (FR-114.7)."""
-
-    def test_enrich_requirement_returns_normalized_text(self) -> None:
-        """Should return NFC-normalized text."""
-        text, signals = enrich_requirement_with_vietnamese_signals(
-            "Kiểm tra tài liệu API",
-            "Documentation",
-        )
-        assert isinstance(text, str)
-        assert isinstance(signals, list)
-
-    def test_enrich_requirement_extracts_signals(self) -> None:
-        """Should extract English signals from Vietnamese text."""
-        _text, signals = enrich_requirement_with_vietnamese_signals(
-            "Xác thực người dùng",
-            "Security",
-        )
-        assert len(signals) > 0
-        assert any("auth" in s.lower() for s in signals)
-
-
-# ============================================================================
-# Exemplar-Based Classification Tests (FR-114.4, FR-114.5, TSK-114.4, TSK-114.5)
-# ============================================================================
-
-
-class TestExemplarEmbeddingCache:
-    """Tests for exemplar embedding cache (FR-114.4)."""
-
-    def test_cache_initializes_empty(self) -> None:
-        """New cache should have zero exemplars."""
-        cache = ExemplarEmbeddingCache()
-        assert cache.size == 0
-        assert not cache.is_loaded
-
-    def test_cache_loads_exemplars_from_json(self) -> None:
-        """Should load exemplars from JSON file."""
-        cache = ExemplarEmbeddingCache()
-        cache.load_exemplars()  # Uses default path
-        assert cache.is_loaded
-        assert cache.size > 0
-
-    def test_cache_default_exemplar_path_exists(self) -> None:
-        """Default exemplar path should resolve to the shipped corpus."""
-        package_root = Path(__file__).resolve().parents[3]
-        exemplar_path = package_root / "data" / "requirement_exemplars.json"
-        assert exemplar_path.exists(), exemplar_path
-
-    def test_cache_load_returns_same_on_second_call(self) -> None:
-        """Second load should be no-op."""
-        cache = ExemplarEmbeddingCache()
-        cache.load_exemplars()
-        first_size = cache.size
-        cache.load_exemplars()
-        assert cache.size == first_size
-
-    def test_get_embedding_client_returns_none_when_disabled(self) -> None:
-        """Should return None when NLP is disabled."""
-        cache = ExemplarEmbeddingCache()
-        with patch.dict("os.environ", {"VDS_AUDIT_REQUIREMENT_NLP_ENABLED": "false"}):
-            client = cache.get_embedding_client()
-            assert client is None
-
-    def test_ensure_embeddings_skips_when_client_unavailable(self) -> None:
-        """Should not fail when embedding client unavailable."""
-        cache = ExemplarEmbeddingCache()
-        # Mock unavailable client
-        cache._embedding_client = None
-        cache.ensure_embeddings()
-        # Should not raise
-
-    def test_get_exemplar_embedding_returns_none_for_unknown(self) -> None:
-        """Should return None for unknown exemplar ID."""
-        cache = ExemplarEmbeddingCache()
-        embedding = cache.get_exemplar_embedding("unknown_id")
-        assert embedding is None
-
-
-class TestExemplarClassificationResult:
-    """Tests for exemplar classification result (FR-114.5)."""
-
-    def test_result_default_values(self) -> None:
-        """Should have sensible default values."""
-        result = ExemplarClassificationResult()
-        assert result.analysis_mode is None
-        assert result.project_scope_required is None
-        assert result.confidence == 0.0
-        assert result.top_similarity == 0.0
-        assert result.vote_share == 0.0
-        assert result.top_matches == []
-        assert not result.has_confident_match
-
-    def test_result_with_confident_match(self) -> None:
-        """Should set has_confident_match when confidence >= threshold."""
-        result = ExemplarClassificationResult(
-            analysis_mode="code_first",
-            confidence=0.8,
-            has_confident_match=True,
-        )
-        assert result.has_confident_match
-
-
-class TestExemplarVoting:
-    """Regression tests for weighted exemplar voting."""
-
-    def test_classification_uses_vote_weight_not_lexicographic_key(self) -> None:
-        cache = ExemplarEmbeddingCache()
-        cache._loaded = True
-        cache._exemplars = [
-            {
-                "id": "ex-code",
-                "requirement_text": "code",
-                "ground_truth": {
-                    "analysis_mode": "code_first",
-                    "project_scope_required": False,
-                    "risk_focus": "quality",
-                },
-            },
-            {
-                "id": "ex-hybrid",
-                "requirement_text": "hybrid",
-                "ground_truth": {
-                    "analysis_mode": "hybrid_balanced",
-                    "project_scope_required": False,
-                    "risk_focus": "quality",
-                },
-            },
-        ]
-        cache._embeddings = {
-            "ex-code": [1.0, 0.0],
-            "ex-hybrid": [0.6, 0.8],
-        }
-
-        class _Client:
-            def embed_texts(self, texts: list[str]):
-                return type("Result", (), {"vectors": [[1.0, 0.0] for _ in texts]})()
-
-        cache._embedding_client = _Client()
-
-        result = cache.classify_by_exemplar_similarity("code query", top_k=2, min_confidence=0.0)
-
-        assert result.analysis_mode == "code_first"
-        assert result.vote_share > 0.5
-
-
-# ============================================================================
-# Heuristic-NLP Arbitration Tests (FR-114.6, TSK-114.6)
-# ============================================================================
-
-
-class TestArbitrationLogic:
-    """Tests for heuristic-NLP arbitration (FR-114.6, DD-114.1)."""
-
-    @patch.dict("os.environ", {"VDS_AUDIT_REQUIREMENT_NLP_ENABLED": "true"})
-    def test_arbitration_keeps_heuristic_when_nlp_unavailable(self) -> None:
-        """Should use heuristic when NLP unavailable."""
-        heuristic = RequirementAnalysisResult(
-            analysis_mode="code_first",
-            project_scope_required=False,
-        )
-        result = arbitrate_heuristic_nlp(
-            heuristic_result=heuristic,
-            heuristic_confidence=0.5,
-            nlp_result=None,
-            analysis_mode="code_first",
-            project_scope_required=False,
-            finalization_policy="code_substantive_required",
-        )
-        assert result.analysis_mode == "code_first"
-        assert result.final_confidence == 0.5
-        assert result.arbitration_outcome == "nlp_unavailable"
-        assert result.classification_source == ClassificationSource.HEURISTIC
-
-    @patch.dict("os.environ", {"VDS_AUDIT_REQUIREMENT_NLP_ENABLED": "true"})
-    def test_arbitration_keeps_high_confidence_heuristic(self) -> None:
-        """Should keep heuristic when confidence >= 0.8 (DD-114.1)."""
-        heuristic = RequirementAnalysisResult(
-            analysis_mode="code_first",
-            project_scope_required=False,
-        )
-        nlp = ExemplarClassificationResult(
-            analysis_mode="docs_first",  # Disagrees
-            confidence=0.9,
-        )
-        result = arbitrate_heuristic_nlp(
-            heuristic_result=heuristic,
-            heuristic_confidence=0.85,  # High heuristic confidence
-            nlp_result=nlp,
-            analysis_mode="code_first",
-            project_scope_required=False,
-            finalization_policy="code_substantive_required",
-        )
-        assert result.analysis_mode == "code_first"  # Kept heuristic
-        assert result.final_confidence == 0.85
-        assert result.arbitration_outcome == "heuristic_kept"
-
-    @patch.dict("os.environ", {"VDS_AUDIT_REQUIREMENT_NLP_ENABLED": "true"})
-    def test_arbitration_boosts_when_nlp_agrees(self) -> None:
-        """Should boost confidence to 0.85 when NLP agrees (FR-114.6)."""
-        heuristic = RequirementAnalysisResult(
-            analysis_mode="code_first",
-            project_scope_required=False,
-        )
-        nlp = ExemplarClassificationResult(
-            analysis_mode="code_first",  # Agrees
-            project_scope_required=False,  # Agrees
-            confidence=0.7,
-        )
-        result = arbitrate_heuristic_nlp(
-            heuristic_result=heuristic,
-            heuristic_confidence=0.6,
-            nlp_result=nlp,
-            analysis_mode="code_first",
-            project_scope_required=False,
-            finalization_policy="code_substantive_required",
-        )
-        assert result.analysis_mode == "code_first"
-        assert result.final_confidence >= 0.85  # Boosted
-        assert result.arbitration_outcome == "nlp_agreement_boost"
-        assert result.classification_source == ClassificationSource.NLP_ENRICHMENT
-        assert result.nlp_agreed is True
-
-    @patch.dict("os.environ", {"VDS_AUDIT_REQUIREMENT_NLP_ENABLED": "true"})
-    def test_arbitration_adopts_nlp_on_high_similarity_disagreement(self) -> None:
-        """Should adopt NLP when similarity > 0.85 (FR-114.6)."""
-        heuristic = RequirementAnalysisResult(
-            analysis_mode="code_first",
-            project_scope_required=False,
-        )
-        nlp = ExemplarClassificationResult(
-            analysis_mode="docs_first",  # Disagrees
-            project_scope_required=True,
-            confidence=0.75,
-            top_similarity=0.90,  # High similarity
-        )
-        result = arbitrate_heuristic_nlp(
-            heuristic_result=heuristic,
-            heuristic_confidence=0.5,
-            nlp_result=nlp,
-            analysis_mode="code_first",
-            project_scope_required=False,
-            finalization_policy="code_substantive_required",
-        )
-        assert result.analysis_mode == "docs_first"  # Adopted NLP
-        assert result.project_scope_required is True
-        assert result.arbitration_outcome == "nlp_high_similarity_adopted"
-        assert result.classification_source == ClassificationSource.NLP_ENRICHMENT
-
-    @patch.dict("os.environ", {"VDS_AUDIT_REQUIREMENT_NLP_ENABLED": "true"})
-    def test_arbitration_escalates_on_low_similarity_disagreement(self) -> None:
-        """Should escalate to Layer 3 when similarity < 0.85 (FR-114.6)."""
-        heuristic = RequirementAnalysisResult(
-            analysis_mode="code_first",
-            project_scope_required=False,
-        )
-        nlp = ExemplarClassificationResult(
-            analysis_mode="docs_first",  # Disagrees
-            confidence=0.5,
-            top_similarity=0.70,  # Low similarity
-        )
-        result = arbitrate_heuristic_nlp(
-            heuristic_result=heuristic,
-            heuristic_confidence=0.5,
-            nlp_result=nlp,
-            analysis_mode="code_first",
-            project_scope_required=False,
-            finalization_policy="code_substantive_required",
-        )
-        assert result.analysis_mode == "code_first"  # Tentative
-        assert result.arbitration_outcome == "escalated_to_layer3"
-        assert result.final_confidence < 0.8  # Low confidence signals need for Layer 3
-
-    @patch.dict("os.environ", {"VDS_AUDIT_REQUIREMENT_NLP_ENABLED": "true"})
-    def test_arbitration_handles_none_nlp_mode(self) -> None:
-        """Should handle None NLP mode gracefully."""
-        heuristic = RequirementAnalysisResult(
-            analysis_mode="code_first",
-            project_scope_required=False,
-        )
-        nlp = ExemplarClassificationResult(
-            analysis_mode=None,  # No mode from NLP
-            project_scope_required=False,
-            confidence=0.5,
-        )
-        result = arbitrate_heuristic_nlp(
-            heuristic_result=heuristic,
-            heuristic_confidence=0.5,
-            nlp_result=nlp,
-            analysis_mode="code_first",
-            project_scope_required=False,
-            finalization_policy="code_substantive_required",
-        )
-        # Should treat None as agreement
-        assert result.analysis_mode == "code_first"
-
-
-# ============================================================================
-# Integration Tests
-# ============================================================================
-
-
-class TestNLPEnrichmentIntegration:
-    """Integration tests for full NLP enrichment pipeline."""
-
-    @patch.dict("os.environ", {"VDS_AUDIT_REQUIREMENT_NLP_ENABLED": "true"})
-    def test_classify_with_nlp_returns_result_tuple(self) -> None:
-        """Should return (analysis_result, arbitration_result) tuple."""
-        result, arbitration = classify_requirement_with_nlp_enrichment(
-            requirement_text="Validate API documentation exists",
-            requirement_category="Documentation",
-            heuristic_confidence=0.5,
-        )
-        assert isinstance(result, RequirementAnalysisResult)
-        assert isinstance(arbitration, ArbitrationResult)
-
-    @patch.dict("os.environ", {"VDS_AUDIT_REQUIREMENT_NLP_ENABLED": "false"})
-    def test_classify_creates_default_heuristic_when_missing(self) -> None:
-        """Should create default heuristic when not provided."""
-        result, _arbitration = classify_requirement_with_nlp_enrichment(
-            requirement_text="Check API docs",
-            requirement_category="Documentation",
-            heuristic_result=None,
-            heuristic_confidence=0.0,
-        )
-        assert result.analysis_mode in {
-            "code_first",
-            "docs_first",
-            "hybrid_balanced",
-            "infra_negative",
-        }
-
-    @patch.dict("os.environ", {"VDS_AUDIT_REQUIREMENT_NLP_ENABLED": "false"})
-    def test_classify_adds_vn_enrichment_reason_code(self) -> None:
-        """Should add Vietnamese enrichment reason code when signals found."""
-        _result, _ = classify_requirement_with_nlp_enrichment(
-            requirement_text="Kiểm tra tài liệu API",
-            requirement_category="Documentation",
-            heuristic_confidence=0.5,
-        )
-        # Should have vn enrichment reason code if signals found
-        # (may not find signals if VN enrichment disabled)
-
-    @patch.dict("os.environ", {"VDS_AUDIT_REQUIREMENT_NLP_ENABLED": "false"})
-    def test_classify_preserves_heuristic_modalities(self) -> None:
-        """Should preserve required anchor modalities from heuristic."""
-        heuristic = RequirementAnalysisResult(
-            analysis_mode="hybrid_balanced",
-            required_anchor_modalities=["code", "docs"],
-        )
-        result, _ = classify_requirement_with_nlp_enrichment(
-            requirement_text="Validate code and docs",
-            requirement_category="Architecture",
-            heuristic_result=heuristic,
-            heuristic_confidence=0.5,
-        )
-        assert set(result.required_anchor_modalities) == {"code", "docs"}
-
-    @patch.dict("os.environ", {"VDS_AUDIT_REQUIREMENT_NLP_ENABLED": "true"})
-    def test_classify_with_nlp_enrichment_preserves_phase114_fields(self) -> None:
-        """NLP enrichment should return a canonical analysis object with P114 fields populated."""
-        heuristic = RequirementAnalysisResult(
-            analysis_mode="code_first",
-            required_anchor_modalities=["code"],
-            project_scope_required=False,
-            execution_scope_class="repo_local",
-            finalization_policy="code_substantive_required",
-            heuristic_confidence=0.6,
-            classification_source="heuristic",
-            content_fingerprint="content-fp",
-            classification_fingerprint="class-fp",
-        )
-
-        fake_nlp = ExemplarClassificationResult(
-            analysis_mode="code_first",
-            project_scope_required=False,
-            confidence=0.82,
-            top_similarity=0.91,
-            vote_share=0.9,
-        )
-
-        with patch(
-            "vds_audit_orchestrator.engine.requirement_classification.get_global_exemplar_cache"
-        ) as mock_cache_factory:
-            mock_cache = Mock()
-            mock_cache.classify_by_exemplar_similarity.return_value = fake_nlp
-            mock_cache_factory.return_value = mock_cache
-
-            result, arbitration = classify_requirement_with_nlp_enrichment(
-                requirement_text="Source code must follow Clean Architecture principles",
-                requirement_category="Architecture",
-                heuristic_result=heuristic,
-                heuristic_confidence=heuristic.heuristic_confidence,
-            )
-
-        assert result.classification_source == "nlp_enrichment"
-        assert result.heuristic_confidence >= 0.85
-        assert result.content_fingerprint == "content-fp"
-        assert result.classification_fingerprint
-        assert result.nlp_exemplar_similarity == 0.91
-        assert result.execution_scope_class == "repo_local"
-        assert arbitration.classification_source == ClassificationSource.NLP_ENRICHMENT
-
-
-# ============================================================================
-# Feature Flag Tests
-# ============================================================================
-
-
-class TestFeatureFlags:
-    """Tests for feature flag behavior (NFR-114.4)."""
-
-    def test_nlp_disabled_skips_classification(self) -> None:
-        """When VDS_AUDIT_REQUIREMENT_NLP_ENABLED=false, NLP should be skipped."""
-        with patch.dict("os.environ", {"VDS_AUDIT_REQUIREMENT_NLP_ENABLED": "false"}):
-            # Reset global cache to pick up new env
-            cache = ExemplarEmbeddingCache()
-            client = cache.get_embedding_client()
-            assert client is None
-
-    def test_nlp_enabled_creates_client(self) -> None:
-        """When VDS_AUDIT_REQUIREMENT_NLP_ENABLED=true, client should be created."""
-        with patch.dict("os.environ", {"VDS_AUDIT_REQUIREMENT_NLP_ENABLED": "true"}):
-            cache = ExemplarEmbeddingCache()
-            # Note: may still be None if OllamaEmbeddingClient is not importable
-            cache._loaded = True  # Skip loading
-            cache.get_embedding_client()
-            # Client creation depends on import success
-
-    def test_vn_enrichment_flag_controls_signal_extraction(self) -> None:
-        """VDS_AUDIT_REQUIREMENT_VN_ENRICHMENT_ENABLED controls enrichment."""
-        # Signal extraction itself is not gated - it's the arbitration that uses it
-        text = "Kiểm tra xác thực người dùng"
-        signals = extract_cross_language_signals(text)
-        # Signals should always be extracted (function is deterministic)
-        # The flag controls whether NLP layer is invoked
-        assert isinstance(signals, list)
-
-
-# ============================================================================
-# Edge Case Tests
-# ============================================================================
-
-
-class TestEdgeCases:
-    """Tests for edge cases and error handling."""
-
-    @patch.dict("os.environ", {"VDS_AUDIT_REQUIREMENT_NLP_ENABLED": "false"})
-    def test_empty_requirement_text(self) -> None:
-        """Should handle empty requirement text gracefully."""
-        result, _arbitration = classify_requirement_with_nlp_enrichment(
-            requirement_text="",
-            requirement_category="",
-            heuristic_confidence=0.5,
-        )
-        assert isinstance(result, RequirementAnalysisResult)
-
-    @patch.dict("os.environ", {"VDS_AUDIT_REQUIREMENT_NLP_ENABLED": "false"})
-    def test_very_long_requirement_text(self) -> None:
-        """Should handle very long requirement text."""
-        long_text = "Validate " + "implementation" * 100
-        result, _arbitration = classify_requirement_with_nlp_enrichment(
-            requirement_text=long_text,
-            requirement_category="Code",
-            heuristic_confidence=0.5,
-        )
-        assert isinstance(result, RequirementAnalysisResult)
-
-    @patch.dict("os.environ", {"VDS_AUDIT_REQUIREMENT_NLP_ENABLED": "false"})
-    def test_special_characters_in_text(self) -> None:
-        """Should handle special characters."""
-        text = "Kiểm tra: <API>, [JSON], {config}? 100%"
-        normalized, signals = enrich_requirement_with_vietnamese_signals(text, "Test")
-        assert isinstance(normalized, str)
-        assert isinstance(signals, list)
-
-    @patch.dict("os.environ", {"VDS_AUDIT_REQUIREMENT_NLP_ENABLED": "false"})
-    def test_unicode_edge_cases(self) -> None:
-        """Should handle various Unicode edge cases."""
-        # Zero-width joiner, other special Unicode
-        text = "Kiểm tra\u200b testing"
-        normalized = normalize_vietnamese_for_matching(text)
-        assert isinstance(normalized, str)
-
-    @patch.dict("os.environ", {"VDS_AUDIT_REQUIREMENT_NLP_ENABLED": "false"})
-    def test_mixed_vietnamese_english_code_terms(self) -> None:
-        """Should handle mixed VN text with English code terms."""
-        text = "Kiểm tra Dockerfile và docker-compose.yml configuration"
-        signals = extract_cross_language_signals(text)
-        # Should find deployment/docker signals
-        assert isinstance(signals, list)