bakery-ia/services/auth/tests/conftest.py

# ================================================================
# services/auth/tests/conftest.py
# Pytest configuration and shared fixtures for auth service tests
# ================================================================
"""
Shared test configuration and fixtures for authentication service tests
"""

import pytest
import asyncio
import os
import sys
from typing import AsyncGenerator
from unittest.mock import AsyncMock, MagicMock, patch
from fastapi.testclient import TestClient
from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine
from sqlalchemy.orm import sessionmaker
import redis.asyncio as redis

# Add the app directory to the Python path for imports
sys.path.append(os.path.join(os.path.dirname(__file__), '..'))

# ================================================================
# TEST DATABASE CONFIGURATION
# ================================================================

# Use in-memory SQLite for fast testing
TEST_DATABASE_URL = "sqlite+aiosqlite:///:memory:"

@pytest.fixture(scope="session")
def event_loop():
    """Create an instance of the default event loop for the test session."""
    loop = asyncio.get_event_loop_policy().new_event_loop()
    yield loop
    loop.close()

@pytest.fixture(scope="function")
async def test_engine():
    """Create a test database engine for each test function"""
    engine = create_async_engine(
        TEST_DATABASE_URL,
        echo=False,  # Set to True for SQL debugging
        future=True,
        pool_pre_ping=True
    )
    
    try:
        # Import models and base here to avoid import issues
        from shared.database.base import Base
        # Create all tables
        async with engine.begin() as conn:
            await conn.run_sync(Base.metadata.create_all)
        
        yield engine
        
        # Cleanup
        async with engine.begin() as conn:
            await conn.run_sync(Base.metadata.drop_all)
    except ImportError:
        # If shared.database.base is not available, create a mock
        yield engine
    finally:
        await engine.dispose()

@pytest.fixture(scope="function")
async def test_db(test_engine) -> AsyncGenerator[AsyncSession, None]:
    """Create a test database session for each test function"""
    async_session = sessionmaker(
        test_engine, 
        class_=AsyncSession, 
        expire_on_commit=False
    )
    
    async with async_session() as session:
        yield session

@pytest.fixture(scope="function")
def client(test_db):
    """Create a test client with database dependency override"""
    try:
        from app.main import app
        from app.core.database import get_db
        
        def override_get_db():
            return test_db
        
        app.dependency_overrides[get_db] = override_get_db
        
        with TestClient(app) as test_client:
            yield test_client
        
        # Clean up overrides
        app.dependency_overrides.clear()
    except ImportError as e:
        pytest.skip(f"Cannot import app modules: {e}")

# ================================================================
# MOCK FIXTURES
# ================================================================

@pytest.fixture
def mock_redis():
    """Mock Redis client for testing rate limiting and session management"""
    redis_mock = AsyncMock()
    
    # Default return values for common operations
    redis_mock.get.return_value = None
    redis_mock.incr.return_value = 1
    redis_mock.expire.return_value = True
    redis_mock.delete.return_value = True
    redis_mock.setex.return_value = True
    redis_mock.exists.return_value = False
    
    return redis_mock

@pytest.fixture
def mock_rabbitmq():
    """Mock RabbitMQ for testing event publishing"""
    rabbitmq_mock = AsyncMock()
    
    # Mock publisher methods
    rabbitmq_mock.publish.return_value = True
    rabbitmq_mock.connect.return_value = True
    rabbitmq_mock.disconnect.return_value = True
    
    return rabbitmq_mock

@pytest.fixture
def mock_external_services():
    """Mock external service calls (tenant service, etc.)"""
    with patch('httpx.AsyncClient') as mock_client:
        mock_response = AsyncMock()
        mock_response.status_code = 200
        mock_response.json.return_value = {"tenants": []}
        mock_client.return_value.__aenter__.return_value.get.return_value = mock_response
        mock_client.return_value.__aenter__.return_value.post.return_value = mock_response
        
        yield mock_client

# ================================================================
# DATA FIXTURES
# ================================================================

@pytest.fixture
def valid_user_data():
    """Valid user registration data"""
    return {
        "email": "test@bakery.es",
        "password": "TestPassword123",
        "full_name": "Test User"
    }

@pytest.fixture
def valid_user_data_list():
    """List of valid user data for multiple users"""
    return [
        {
            "email": f"test{i}@bakery.es",
            "password": "TestPassword123",
            "full_name": f"Test User {i}"
        }
        for i in range(1, 6)
    ]

@pytest.fixture
def weak_password_data():
    """User data with various weak passwords"""
    return [
        {"email": "weak1@bakery.es", "password": "123", "full_name": "Weak 1"},
        {"email": "weak2@bakery.es", "password": "password", "full_name": "Weak 2"},
        {"email": "weak3@bakery.es", "password": "PASSWORD123", "full_name": "Weak 3"},
        {"email": "weak4@bakery.es", "password": "testpassword", "full_name": "Weak 4"},
    ]

