@ngocsangairvds/vsaf 3.2.14 → 3.2.16

package/tools/vds-scripts/hexagonal_orchestrator/tests/test_integration.py

@@ -1,1524 +0,0 @@
-#!/usr/bin/env python3
-"""
-Comprehensive integration tests for hexagonal compliance skill (TSK-404).
-
-Tests the full pipeline on fixture repositories:
-- python-compliant fixtures (should have 0 critical violations)
-- python-noncompliant fixtures (should detect critical violations)
-- python-mixed fixtures (should detect some violations)
-
-Also tests:
-- Analyzer routing (PythonAstAnalyzer vs FallbackAnalyzer)
-- Layer classification
-- Violation detection
-- Report generation (JSON and Markdown)
-- Configuration loading and layer overrides
-"""
-
-import json
-import tempfile
-import unittest
-from pathlib import Path
-
-import pytest
-
-from vds_hexagonal_orchestrator.analyzers.fallback import FallbackAnalyzer
-from vds_hexagonal_orchestrator.analyzers.python import PythonAstAnalyzer
-from vds_hexagonal_orchestrator.classifier import LayerClassifier
-from vds_hexagonal_orchestrator.config import DEFAULT_CONFIG, ConfigManager
-from vds_hexagonal_orchestrator.models import (
-    ComplianceReport,
-    LayerAssignment,
-    RepositoryProfile,
-    Violation,
-)
-
-
-class FixtureBuilder:
-    """Builder for creating test fixture repositories."""
-
-    @staticmethod
-    def create_python_compliant_repo(base_path: Path) -> Path:
-        """
-        Create a compliant Python repository with proper hexagonal structure.
-
-        Structure:
-        - domain/ - Pure domain entities with no framework dependencies
-        - application/ - Use cases with only domain dependencies
-        - adapters/driving/ - Controllers using application ports
-        - adapters/driven/ - Repositories implementing ports
-        """
-        repo_path = base_path / "python-compliant"
-        repo_path.mkdir(parents=True, exist_ok=True)
-
-        # Domain layer - pure business logic
-        domain_dir = repo_path / "domain"
-        domain_dir.mkdir(parents=True, exist_ok=True)
-
-        (domain_dir / "__init__.py").write_text("")
-        (domain_dir / "entity.py").write_text('''
-"""Pure domain entity with no framework dependencies."""
-
-class User:
-    """User domain entity."""
-
-    def __init__(self, user_id: str, name: str, email: str):
-        self.user_id = user_id
-        self.name = name
-        self.email = email
-
-    def change_email(self, new_email: str) -> None:
-        """Change user email with domain validation."""
-        if "@" not in new_email:
-            raise ValueError("Invalid email format")
-        self.email = new_email
-
-
-class Order:
-    """Order domain entity."""
-
-    def __init__(self, order_id: str, user_id: str):
-        self.order_id = order_id
-        self.user_id = user_id
-        self.items: list = []
-        self.status = "pending"
-
-    def add_item(self, product_id: str, quantity: int) -> None:
-        """Add item to order."""
-        if quantity <= 0:
-            raise ValueError("Quantity must be positive")
-        self.items.append({"product_id": product_id, "quantity": quantity})
-
-    def calculate_total(self) -> float:
-        """Calculate order total - pure domain logic."""
-        return sum(item.get("price", 0) * item.get("quantity", 0) for item in self.items)
-''')
-
-        (domain_dir / "value_object.py").write_text('''
-"""Pure domain value objects."""
-
-class Email:
-    """Email value object with validation."""
-
-    def __init__(self, value: str):
-        if "@" not in value:
-            raise ValueError("Invalid email format")
-        self._value = value
-
-    @property
-    def value(self) -> str:
-        return self._value
-
-    def __eq__(self, other) -> bool:
-        if isinstance(other, Email):
-            return self._value == other._value
-        return False
-
-
-class Money:
-    """Money value object."""
-
-    def __init__(self, amount: float, currency: str = "USD"):
-        if amount < 0:
-            raise ValueError("Amount cannot be negative")
-        self._amount = amount
-        self._currency = currency
-
-    @property
-    def amount(self) -> float:
-        return self._amount
-
-    @property
-    def currency(self) -> str:
-        return self._currency
-
-    def add(self, other: "Money") -> "Money":
-        """Add two money values."""
-        if self._currency != other._currency:
-            raise ValueError("Cannot add different currencies")
-        return Money(self._amount + other._amount, self._currency)
-''')
-
-        # Application layer - use cases
-        application_dir = repo_path / "application"
-        application_dir.mkdir(parents=True, exist_ok=True)
-
-        (application_dir / "__init__.py").write_text("")
-        (application_dir / "ports.py").write_text('''
-"""Application layer port interfaces."""
-
-from abc import ABC, abstractmethod
-from typing import Optional
-
-# These are interfaces defined in application layer
-# Domain entities are imported (allowed dependency direction)
-
-
-class UserRepository(ABC):
-    """Port for user repository."""
-
-    @abstractmethod
-    def find_by_id(self, user_id: str) -> Optional["User"]:
-        """Find user by ID."""
-        pass
-
-    @abstractmethod
-    def save(self, user: "User") -> None:
-        """Save user."""
-        pass
-
-
-class OrderRepository(ABC):
-    """Port for order repository."""
-
-    @abstractmethod
-    def find_by_id(self, order_id: str) -> Optional["Order"]:
-        """Find order by ID."""
-        pass
-
-    @abstractmethod
-    def save(self, order: "Order") -> None:
-        """Save order."""
-        pass
-
-
-class NotificationService(ABC):
-    """Port for notification service."""
-
-    @abstractmethod
-    def send_email(self, to: str, subject: str, body: str) -> None:
-        """Send email notification."""
-        pass
-''')
-
-        (application_dir / "use_cases.py").write_text('''
-"""Application layer use cases."""
-
-from typing import Optional
-
-# Import from domain layer (allowed)
-import sys
-sys.path.insert(0, "..")
-from domain.entity import User, Order
-from application.ports import UserRepository, OrderRepository, NotificationService
-
-
-class CreateUserUseCase:
-    """Use case for creating a new user."""
-
-    def __init__(self, user_repository: UserRepository, notification_service: NotificationService):
-        self._user_repository = user_repository
-        self._notification_service = notification_service
-
-    def execute(self, name: str, email: str) -> User:
-        """Execute the use case."""
-        user = User(user_id="generated-id", name=name, email=email)
-        self._user_repository.save(user)
-        self._notification_service.send_email(
-            to=email,
-            subject="Welcome",
-            body=f"Welcome {name}!"
-        )
-        return user
-
-
-class PlaceOrderUseCase:
-    """Use case for placing an order."""
-
-    def __init__(self, order_repository: OrderRepository, user_repository: UserRepository):
-        self._order_repository = order_repository
-        self._user_repository = user_repository
-
-    def execute(self, user_id: str, items: list) -> Optional[Order]:
-        """Execute the use case."""
-        user = self._user_repository.find_by_id(user_id)
-        if not user:
-            return None
-
-        order = Order(order_id="generated-order-id", user_id=user_id)
-        for item in items:
-            order.add_item(item["product_id"], item["quantity"])
-
-        self._order_repository.save(order)
-        return order
-''')
-
-        # Driving adapters (controllers, APIs)
-        adapters_driving_dir = repo_path / "adapters" / "driving"
-        adapters_driving_dir.mkdir(parents=True, exist_ok=True)
-
-        (adapters_driving_dir / "__init__.py").write_text("")
-        (adapters_driving_dir / "controller.py").write_text('''
-"""Driving adapter - REST controller."""
-
-# Import from application layer (allowed)
-import sys
-sys.path.insert(0, "../..")
-from application.use_cases import CreateUserUseCase, PlaceOrderUseCase
-
-
-class UserController:
-    """REST controller for user operations."""
-
-    def __init__(self, create_user_use_case: CreateUserUseCase):
-        self._create_user_use_case = create_user_use_case
-
-    def create_user(self, request: dict) -> dict:
-        """Handle POST /users request."""
-        user = self._create_user_use_case.execute(
-            name=request.get("name"),
-            email=request.get("email")
-        )
-        return {"user_id": user.user_id, "name": user.name, "email": user.email}
-
-
-class OrderController:
-    """REST controller for order operations."""
-
-    def __init__(self, place_order_use_case: PlaceOrderUseCase):
-        self._place_order_use_case = place_order_use_case
-
-    def place_order(self, request: dict) -> dict:
-        """Handle POST /orders request."""
-        order = self._place_order_use_case.execute(
-            user_id=request.get("user_id"),
-            items=request.get("items", [])
-        )
-        if order:
-            return {"order_id": order.order_id, "status": order.status}
-        return {"error": "User not found"}, 404
-''')
-
-        # Driven adapters (repositories, external services)
-        adapters_driven_dir = repo_path / "adapters" / "driven"
-        adapters_driven_dir.mkdir(parents=True, exist_ok=True)
-
-        (adapters_driven_dir / "__init__.py").write_text("")
-        (adapters_driven_dir / "user_repository_impl.py").write_text('''
-"""Driven adapter - User repository implementation."""
-
-from typing import Optional
-
-# Import from application layer (allowed - implementing port)
-import sys
-sys.path.insert(0, "../..")
-from domain.entity import User
-from application.ports import UserRepository
-
-
-class InMemoryUserRepository(UserRepository):
-    """In-memory implementation of UserRepository."""
-
-    def __init__(self):
-        self._users: dict = {}
-
-    def find_by_id(self, user_id: str) -> Optional[User]:
-        """Find user by ID."""
-        return self._users.get(user_id)
-
-    def save(self, user: User) -> None:
-        """Save user."""
-        self._users[user.user_id] = user
-
-
-class SqlUserRepository(UserRepository):
-    """SQL implementation of UserRepository - would use SQLAlchemy here."""
-
-    def __init__(self, connection_string: str):
-        self._connection_string = connection_string
-        # Note: SQLAlchemy would be imported and used here
-        # This is infrastructure code, so framework imports are OK
-
-    def find_by_id(self, user_id: str) -> Optional[User]:
-        """Find user by ID from database."""
-        # Implementation would use SQL queries
-        pass
-
-    def save(self, user: User) -> None:
-        """Save user to database."""
-        # Implementation would use SQL queries
-        pass
-''')
-
-        (adapters_driven_dir / "notification_service_impl.py").write_text('''
-"""Driven adapter - Notification service implementation."""
-
-# Import from application layer (allowed - implementing port)
-import sys
-sys.path.insert(0, "../..")
-from application.ports import NotificationService
-
-
-class EmailNotificationService(NotificationService):
-    """Email notification service implementation."""
-
-    def __init__(self, smtp_host: str, smtp_port: int):
-        self._smtp_host = smtp_host
-        self._smtp_port = smtp_port
-        # Note: smtplib would be imported and used here
-        # This is infrastructure code, so framework imports are OK
-
-    def send_email(self, to: str, subject: str, body: str) -> None:
-        """Send email via SMTP."""
-        # Implementation would use smtplib
-        print(f"Sending email to {to}: {subject}")
-''')
-
-        return repo_path
-
-    @staticmethod
-    def create_python_noncompliant_repo(base_path: Path) -> Path:
-        """
-        Create a non-compliant Python repository with violations.
-
-        Expected violations:
-        - Domain layer importing infrastructure (critical)
-        - Domain layer with framework annotations (critical/major)
-        - Application layer importing adapters (critical)
-        - Cross-layer dependency violations
-        """
-        repo_path = base_path / "python-noncompliant"
-        repo_path.mkdir(parents=True, exist_ok=True)
-
-        # Domain layer with violations
-        domain_dir = repo_path / "domain"
-        domain_dir.mkdir(parents=True, exist_ok=True)
-
-        (domain_dir / "__init__.py").write_text("")
-        (domain_dir / "entity.py").write_text('''
-"""Domain entity with VIOLATIONS - should trigger critical violations."""
-
-# CRITICAL: Domain importing from adapter layer
-from adapters.driven.user_repository_impl import InMemoryUserRepository
-
-# CRITICAL: Domain importing from infrastructure
-from infrastructure.database import get_connection
-
-# MAJOR: Domain using framework annotations
-from sqlalchemy import Column, String
-from pydantic import BaseModel
-
-
-class User:
-    """User entity with multiple violations."""
-
-    # MAJOR: Framework annotation in domain
-    __tablename__ = "users"
-    id = Column(String, primary_key=True)
-
-    def __init__(self, user_id: str, name: str, email: str):
-        self.user_id = user_id
-        self.name = name
-        self.email = email
-
-        # CRITICAL: Direct infrastructure access in domain
-        self._repo = InMemoryUserRepository()
-        self._db = get_connection()
-
-    def save(self) -> None:
-        """Save method in domain - violation of separation."""
-        self._repo.save(self)
-''')
-
-        (domain_dir / "order.py").write_text('''
-"""Order entity with violations."""
-
-# MAJOR: Framework imports in domain
-from sqlalchemy import Column, String, Integer, Float
-from sqlalchemy.orm import Mapped, mapped_column
-
-# MAJOR: Serialization framework in domain
-from pydantic import BaseModel, validator
-
-
-class Order(BaseModel):
-    """Order with Pydantic inheritance - major violation."""
-
-    order_id: str
-    user_id: str
-    total: float = 0.0
-
-    # MAJOR: Pydantic validator in domain
-    @validator("total")
-    def validate_total(cls, v):
-        if v < 0:
-            raise ValueError("Total must be non-negative")
-        return v
-
-
-class OrderEntity:
-    """Order entity with SQLAlchemy annotations - major violation."""
-
-    __tablename__ = "orders"
-
-    # MAJOR: ORM annotations in domain entity
-    id: Mapped[str] = mapped_column(String, primary_key=True)
-    user_id: Mapped[str] = mapped_column(String)
-    total: Mapped[float] = mapped_column(Float)
-''')
-
-        # Application layer with violations
-        application_dir = repo_path / "application"
-        application_dir.mkdir(parents=True, exist_ok=True)
-
-        (application_dir / "__init__.py").write_text("")
-        (application_dir / "service.py").write_text('''
-"""Application service with VIOLATIONS."""
-
-# CRITICAL: Application importing from adapter layer
-from adapters.driving.controller import UserController
-from adapters.driven.user_repository_impl import SqlUserRepository
-
-# CRITICAL: Application importing infrastructure
-from infrastructure.cache import RedisCache
-
-# MAJOR: Application using web framework
-from fastapi import Depends, HTTPException
-
-
-class UserService:
-    """User service with critical violations."""
-
-    def __init__(self):
-        # CRITICAL: Direct adapter instantiation in application
-        self._controller = UserController()
-        self._repository = SqlUserRepository("postgresql://...")
-        self._cache = RedisCache()
-
-    def get_user(self, user_id: str):
-        """Get user - violates hexagonal boundaries."""
-        # MAJOR: Direct HTTP exception in application
-        user = self._repository.find_by_id(user_id)
-        if not user:
-            raise HTTPException(status_code=404, detail="User not found")
-        return user
-''')
-
-        # Infrastructure directory (referenced by domain)
-        infrastructure_dir = repo_path / "infrastructure"
-        infrastructure_dir.mkdir(parents=True, exist_ok=True)
-
-        (infrastructure_dir / "__init__.py").write_text("")
-        (infrastructure_dir / "database.py").write_text('''
-"""Database infrastructure."""
-
-def get_connection():
-    """Get database connection."""
-    return "database-connection"
-''')
-
-        (infrastructure_dir / "cache.py").write_text('''
-"""Cache infrastructure."""
-
-class RedisCache:
-    """Redis cache implementation."""
-
-    def __init__(self):
-        self._data = {}
-
-    def get(self, key: str):
-        return self._data.get(key)
-
-    def set(self, key: str, value):
-        self._data[key] = value
-''')
-
-        # Adapter directories
-        adapters_driving_dir = repo_path / "adapters" / "driving"
-        adapters_driving_dir.mkdir(parents=True, exist_ok=True)
-
-        (adapters_driving_dir / "__init__.py").write_text("")
-        (adapters_driving_dir / "controller.py").write_text('''
-"""Controller - referenced by application layer (violation)."""
-
-class UserController:
-    """User controller."""
-
-    def create_user(self, request):
-        pass
-''')
-
-        adapters_driven_dir = repo_path / "adapters" / "driven"
-        adapters_driven_dir.mkdir(parents=True, exist_ok=True)
-
-        (adapters_driven_dir / "__init__.py").write_text("")
-        (adapters_driven_dir / "user_repository_impl.py").write_text('''
-"""User repository implementation."""
-
-class InMemoryUserRepository:
-    """In-memory user repository."""
-
-    def __init__(self):
-        self._users = {}
-
-    def find_by_id(self, user_id):
-        return self._users.get(user_id)
-
-    def save(self, user):
-        self._users[user.user_id] = user
-''')
-
-        return repo_path
-
-    @staticmethod
-    def create_python_mixed_repo(base_path: Path) -> Path:
-        """
-        Create a mixed compliance Python repository.
-
-        Has some compliant parts and some violations.
-        """
-        repo_path = base_path / "python-mixed"
-        repo_path.mkdir(parents=True, exist_ok=True)
-
-        # Domain layer - mix of compliant and non-compliant
-        domain_dir = repo_path / "domain"
-        domain_dir.mkdir(parents=True, exist_ok=True)
-
-        (domain_dir / "__init__.py").write_text("")
-        (domain_dir / "user.py").write_text('''
-"""Compliant user domain entity."""
-
-class User:
-    """Pure domain entity - compliant."""
-
-    def __init__(self, user_id: str, name: str, email: str):
-        self.user_id = user_id
-        self.name = name
-        self.email = email
-
-    def change_name(self, new_name: str) -> None:
-        """Change user name."""
-        self.name = new_name
-''')
-
-        (domain_dir / "product.py").write_text('''
-"""Product entity with minor violation."""
-
-# MINOR: Utility import in domain (consider domain purity)
-from util.helpers import generate_id
-
-# MINOR: Datetime import in domain (use value objects instead)
-from datetime import datetime
-
-
-class Product:
-    """Product entity with minor violations."""
-
-    def __init__(self, name: str, price: float):
-        self.product_id = generate_id()  # MINOR violation
-        self.name = name
-        self.price = price
-        self.created_at = datetime.now()  # MINOR violation
-''')
-
-        # Application layer - mostly compliant
-        application_dir = repo_path / "application"
-        application_dir.mkdir(parents=True, exist_ok=True)
-
-        (application_dir / "__init__.py").write_text("")
-        (application_dir / "use_case.py").write_text('''
-"""Compliant use case."""
-
-from domain.user import User
-
-
-class GetUserUseCase:
-    """Compliant use case - only depends on domain."""
-
-    def __init__(self, user_repository):
-        self._user_repository = user_repository
-
-    def execute(self, user_id: str):
-        """Execute use case."""
-        return self._user_repository.find_by_id(user_id)
-''')
-
-        (application_dir / "service.py").write_text('''
-"""Service with major violation."""
-
-# MAJOR: Web framework in application layer
-from flask import request, jsonify
-
-
-class ProductService:
-    """Service with major violation."""
-
-    def get_products(self):
-        """Get products - uses web framework in application."""
-        # MAJOR violation: Flask-specific code in application
-        page = request.args.get("page", 1)
-        return jsonify({"products": [], "page": page})
-''')
-
-        return repo_path
-
-
-@pytest.mark.integration
-@pytest.mark.slow
-class TestFullPipelineOnFixtures(unittest.TestCase):
-    """Test the full analysis pipeline on fixture repositories."""
-
-    @classmethod
-    def setUpClass(cls):
-        """Set up test fixtures."""
-        cls.temp_dir = tempfile.mkdtemp()
-        cls.temp_path = Path(cls.temp_dir)
-
-        # Create fixture repositories
-        cls.compliant_repo = FixtureBuilder.create_python_compliant_repo(cls.temp_path)
-        cls.noncompliant_repo = FixtureBuilder.create_python_noncompliant_repo(cls.temp_path)
-        cls.mixed_repo = FixtureBuilder.create_python_mixed_repo(cls.temp_path)
-
-        # Initialize classifier
-        cls.classifier = LayerClassifier()
-
-    @classmethod
-    def tearDownClass(cls):
-        """Clean up test fixtures."""
-        import shutil
-
-        if cls.temp_path.exists():
-            shutil.rmtree(cls.temp_path)
-
-    def _get_python_files(self, repo_path: Path) -> list[Path]:
-        """Get all Python files in a repository."""
-        return list(repo_path.rglob("*.py"))
-
-    def _analyze_repo(self, repo_path: Path) -> tuple[list[Violation], list[LayerAssignment]]:
-        """Analyze a repository and return violations and assignments."""
-        python_files = self._get_python_files(repo_path)
-
-        # Create repository profile
-        profile = RepositoryProfile(
-            repository_path=str(repo_path),
-            total_files=len(python_files),
-            files_by_language={"python": len(python_files)},
-            files_by_directory={},
-            excluded_directories=[],
-            language_distribution={"python": 1.0},
-            source_files=[str(f) for f in python_files],
-        )
-
-        # Initialize analyzers
-        python_analyzer = PythonAstAnalyzer()
-        fallback_analyzer = FallbackAnalyzer()
-
-        violations = []
-        assignments = []
-
-        for file_path in python_files:
-            # Classify file
-            assignment = self.classifier.classify_file(file_path)
-            assignments.append(assignment)
-
-            # Skip unknown layers
-            if assignment.layer == "unknown":
-                continue
-
-            # Analyze with appropriate analyzer
-            if python_analyzer.can_handle(file_path):
-                file_violations = python_analyzer.analyze(file_path, assignment, profile)
-            else:
-                file_violations = fallback_analyzer.analyze(file_path, assignment, profile)
-
-            violations.extend(file_violations)
-
-        return violations, assignments
-
-    def test_compliant_repo_has_no_critical_violations(self):
-        """Test that compliant repository has no critical violations."""
-        violations, assignments = self._analyze_repo(self.compliant_repo)
-
-        # Filter critical violations
-        critical_violations = [v for v in violations if v.severity == "critical"]
-
-        # Compliant repo should have no critical violations
-        self.assertEqual(
-            len(critical_violations),
-            0,
-            f"Compliant repo should have no critical violations, but found: {[v.category for v in critical_violations]}",
-        )
-
-    def test_noncompliant_repo_detects_critical_violations(self):
-        """Test that non-compliant repository detects critical violations."""
-        violations, assignments = self._analyze_repo(self.noncompliant_repo)
-
-        # Filter critical violations
-        critical_violations = [v for v in violations if v.severity == "critical"]
-
-        # Non-compliant repo should have critical violations
-        self.assertGreater(
-            len(critical_violations),
-            0,
-            "Non-compliant repo should have critical violations",
-        )
-
-        # Check for expected violation categories
-        {v.category for v in critical_violations}
-
-        # Should detect adapter imports in domain
-        adapter_imports = [v for v in critical_violations if "Adapter import" in v.category]
-        self.assertGreater(len(adapter_imports), 0, "Should detect adapter imports in domain")
-
-    def test_mixed_repo_detects_some_violations(self):
-        """Test that mixed repository detects some violations."""
-        violations, assignments = self._analyze_repo(self.mixed_repo)
-
-        # Mixed repo should have some violations
-        self.assertGreater(len(violations), 0, "Mixed repo should have some violations")
-
-        # But should have fewer critical violations than non-compliant
-        sum(1 for v in violations if v.severity == "critical")
-
-        # Should have some minor or major violations at least
-        non_critical = [v for v in violations if v.severity in ("major", "minor")]
-        self.assertGreater(len(non_critical), 0, "Mixed repo should have some violations")
-
-
-class TestAnalyzerRouting(unittest.TestCase):
-    """Test analyzer routing based on file type."""
-
-    def setUp(self):
-        """Set up test fixtures."""
-        self.temp_dir = tempfile.mkdtemp()
-        self.temp_path = Path(self.temp_dir)
-
-        # Create test files
-        self.python_file = self.temp_path / "test.py"
-        self.python_file.write_text("print('hello')")
-
-        self.js_file = self.temp_path / "test.js"
-        self.js_file.write_text("console.log('hello');")
-
-        self.java_file = self.temp_path / "Test.java"
-        self.java_file.write_text("public class Test {}")
-
-        self.txt_file = self.temp_path / "test.txt"
-        self.txt_file.write_text("hello world")
-
-        # Initialize analyzers
-        self.python_analyzer = PythonAstAnalyzer()
-        self.fallback_analyzer = FallbackAnalyzer()
-
-    def tearDown(self):
-        """Clean up test fixtures."""
-        import shutil
-
-        if self.temp_path.exists():
-            shutil.rmtree(self.temp_path)
-
-    def test_python_files_use_python_ast_analyzer(self):
-        """Test that .py files are handled by PythonAstAnalyzer."""
-        self.assertTrue(
-            self.python_analyzer.can_handle(self.python_file),
-            "PythonAstAnalyzer should handle .py files",
-        )
-
-    def test_non_python_files_use_fallback_analyzer(self):
-        """Test that non-.py files are handled by FallbackAnalyzer."""
-        # Fallback analyzer should handle all text files
-        self.assertTrue(
-            self.fallback_analyzer.can_handle(self.js_file),
-            "FallbackAnalyzer should handle .js files",
-        )
-        self.assertTrue(
-            self.fallback_analyzer.can_handle(self.java_file),
-            "FallbackAnalyzer should handle .java files",
-        )
-        self.assertTrue(
-            self.fallback_analyzer.can_handle(self.txt_file),
-            "FallbackAnalyzer should handle .txt files",
-        )
-
-    def test_python_analyzer_rejects_non_python_files(self):
-        """Test that PythonAstAnalyzer rejects non-.py files."""
-        self.assertFalse(
-            self.python_analyzer.can_handle(self.js_file),
-            "PythonAstAnalyzer should not handle .js files",
-        )
-        self.assertFalse(
-            self.python_analyzer.can_handle(self.java_file),
-            "PythonAstAnalyzer should not handle .java files",
-        )
-
-    def test_fallback_analyzer_rejects_binary_files(self):
-        """Test that FallbackAnalyzer rejects binary files."""
-        # Create a binary file
-        binary_file = self.temp_path / "test.bin"
-        binary_file.write_bytes(b"\x00\x01\x02\x03")
-
-        self.assertFalse(
-            self.fallback_analyzer.can_handle(binary_file),
-            "FallbackAnalyzer should not handle binary files",
-        )
-
-
-class TestLayerClassification(unittest.TestCase):
-    """Test layer classification for different file types."""
-
-    def setUp(self):
-        """Set up test fixtures."""
-        self.classifier = LayerClassifier()
-        self.temp_dir = tempfile.mkdtemp()
-        self.temp_path = Path(self.temp_dir)
-
-    def tearDown(self):
-        """Clean up test fixtures."""
-        import shutil
-
-        if self.temp_path.exists():
-            shutil.rmtree(self.temp_path)
-
-    def test_domain_files_classified_correctly(self):
-        """Test that domain files are classified as domain layer."""
-        test_cases = [
-            Path("/project/src/domain/entity.py"),
-            Path("/project/domain/models/user.py"),
-            Path("/project/core/domain/value_object.py"),
-            Path("/project/entities/User.java"),
-            Path("/project/model/order.py"),
-        ]
-
-        for file_path in test_cases:
-            assignment = self.classifier.classify_file(file_path)
-            self.assertEqual(
-                assignment.layer,
-                "domain",
-                f"File {file_path} should be classified as domain, got {assignment.layer}",
-            )
-
-    def test_application_files_classified_correctly(self):
-        """Test that application files are classified as application layer."""
-        test_cases = [
-            Path("/project/src/application/service.py"),
-            Path("/project/application/use_cases/create_order.py"),
-            Path("/project/usecase/PlaceOrder.java"),
-            Path("/project/service/UserService.py"),
-            Path("/project/command/CreateUserCommand.py"),
-            Path("/project/query/GetUserQuery.py"),
-            Path("/project/port/UserRepository.py"),
-            Path("/project/dto/UserDTO.py"),
-        ]
-
-        for file_path in test_cases:
-            assignment = self.classifier.classify_file(file_path)
-            self.assertEqual(
-                assignment.layer,
-                "application",
-                f"File {file_path} should be classified as application, got {assignment.layer}",
-            )
-
-    def test_driving_adapter_files_classified_correctly(self):
-        """Test that driving adapter files are classified correctly."""
-        test_cases = [
-            Path("/project/src/adapter/web/UserController.py"),
-            Path("/project/controller/UserController.java"),
-            Path("/project/api/rest/user_routes.py"),
-            Path("/project/rest/UserResource.py"),
-            Path("/project/graphql/schema.py"),
-            Path("/project/cli/commands.py"),
-            Path("/project/web/handlers.py"),
-            Path("/project/presentation/views.py"),
-            Path("/project/http/endpoints.py"),
-        ]
-
-        for file_path in test_cases:
-            assignment = self.classifier.classify_file(file_path)
-            self.assertEqual(
-                assignment.layer,
-                "driving_adapter",
-                f"File {file_path} should be classified as driving_adapter, got {assignment.layer}",
-            )
-
-    def test_driven_adapter_files_classified_correctly(self):
-        """Test that driven adapter files are classified correctly."""
-        test_cases = [
-            Path("/project/src/adapter/persistence/UserRepositoryImpl.py"),
-            Path("/project/repository/UserRepository.java"),
-            Path("/project/infrastructure/persistence/dao.py"),
-            Path("/project/persistence/models.py"),
-            Path("/project/dao/UserDAO.py"),
-            Path("/project/external/ApiClient.py"),
-            Path("/project/client/HttpClient.py"),
-            Path("/project/integration/ExternalService.py"),
-        ]
-
-        for file_path in test_cases:
-            assignment = self.classifier.classify_file(file_path)
-            self.assertEqual(
-                assignment.layer,
-                "driven_adapter",
-                f"File {file_path} should be classified as driven_adapter, got {assignment.layer}",
-            )
-
-    def test_classification_confidence_levels(self):
-        """Test that classification confidence levels are correct."""
-        # Config override should have highest confidence
-        # Create temporary config file with layer_overrides
-        import json
-
-        with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as f:
-            json.dump({"layer_overrides": {"/test/custom/path.py": "domain"}}, f)
-            temp_config_path = f.name
-
-        try:
-            config_manager = ConfigManager(config_path=temp_config_path)
-            config_manager.load()
-            classifier = LayerClassifier(config_manager=config_manager)
-
-            assignment = classifier.classify_file(Path("/test/custom/path.py"))
-            self.assertEqual(assignment.source, "config_override")
-            self.assertEqual(assignment.confidence, 1.0)
-
-            # Path rule should have medium-high confidence
-            assignment = classifier.classify_file(Path("/project/domain/entity.py"))
-            self.assertEqual(assignment.source, "path_rule")
-            self.assertEqual(assignment.confidence, 0.85)
-
-            # Import clue should have lower confidence
-            content = "from flask import Flask\nclass Controller:\n    pass"
-            assignment = classifier.classify_file(Path("/project/unknown/file.py"), content)
-            if assignment.source == "import_clue":
-                self.assertEqual(assignment.confidence, 0.65)
-        finally:
-            Path(temp_config_path).unlink(missing_ok=True)
-
-
-class TestViolationDetection(unittest.TestCase):
-    """Test violation detection in different layers."""
-
-    def setUp(self):
-        """Set up test fixtures."""
-        self.temp_dir = tempfile.mkdtemp()
-        self.temp_path = Path(self.temp_dir)
-
-        self.python_analyzer = PythonAstAnalyzer()
-        self.classifier = LayerClassifier()
-
-    def tearDown(self):
-        """Clean up test fixtures."""
-        import shutil
-
-        if self.temp_path.exists():
-            shutil.rmtree(self.temp_path)
-
-    def _create_test_file(self, relative_path: str, content: str) -> Path:
-        """Create a test file with the given content."""
-        file_path = self.temp_path / relative_path
-        file_path.parent.mkdir(parents=True, exist_ok=True)
-        file_path.write_text(content)
-        return file_path
-
-    def test_critical_violations_detected_in_domain(self):
-        """Test that critical violations are detected in domain layer."""
-        # Create domain file with critical violations
-        domain_file = self._create_test_file(
-            "domain/entity.py",
-            """
-# Critical: Adapter import in domain
-from adapters.driven.repository import Repository
-
-class Entity:
-    pass
-""",
-        )
-
-        assignment = self.classifier.classify_file(domain_file)
-        self.assertEqual(assignment.layer, "domain")
-
-        profile = RepositoryProfile(
-            repository_path=str(self.temp_path),
-            total_files=1,
-            files_by_language={"python": 1},
-            files_by_directory={},
-            excluded_directories=[],
-            language_distribution={"python": 1.0},
-            source_files=[str(domain_file)],
-        )
-
-        violations = self.python_analyzer.analyze(domain_file, assignment, profile)
-
-        # Should have critical violations
-        critical = [v for v in violations if v.severity == "critical"]
-        self.assertGreater(len(critical), 0, "Should detect critical violations in domain")
-
-    def test_major_violations_detected_in_application(self):
-        """Test that major violations are detected in application layer."""
-        # Create application file with major violations
-        app_file = self._create_test_file(
-            "application/service.py",
-            """
-# Major: Web framework in application
-from flask import Flask, request
-
-class Service:
-    pass
-""",
-        )
-
-        assignment = self.classifier.classify_file(app_file)
-        self.assertEqual(assignment.layer, "application")
-
-        profile = RepositoryProfile(
-            repository_path=str(self.temp_path),
-            total_files=1,
-            files_by_language={"python": 1},
-            files_by_directory={},
-            excluded_directories=[],
-            language_distribution={"python": 1.0},
-            source_files=[str(app_file)],
-        )
-
-        violations = self.python_analyzer.analyze(app_file, assignment, profile)
-
-        # Should have violations (major or critical)
-        self.assertGreater(len(violations), 0, "Should detect violations in application")
-
-    def test_confidence_scores_are_appropriate(self):
-        """Test that confidence scores are appropriate for different violations."""
-        # Create file with violations
-        domain_file = self._create_test_file(
-            "domain/entity.py",
-            """
-# Critical violation
-from infrastructure.database import db
-
-# Major violation
-from sqlalchemy import Column
-
-class Entity:
-    pass
-""",
-        )
-
-        assignment = self.classifier.classify_file(domain_file)
-        profile = RepositoryProfile(
-            repository_path=str(self.temp_path),
-            total_files=1,
-            files_by_language={"python": 1},
-            files_by_directory={},
-            excluded_directories=[],
-            language_distribution={"python": 1.0},
-            source_files=[str(domain_file)],
-        )
-
-        violations = self.python_analyzer.analyze(domain_file, assignment, profile)
-
-        for violation in violations:
-            # All violations should have confidence between 0 and 1
-            self.assertGreaterEqual(violation.confidence, 0.0)
-            self.assertLessEqual(violation.confidence, 1.0)
-
-            # Confidence factors should be populated
-            self.assertIsInstance(violation.confidence_factors, dict)
-            self.assertIn("detection_factor", violation.confidence_factors)
-            self.assertIn("layer_factor", violation.confidence_factors)
-
-    def test_evidence_status_is_set(self):
-        """Test that evidence_status is properly set for violations."""
-        domain_file = self._create_test_file(
-            "domain/entity.py",
-            """
-from infrastructure import Database
-""",
-        )
-
-        assignment = self.classifier.classify_file(domain_file)
-        profile = RepositoryProfile(
-            repository_path=str(self.temp_path),
-            total_files=1,
-            files_by_language={"python": 1},
-            files_by_directory={},
-            excluded_directories=[],
-            language_distribution={"python": 1.0},
-            source_files=[str(domain_file)],
-        )
-
-        violations = self.python_analyzer.analyze(domain_file, assignment, profile)
-
-        for violation in violations:
-            self.assertIn(
-                violation.evidence_status,
-                ["confirmed_gap", "evidence_gap"],
-                f"evidence_status should be confirmed_gap or evidence_gap, got {violation.evidence_status}",
-            )
-
-    def test_remediation_steps_are_provided(self):
-        """Test that remediation steps are provided for violations."""
-        domain_file = self._create_test_file(
-            "domain/entity.py",
-            """
-from adapter import Repository
-""",
-        )
-
-        assignment = self.classifier.classify_file(domain_file)
-        profile = RepositoryProfile(
-            repository_path=str(self.temp_path),
-            total_files=1,
-            files_by_language={"python": 1},
-            files_by_directory={},
-            excluded_directories=[],
-            language_distribution={"python": 1.0},
-            source_files=[str(domain_file)],
-        )
-
-        violations = self.python_analyzer.analyze(domain_file, assignment, profile)
-
-        for violation in violations:
-            self.assertIsInstance(violation.remediation_steps, list)
-            self.assertGreater(len(violation.remediation_steps), 0, "Should provide remediation steps")
-
-
-class TestReportGeneration(unittest.TestCase):
-    """Test report generation in different formats."""
-
-    def test_json_export_structure(self):
-        """Test that JSON export has correct structure."""
-        # Create a sample compliance report
-        report = ComplianceReport(
-            repository_path="/test/repo",
-            files_scanned=10,
-            files_analyzed=8,
-            coverage_ratio=0.8,
-            compliance_level=2.5,
-            confidence_score=0.85,
-            layer_distribution={
-                "domain": 3,
-                "application": 3,
-                "driving_adapter": 1,
-                "driven_adapter": 1,
-            },
-            violations=[
-                Violation(
-                    violation_id="HEX-001",
-                    file_path="/test/repo/domain/entity.py",
-                    line_number=10,
-                    symbol_name="Repository",
-                    layer="domain",
-                    severity="critical",
-                    category="Adapter import in domain layer",
-                    detection_mode="python_ast",
-                    confidence=0.95,
-                    confidence_factors={"detection_factor": 0.95, "layer_factor": 0.95},
-                    code_snippet="from adapter import Repository",
-                    context_before="class Entity:",
-                    context_after="    pass",
-                    remediation_steps=["Remove adapter dependency"],
-                    evidence_status="confirmed_gap",
-                )
-            ],
-            timestamp="2024-01-01T00:00:00",
-            total_violations=1,
-            violations_by_severity={"critical": 1, "major": 0, "minor": 0},
-            violations_by_layer={"domain": {"critical": 1}},
-        )
-
-        # Export to dict (JSON structure)
-        report_dict = report.to_dict()
-
-        # Verify required fields
-        self.assertIn("repository_path", report_dict)
-        self.assertIn("files_scanned", report_dict)
-        self.assertIn("files_analyzed", report_dict)
-        self.assertIn("compliance_level", report_dict)
-        self.assertIn("confidence_score", report_dict)
-        self.assertIn("layer_distribution", report_dict)
-        self.assertIn("violations", report_dict)
-        self.assertIn("total_violations", report_dict)
-        self.assertIn("violations_by_severity", report_dict)
-        self.assertIn("violations_by_layer", report_dict)
-
-        # Verify violations structure
-        self.assertIsInstance(report_dict["violations"], list)
-        if report_dict["violations"]:
-            violation = report_dict["violations"][0]
-            self.assertIn("violation_id", violation)
-            self.assertIn("file_path", violation)
-            self.assertIn("line_number", violation)
-            self.assertIn("layer", violation)
-            self.assertIn("severity", violation)
-            self.assertIn("category", violation)
-            self.assertIn("detection_mode", violation)
-            self.assertIn("confidence", violation)
-            self.assertIn("remediation_steps", violation)
-            self.assertIn("evidence_status", violation)
-
-    def test_markdown_export_format(self):
-        """Test that Markdown export generates valid content."""
-        report = ComplianceReport(
-            repository_path="/test/repo",
-            files_scanned=10,
-            files_analyzed=8,
-            coverage_ratio=0.8,
-            compliance_level=2.5,
-            confidence_score=0.85,
-            layer_distribution={"domain": 3, "application": 3},
-            violations=[],
-            timestamp="2024-01-01T00:00:00",
-            total_violations=0,
-            violations_by_severity={},
-            violations_by_layer={},
-        )
-
-        # Generate markdown content (simplified)
-        md_lines = [
-            "# Hexagonal Architecture Compliance Report",
-            "",
-            f"**Repository**: `{report.repository_path}`",
-            f"**Compliance Level**: {report.compliance_level:.2f} / 3.00",
-            f"**Confidence Score**: {report.confidence_score:.2f}",
-            "",
-            "## Summary",
-            "",
-            f"- Total Files Analyzed: {report.files_analyzed}",
-            f"- Total Violations: {report.total_violations}",
-            "",
-            "## Layer Distribution",
-            "",
-        ]
-
-        for layer, count in report.layer_distribution.items():
-            md_lines.append(f"- {layer}: {count} files")
-
-        md_content = "\n".join(md_lines)
-
-        # Verify markdown structure
-        self.assertIn("# Hexagonal Architecture Compliance Report", md_content)
-        self.assertIn("/test/repo", md_content)
-        self.assertIn("Compliance Level", md_content)
-        self.assertIn("Layer Distribution", md_content)
-
-    def test_report_matches_compliance_report_model(self):
-        """Test that generated report matches ComplianceReport model."""
-        report = ComplianceReport(
-            repository_path="/test/repo",
-            files_scanned=10,
-            files_analyzed=8,
-            coverage_ratio=0.8,
-            compliance_level=2.5,
-            confidence_score=0.85,
-            layer_distribution={"domain": 3, "application": 3},
-            violations=[],
-            timestamp="2024-01-01T00:00:00",
-            total_violations=0,
-            violations_by_severity={"critical": 0, "major": 0, "minor": 0},
-            violations_by_layer={},
-        )
-
-        # Verify model attributes
-        self.assertEqual(report.repository_path, "/test/repo")
-        self.assertEqual(report.files_scanned, 10)
-        self.assertEqual(report.files_analyzed, 8)
-        self.assertEqual(report.compliance_level, 2.5)
-        self.assertEqual(report.confidence_score, 0.85)
-        self.assertEqual(report.total_violations, 0)
-
-        # Verify to_dict works
-        report_dict = report.to_dict()
-        self.assertIsInstance(report_dict, dict)
-        self.assertEqual(report_dict["repository_path"], "/test/repo")
-
-
-@pytest.mark.integration
-class TestConfiguration(unittest.TestCase):
-    """Test configuration loading and layer overrides."""
-
-    def setUp(self):
-        """Set up test fixtures."""
-        self.temp_dir = tempfile.mkdtemp()
-        self.temp_path = Path(self.temp_dir)
-
-    def tearDown(self):
-        """Clean up test fixtures."""
-        import shutil
-
-        if self.temp_path.exists():
-            shutil.rmtree(self.temp_path)
-
-    def test_custom_config_loading(self):
-        """Test loading custom configuration."""
-        # Create custom config file
-        config_file = self.temp_path / ".hexagonal-config.json"
-        config_file.write_text(
-            json.dumps(
-                {
-                    "layers": {"domain": {"patterns": ["custom-domain/**"]}},
-                    "exclusions": {"paths": ["vendor/**"]},
-                }
-            )
-        )
-
-        # Load configuration
-        config_manager = ConfigManager(config_file)
-        config = config_manager.load()
-
-        # Verify custom patterns are loaded
-        self.assertIsNotNone(config)
-        domain_patterns = config_manager.get_layer_patterns("domain")
-        self.assertIn("custom-domain/**", domain_patterns)
-
-    def test_layer_override_via_config(self):
-        """Test layer override through configuration."""
-        # Create config with layer overrides
-        import json
-
-        config = {
-            "layer_overrides": {
-                "/custom/path/entity.py": "domain",
-                r".*Controller\.py$": "driving_adapter",
-            }
-        }
-
-        # Create temporary config file
-        with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as f:
-            json.dump(config, f)
-            temp_config_path = f.name
-
-        try:
-            # Create classifier with config
-            config_manager = ConfigManager(config_path=temp_config_path)
-            config_manager.load()
-            classifier = LayerClassifier(config_manager=config_manager)
-
-            # Test override
-            assignment = classifier.classify_file(Path("/custom/path/entity.py"))
-            self.assertEqual(assignment.layer, "domain")
-            self.assertEqual(assignment.source, "config_override")
-            self.assertEqual(assignment.confidence, 1.0)
-        finally:
-            Path(temp_config_path).unlink(missing_ok=True)
-
-    def test_default_config_used_when_no_file(self):
-        """Test that default configuration is used when no file exists."""
-        config_manager = ConfigManager()
-        config = config_manager.load()
-
-        # Should have default layers
-        self.assertIn("layers", config)
-        self.assertIn("domain", config["layers"])
-        self.assertIn("application", config["layers"])
-
-    def test_config_exclusions(self):
-        """Test that configuration exclusions work correctly."""
-        config = {"exclusions": {"paths": ["vendor/**", "generated/**", "**/test/**"]}}
-
-        config_manager = ConfigManager()
-        config_manager._config = config
-
-        exclusions = config_manager.get_exclusion_paths()
-        self.assertIn("vendor/**", exclusions)
-        self.assertIn("generated/**", exclusions)
-
-    def test_config_validation(self):
-        """Test configuration validation."""
-        from vds_hexagonal_orchestrator.config import ConfigValidationError
-
-        # Invalid config (layers not a dict)
-        config_manager = ConfigManager()
-
-        with self.assertRaises(ConfigValidationError):
-            config_manager._validate_config({"layers": "invalid"})
-
-    def test_config_merge_with_defaults(self):
-        """Test that custom config merges with defaults."""
-        config_manager = ConfigManager()
-        custom_config = {"layers": {"domain": {"patterns": ["custom-domain/**"]}}}
-
-        merged = config_manager._merge_configs(DEFAULT_CONFIG, custom_config)
-
-        # Should have both default and custom patterns
-        self.assertIn("custom-domain/**", merged["layers"]["domain"]["patterns"])
-
-
-@pytest.mark.integration
-class TestFallbackAnalyzer(unittest.TestCase):
-    """Test FallbackAnalyzer behavior."""
-
-    def setUp(self):
-        """Set up test fixtures."""
-        self.analyzer = FallbackAnalyzer()
-        self.temp_dir = tempfile.mkdtemp()
-        self.temp_path = Path(self.temp_dir)
-
-    def tearDown(self):
-        """Clean up test fixtures."""
-        import shutil
-
-        if self.temp_path.exists():
-            shutil.rmtree(self.temp_path)
-
-    def test_fallback_confidence_capped_at_074(self):
-        """Test that fallback analyzer confidence is capped at 0.74."""
-        # Create a test file with violations
-        test_file = self.temp_path / "domain" / "entity.java"
-        test_file.parent.mkdir(parents=True, exist_ok=True)
-        test_file.write_text("""
-import com.example.adapter.Repository;
-
-public class Entity {
-}
-""")
-
-        assignment = LayerAssignment(
-            file_path=str(test_file),
-            layer="domain",
-            source="path_rule",
-            confidence=0.85,
-        )
-
-        profile = RepositoryProfile(
-            repository_path=str(self.temp_path),
-            total_files=1,
-            files_by_language={"java": 1},
-            files_by_directory={},
-            excluded_directories=[],
-            language_distribution={"java": 1.0},
-            source_files=[str(test_file)],
-        )
-
-        violations = self.analyzer.analyze(test_file, assignment, profile)
-
-        for violation in violations:
-            self.assertLessEqual(
-                violation.confidence,
-                0.74,
-                f"Fallback analyzer confidence should be capped at 0.74, got {violation.confidence}",
-            )
-
-    def test_fallback_detection_mode_is_regex(self):
-        """Test that fallback analyzer uses 'regex' detection mode."""
-        test_file = self.temp_path / "domain" / "entity.java"
-        test_file.parent.mkdir(parents=True, exist_ok=True)
-        test_file.write_text("import adapter.Repository;")
-
-        assignment = LayerAssignment(
-            file_path=str(test_file),
-            layer="domain",
-            source="path_rule",
-            confidence=0.85,
-        )
-
-        profile = RepositoryProfile(
-            repository_path=str(self.temp_path),
-            total_files=1,
-            files_by_language={"java": 1},
-            files_by_directory={},
-            excluded_directories=[],
-            language_distribution={"java": 1.0},
-            source_files=[str(test_file)],
-        )
-
-        violations = self.analyzer.analyze(test_file, assignment, profile)
-
-        for violation in violations:
-            self.assertEqual(
-                violation.detection_mode,
-                "regex",
-                "Fallback analyzer should use 'regex' detection mode",
-            )
-
-
-if __name__ == "__main__":
-    # Run tests with verbosity
-    unittest.main(verbosity=2)