@pytest.fixture
def invalid_email_data():
    """User data with invalid email formats"""
    return [
        {"email": "invalid", "password": "TestPassword123", "full_name": "Invalid 1"},
        {"email": "@bakery.es", "password": "TestPassword123", "full_name": "Invalid 2"},
        {"email": "test@", "password": "TestPassword123", "full_name": "Invalid 3"},
        {"email": "test..test@bakery.es", "password": "TestPassword123", "full_name": "Invalid 4"},
    ]

# ================================================================
# USER FIXTURES
# ================================================================

@pytest.fixture
async def test_user(test_db, valid_user_data):
    """Create a test user in the database"""
    try:
        from app.services.auth_service import AuthService
        
        user = await AuthService.create_user(
            email=valid_user_data["email"],
            password=valid_user_data["password"],
            full_name=valid_user_data["full_name"],
            db=test_db
        )
        return user
    except ImportError:
        pytest.skip("AuthService not available")

@pytest.fixture
async def test_users(test_db, valid_user_data_list):
    """Create multiple test users in the database"""
    try:
        from app.services.auth_service import AuthService
        
        users = []
        for user_data in valid_user_data_list:
            user = await AuthService.create_user(
                email=user_data["email"],
                password=user_data["password"],
                full_name=user_data["full_name"],
                db=test_db
            )
            users.append(user)
        return users
    except ImportError:
        pytest.skip("AuthService not available")

@pytest.fixture
async def authenticated_user(client, valid_user_data):
    """Create an authenticated user and return user info, tokens, and headers"""
    # Register user
    register_response = client.post("/auth/register", json=valid_user_data)
    assert register_response.status_code == 200
    
    # Login user
    login_data = {
        "email": valid_user_data["email"],
        "password": valid_user_data["password"]
    }
    login_response = client.post("/auth/login", json=login_data)
    assert login_response.status_code == 200
    
    token_data = login_response.json()
    
    return {
        "user": register_response.json(),
        "tokens": token_data,
        "access_token": token_data["access_token"],
        "refresh_token": token_data["refresh_token"],
        "headers": {"Authorization": f"Bearer {token_data['access_token']}"}
    }

# ================================================================
# CONFIGURATION FIXTURES
# ================================================================

@pytest.fixture
def test_settings():
    """Test-specific settings override"""
    try:
        from app.core.config import settings
        
        original_settings = {}
        
        # Store original values
        test_overrides = {
            'JWT_ACCESS_TOKEN_EXPIRE_MINUTES': 30,
            'JWT_REFRESH_TOKEN_EXPIRE_DAYS': 7,
            'PASSWORD_MIN_LENGTH': 8,
            'PASSWORD_REQUIRE_UPPERCASE': True,
            'PASSWORD_REQUIRE_LOWERCASE': True,
            'PASSWORD_REQUIRE_NUMBERS': True,
            'PASSWORD_REQUIRE_SYMBOLS': False,
            'MAX_LOGIN_ATTEMPTS': 5,
            'LOCKOUT_DURATION_MINUTES': 30,
            'BCRYPT_ROUNDS': 4,  # Lower for faster tests
        }
        
        for key, value in test_overrides.items():
            if hasattr(settings, key):
                original_settings[key] = getattr(settings, key)
                setattr(settings, key, value)
        
        yield settings
        
        # Restore original values
        for key, value in original_settings.items():
            setattr(settings, key, value)
    except ImportError:
        pytest.skip("Settings not available")

# ================================================================
# PATCHING FIXTURES
# ================================================================

@pytest.fixture
def patch_redis(mock_redis):
    """Patch Redis client for all tests"""
    with patch('app.core.security.redis_client', mock_redis):
        yield mock_redis

@pytest.fixture
def patch_messaging(mock_rabbitmq):
    """Patch messaging system for all tests"""
    with patch('app.services.messaging.publisher', mock_rabbitmq):
        yield mock_rabbitmq

@pytest.fixture
def patch_external_apis(mock_external_services):
    """Patch external API calls"""
    yield mock_external_services

# ================================================================
# UTILITY FIXTURES
# ================================================================

@pytest.fixture
def auth_headers():
    """Factory for creating authorization headers"""
    def _create_headers(token):
        return {"Authorization": f"Bearer {token}"}
    return _create_headers

@pytest.fixture
def password_generator():
    """Generate passwords with different characteristics"""
    def _generate(
        length=12, 
        include_upper=True, 
        include_lower=True, 
        include_numbers=True, 
        include_symbols=False
    ):
        import random
        import string
        
        chars = ""
        password = ""
        
        if include_lower:
            chars += string.ascii_lowercase
            password += random.choice(string.ascii_lowercase)
        
        if include_upper:
            chars += string.ascii_uppercase
            password += random.choice(string.ascii_uppercase)
        
        if include_numbers:
            chars += string.digits
            password += random.choice(string.digits)
        
        if include_symbols:
            chars += "!@#$%^&*"
            password += random.choice("!@#$%^&*")
        
        # Fill remaining length
        remaining = length - len(password)
        if remaining > 0:
            password += ''.join(random.choice(chars) for _ in range(remaining))
        
        # Shuffle the password
        password_list = list(password)
        random.shuffle(password_list)
        return ''.join(password_list)
    
    return _generate

# ================================================================
# PERFORMANCE TESTING FIXTURES
# ================================================================

@pytest.fixture
def performance_timer():
    """Timer utility for performance testing"""
    import time
    
    class Timer:
        def __init__(self):
            self.start_time = None
            self.end_time = None
        
        def start(self):
            self.start_time = time.time()
        
        def stop(self):
            self.end_time = time.time()
        
        @property
        def elapsed(self):
            if self.start_time and self.end_time:
                return self.end_time - self.start_time
            return None
        
        def __enter__(self):
            self.start()
            return self
        
        def __exit__(self, *args):
            self.stop()
    
    return Timer

# ================================================================
# DATABASE UTILITY FIXTURES
# ================================================================

@pytest.fixture
async def db_utils(test_db):
    """Database utility functions for testing"""
    class DBUtils:
        def __init__(self, db):
            self.db = db
        
        async def count_users(self):
            try:
                from sqlalchemy import select, func
                from app.models.users import User
                result = await self.db.execute(select(func.count(User.id)))
                return result.scalar()
            except ImportError:
                return 0
        
        async def get_user_by_email(self, email):
            try:
                from sqlalchemy import select
                from app.models.users import User
                result = await self.db.execute(select(User).where(User.email == email))
                return result.scalar_one_or_none()
            except ImportError:
                return None
        
        async def count_refresh_tokens(self):
            try:
                from sqlalchemy import select, func
                from app.models.users import RefreshToken
                result = await self.db.execute(select(func.count(RefreshToken.id)))
                return result.scalar()
            except ImportError:
                return 0
        
        async def clear_all_data(self):
            try:
                from app.models.users import User, RefreshToken
                await self.db.execute(RefreshToken.__table__.delete())
                await self.db.execute(User.__table__.delete())
                await self.db.commit()
            except ImportError:
                pass
    
    return DBUtils(test_db)

# ================================================================
# LOGGING FIXTURES
# ================================================================

@pytest.fixture
def capture_logs():
    """Capture logs for testing"""
    import logging
    from io import StringIO
    
    log_capture = StringIO()
    handler = logging.StreamHandler(log_capture)
    handler.setLevel(logging.DEBUG)
    
    # Add handler to auth service loggers
    loggers = [
        logging.getLogger('app.services.auth_service'),
        logging.getLogger('app.core.security'),
        logging.getLogger('app.api.auth'),
    ]
    
    for logger in loggers:
        logger.addHandler(handler)
        logger.setLevel(logging.DEBUG)
    
    yield log_capture
    
    # Clean up
    for logger in loggers:
        logger.removeHandler(handler)

# ================================================================
# TEST MARKERS AND CONFIGURATION
# ================================================================

def pytest_configure(config):
    """Configure pytest with custom markers"""
    config.addinivalue_line(
        "markers", "unit: marks tests as unit tests"
    )
    config.addinivalue_line(
        "markers", "integration: marks tests as integration tests"
    )
    config.addinivalue_line(
        "markers", "api: marks tests as API tests"
    )
    config.addinivalue_line(
        "markers", "security: marks tests as security tests"
    )
    config.addinivalue_line(
        "markers", "performance: marks tests as performance tests"
    )
    config.addinivalue_line(
        "markers", "slow: marks tests as slow running"
    )
    config.addinivalue_line(
        "markers", "auth: marks tests as authentication tests"
    )

def pytest_collection_modifyitems(config, items):
    """Modify test collection to add markers automatically"""
    for item in items:
        # Add markers based on test class or function names
        if "test_api" in item.name.lower() or "API" in str(item.cls):
            item.add_marker(pytest.mark.api)
        
        if "test_security" in item.name.lower() or "Security" in str(item.cls):
            item.add_marker(pytest.mark.security)
        
        if "test_performance" in item.name.lower() or "Performance" in str(item.cls):
            item.add_marker(pytest.mark.performance)
            item.add_marker(pytest.mark.slow)
        
        if "integration" in item.name.lower() or "Integration" in str(item.cls):
            item.add_marker(pytest.mark.integration)
        
        if "Flow" in str(item.cls) or "flow" in item.name.lower():
            item.add_marker(pytest.mark.integration)
        
        if "auth" in item.name.lower() or "Auth" in str(item.cls):
            item.add_marker(pytest.mark.auth)