metacoding 1.5.0 → 2.0.1

package/templates/python/python.testing.instructions.md

@@ -1,1073 +0,0 @@
----
-description: 'Python-specific testing patterns and frameworks (pytest, Django, FastAPI)'
-applyTo: 'test/**/*.py,tests/**/*.py,**/test_*.py'
----
-
-# Python Testing Standards
-
-## Test Case Naming Conventions
-
-### Test Case ID Format: `[AREA]-[TYPE]-[NUMBER]`
-
-**Python/Django/FastAPI Area Prefixes:**
-
-- `VIEW` - Django views/FastAPI endpoints tests
-- `MODEL` - Django models/SQLAlchemy tests
-- `FORM` - Django forms/Pydantic validators tests
-- `API` - REST API endpoint tests
-- `SRV` - Service layer tests
-- `DB` - Database/ORM tests
-- `AUTH` - Authentication/Authorization tests
-- `UTIL` - Backend utility function tests
-- `SERIALIZER` - DRF serializers/Pydantic schemas tests
-- `MIDDLEWARE` - Django middleware tests
-
-**Type Suffixes:**
-
-- `UNIT` - Unit tests (isolated component testing)
-- `INT` - Integration tests (component interaction testing)
-- `E2E` - End-to-end tests (full API workflow testing)
-
-**Examples:**
-
-- `VIEW-UNIT-001` - First unit test for Django view
-- `MODEL-UNIT-001` - First unit test for Django model
-- `FORM-INT-001` - First integration test for Django form
-- `API-E2E-001` - First end-to-end API test
-
-## Testing Framework and Setup
-
-### Primary Testing Framework: pytest
-
-```python
-# pytest.ini
-[tool:pytest]
-testpaths = tests
-python_files = test_*.py *_test.py
-python_classes = Test*
-python_functions = test_*
-addopts =
-    --strict-markers
-    --strict-config
-    --cov=src
-    --cov-report=term-missing
-    --cov-report=html
-    --cov-fail-under=80
-markers =
-    unit: Unit tests
-    integration: Integration tests
-    slow: Slow running tests
-    api: API endpoint tests
-```
-
-```python
-# conftest.py
-import pytest
-from unittest.mock import Mock
-from src.database import Database
-from src.services.user_service import UserService
-
-@pytest.fixture
-def mock_database():
-    """Mock database connection for testing."""
-    return Mock(spec=Database)
-
-@pytest.fixture
-def user_service(mock_database):
-    """User service with mocked dependencies."""
-    return UserService(database=mock_database)
-
-@pytest.fixture
-def sample_user_data():
-    """Sample user data for testing."""
-    return {
-        'name': 'John Doe',
-        'email': 'john@example.com',
-        'age': 30
-    }
-
-@pytest.fixture(scope="session")
-def test_database():
-    """Session-scoped test database."""
-    db = Database(DATABASE_TEST_URL)
-    db.create_tables()
-    yield db
-    db.drop_tables()
-    db.close()
-```
-
-### Test Case Naming Conventions
-
-**Area Prefixes for Python/Django:**
-
-- `VIEW` - View/Controller tests
-- `MODEL` - Model/ORM tests
-- `FORM` - Form validation tests
-- `CMD` - Management command tests
-- `API` - API endpoint tests
-- `SRV` - Service layer tests
-- `UTIL` - Utility function tests
-- `DB` - Database operation tests
-- `AUTH` - Authentication/Authorization tests
-- `INT` - Integration tests
-- `E2E` - End-to-end tests
-
-**Examples:**
-
-- `VIEW-UNIT-001` - First unit test for View layer
-- `MODEL-UNIT-001` - First unit test for Model layer
-- `API-INT-001` - First integration test for API
-- `E2E-FLOW-001` - First end-to-end workflow test
-
-## Unit Testing Patterns
-
-### Service Layer Testing
-
-```python
-# tests/unit/test_user_service.py
-import pytest
-from unittest.mock import Mock, patch, call
-from src.services.user_service import UserService, UserNotFoundError
-from src.models.user import User
-
-class TestUserService:
-    """Test suite for UserService class."""
-
-    @pytest.fixture
-    def mock_repository(self):
-        """Mock user repository."""
-        return Mock()
-
-    @pytest.fixture
-    def user_service(self, mock_repository):
-        """UserService instance with mocked dependencies."""
-        return UserService(repository=mock_repository)
-
-    def test_get_user_by_id_success(self, user_service, mock_repository):
-        """Test successful user retrieval by ID."""
-        # Arrange
-        user_id = "123"
-        expected_user = User(id=user_id, name="John Doe", email="john@example.com")
-        mock_repository.find_by_id.return_value = expected_user
-
-        # Act
-        result = user_service.get_user_by_id(user_id)
-
-        # Assert
-        assert result == expected_user
-        mock_repository.find_by_id.assert_called_once_with(user_id)
-
-    def test_get_user_by_id_not_found(self, user_service, mock_repository):
-        """Test user retrieval when user doesn't exist."""
-        # Arrange
-        user_id = "999"
-        mock_repository.find_by_id.return_value = None
-
-        # Act & Assert
-        with pytest.raises(UserNotFoundError, match=f"User {user_id} not found"):
-            user_service.get_user_by_id(user_id)
-
-        mock_repository.find_by_id.assert_called_once_with(user_id)
-
-    @pytest.mark.parametrize("user_id,expected_calls", [
-        ("valid_id", 1),
-        ("another_id", 1),
-    ])
-    def test_get_user_by_id_repository_calls(
-        self, user_service, mock_repository, user_id, expected_calls
-    ):
-        """Test repository is called correct number of times."""
-        # Arrange
-        mock_repository.find_by_id.return_value = Mock()
-
-        # Act
-        user_service.get_user_by_id(user_id)
-
-        # Assert
-        assert mock_repository.find_by_id.call_count == expected_calls
-
-    def test_create_user_success(self, user_service, mock_repository):
-        """Test successful user creation."""
-        # Arrange
-        user_data = {
-            'name': 'Jane Doe',
-            'email': 'jane@example.com'
-        }
-        created_user = User(id="456", **user_data)
-        mock_repository.create.return_value = created_user
-
-        # Act
-        result = user_service.create_user(user_data)
-
-        # Assert
-        assert result == created_user
-        mock_repository.create.assert_called_once_with(user_data)
-
-    def test_create_user_validation_error(self, user_service):
-        """Test user creation with invalid data."""
-        # Arrange
-        invalid_data = {'name': ''}  # Missing email
-
-        # Act & Assert
-        with pytest.raises(ValueError, match="Invalid user data"):
-            user_service.create_user(invalid_data)
-```
-
-### Model Testing (Django)
-
-```python
-# tests/unit/test_user_model.py
-import pytest
-from django.test import TestCase
-from django.core.exceptions import ValidationError
-from django.db import IntegrityError
-from src.models.user import User
-
-class TestUserModel(TestCase):
-    """Test suite for User model."""
-
-    def setUp(self):
-        """Set up test data."""
-        self.valid_user_data = {
-            'name': 'John Doe',
-            'email': 'john@example.com',
-            'age': 30
-        }
-
-    def test_create_user_success(self):
-        """Test successful user creation."""
-        # Act
-        user = User.objects.create(**self.valid_user_data)
-
-        # Assert
-        assert user.pk is not None
-        assert user.name == self.valid_user_data['name']
-        assert user.email == self.valid_user_data['email']
-        assert user.age == self.valid_user_data['age']
-        assert user.is_active is True  # Default value
-
-    def test_user_str_representation(self):
-        """Test string representation of user."""
-        # Arrange
-        user = User(**self.valid_user_data)
-
-        # Act
-        result = str(user)
-
-        # Assert
-        expected = f"{self.valid_user_data['name']} ({self.valid_user_data['email']})"
-        assert result == expected
-
-    def test_email_uniqueness_constraint(self):
-        """Test email uniqueness is enforced."""
-        # Arrange
-        User.objects.create(**self.valid_user_data)
-
-        # Act & Assert
-        with pytest.raises(IntegrityError):
-            User.objects.create(**self.valid_user_data)
-
-    def test_email_validation(self):
-        """Test email format validation."""
-        # Arrange
-        invalid_data = self.valid_user_data.copy()
-        invalid_data['email'] = 'invalid-email'
-
-        # Act & Assert
-        user = User(**invalid_data)
-        with pytest.raises(ValidationError):
-            user.full_clean()
-
-    @pytest.mark.parametrize("age,is_valid", [
-        (0, False),   # Too young
-        (13, True),   # Minimum valid age
-        (120, True),  # Maximum reasonable age
-        (150, False), # Too old
-        (-1, False),  # Negative age
-    ])
-    def test_age_validation(self, age, is_valid):
-        """Test age validation with various values."""
-        # Arrange
-        user_data = self.valid_user_data.copy()
-        user_data['age'] = age
-        user = User(**user_data)
-
-        # Act & Assert
-        if is_valid:
-            user.full_clean()  # Should not raise
-        else:
-            with pytest.raises(ValidationError):
-                user.full_clean()
-
-    def test_get_full_name_method(self):
-        """Test custom method for getting full name."""
-        # Arrange
-        user = User(name="John Doe", email="john@example.com")
-
-        # Act
-        result = user.get_full_name()
-
-        # Assert
-        assert result == "John Doe"
-
-    def test_is_adult_property(self):
-        """Test custom property for checking if user is adult."""
-        # Arrange
-        adult_user = User(age=25, name="Adult", email="adult@example.com")
-        minor_user = User(age=16, name="Minor", email="minor@example.com")
-
-        # Act & Assert
-        assert adult_user.is_adult is True
-        assert minor_user.is_adult is False
-```
-
-### View Testing (Django)
-
-```python
-# tests/unit/test_user_views.py
-import json
-import pytest
-from django.test import TestCase, Client
-from django.contrib.auth.models import User as AuthUser
-from django.urls import reverse
-from src.models.user import User
-
-class TestUserViews(TestCase):
-    """Test suite for user-related views."""
-
-    def setUp(self):
-        """Set up test data and client."""
-        self.client = Client()
-        self.auth_user = AuthUser.objects.create_user(
-            username='testuser',
-            password='testpass123'
-        )
-        self.user = User.objects.create(
-            name='John Doe',
-            email='john@example.com',
-            age=30
-        )
-
-    def test_user_list_view_success(self):
-        """Test user list view returns users."""
-        # Act
-        response = self.client.get(reverse('user:list'))
-
-        # Assert
-        assert response.status_code == 200
-        assert 'users' in response.context
-        assert self.user in response.context['users']
-
-    def test_user_detail_view_success(self):
-        """Test user detail view returns specific user."""
-        # Act
-        response = self.client.get(
-            reverse('user:detail', kwargs={'pk': self.user.pk})
-        )
-
-        # Assert
-        assert response.status_code == 200
-        assert response.context['user'] == self.user
-
-    def test_user_detail_view_not_found(self):
-        """Test user detail view with non-existent user."""
-        # Act
-        response = self.client.get(
-            reverse('user:detail', kwargs={'pk': 999})
-        )
-
-        # Assert
-        assert response.status_code == 404
-
-    def test_user_create_view_get(self):
-        """Test GET request to user create view."""
-        # Arrange
-        self.client.login(username='testuser', password='testpass123')
-
-        # Act
-        response = self.client.get(reverse('user:create'))
-
-        # Assert
-        assert response.status_code == 200
-        assert 'form' in response.context
-
-    def test_user_create_view_post_success(self):
-        """Test successful POST to user create view."""
-        # Arrange
-        self.client.login(username='testuser', password='testpass123')
-        user_data = {
-            'name': 'Jane Doe',
-            'email': 'jane@example.com',
-            'age': 25
-        }
-
-        # Act
-        response = self.client.post(reverse('user:create'), data=user_data)
-
-        # Assert
-        assert response.status_code == 302  # Redirect after success
-        assert User.objects.filter(email='jane@example.com').exists()
-
-    def test_user_create_view_post_invalid_data(self):
-        """Test POST to user create view with invalid data."""
-        # Arrange
-        self.client.login(username='testuser', password='testpass123')
-        invalid_data = {
-            'name': '',  # Invalid: empty name
-            'email': 'invalid-email',  # Invalid: bad email format
-            'age': -5  # Invalid: negative age
-        }
-
-        # Act
-        response = self.client.post(reverse('user:create'), data=invalid_data)
-
-        # Assert
-        assert response.status_code == 200  # Returns form with errors
-        assert 'form' in response.context
-        assert response.context['form'].errors
-
-    def test_user_create_view_requires_authentication(self):
-        """Test user create view requires authentication."""
-        # Act
-        response = self.client.get(reverse('user:create'))
-
-        # Assert
-        assert response.status_code == 302  # Redirect to login
-        assert '/login/' in response.url
-```
-
-### API Testing (FastAPI)
-
-```python
-# tests/unit/test_user_api.py
-import pytest
-from fastapi.testclient import TestClient
-from unittest.mock import Mock, patch
-from src.main import app
-from src.services.user_service import UserService
-from src.models.user import User
-
-client = TestClient(app)
-
-class TestUserAPI:
-    """Test suite for User API endpoints."""
-
-    @patch('src.dependencies.get_user_service')
-    def test_get_user_success(self, mock_get_service):
-        """Test successful user retrieval via API."""
-        # Arrange
-        user_id = "123"
-        expected_user = User(id=user_id, name="John Doe", email="john@example.com")
-        mock_service = Mock(spec=UserService)
-        mock_service.get_user_by_id.return_value = expected_user
-        mock_get_service.return_value = mock_service
-
-        # Act
-        response = client.get(f"/users/{user_id}")
-
-        # Assert
-        assert response.status_code == 200
-        assert response.json()["id"] == user_id
-        assert response.json()["name"] == "John Doe"
-        mock_service.get_user_by_id.assert_called_once_with(user_id)
-
-    @patch('src.dependencies.get_user_service')
-    def test_get_user_not_found(self, mock_get_service):
-        """Test user not found via API."""
-        # Arrange
-        user_id = "999"
-        mock_service = Mock(spec=UserService)
-        mock_service.get_user_by_id.side_effect = UserNotFoundError("User not found")
-        mock_get_service.return_value = mock_service
-
-        # Act
-        response = client.get(f"/users/{user_id}")
-
-        # Assert
-        assert response.status_code == 404
-        assert "not found" in response.json()["detail"].lower()
-
-    @patch('src.dependencies.get_user_service')
-    def test_create_user_success(self, mock_get_service):
-        """Test successful user creation via API."""
-        # Arrange
-        user_data = {
-            "name": "Jane Doe",
-            "email": "jane@example.com",
-            "age": 25
-        }
-        created_user = User(id="456", **user_data)
-        mock_service = Mock(spec=UserService)
-        mock_service.create_user.return_value = created_user
-        mock_get_service.return_value = mock_service
-
-        # Act
-        response = client.post("/users/", json=user_data)
-
-        # Assert
-        assert response.status_code == 201
-        assert response.json()["id"] == "456"
-        assert response.json()["name"] == user_data["name"]
-        mock_service.create_user.assert_called_once_with(user_data)
-
-    def test_create_user_validation_error(self):
-        """Test user creation with invalid data."""
-        # Arrange
-        invalid_data = {
-            "name": "",  # Invalid: empty name
-            "email": "invalid-email",  # Invalid: bad format
-            "age": -5  # Invalid: negative age
-        }
-
-        # Act
-        response = client.post("/users/", json=invalid_data)
-
-        # Assert
-        assert response.status_code == 422
-        assert "detail" in response.json()
-
-    @pytest.mark.parametrize("user_data,expected_status", [
-        ({"name": "Valid User", "email": "valid@example.com", "age": 25}, 201),
-        ({"name": "", "email": "valid@example.com", "age": 25}, 422),
-        ({"name": "Valid User", "email": "invalid-email", "age": 25}, 422),
-        ({"name": "Valid User", "email": "valid@example.com", "age": -1}, 422),
-    ])
-    @patch('src.dependencies.get_user_service')
-    def test_create_user_various_data(
-        self, mock_get_service, user_data, expected_status
-    ):
-        """Test user creation with various data combinations."""
-        # Arrange
-        if expected_status == 201:
-            created_user = User(id="123", **user_data)
-            mock_service = Mock(spec=UserService)
-            mock_service.create_user.return_value = created_user
-            mock_get_service.return_value = mock_service
-
-        # Act
-        response = client.post("/users/", json=user_data)
-
-        # Assert
-        assert response.status_code == expected_status
-```
-
-## Integration Testing
-
-### Database Integration Testing
-
-```python
-# tests/integration/test_user_repository.py
-import pytest
-import asyncio
-from sqlalchemy import create_engine
-from sqlalchemy.orm import sessionmaker
-from src.database.base import Base
-from src.repositories.user_repository import UserRepository
-from src.models.user import User
-
-class TestUserRepositoryIntegration:
-    """Integration tests for UserRepository with real database."""
-
-    @pytest.fixture(scope="class")
-    def db_engine(self):
-        """Create test database engine."""
-        engine = create_engine("sqlite:///:memory:", echo=False)
-        Base.metadata.create_all(engine)
-        yield engine
-        Base.metadata.drop_all(engine)
-
-    @pytest.fixture
-    def db_session(self, db_engine):
-        """Create database session for each test."""
-        Session = sessionmaker(bind=db_engine)
-        session = Session()
-        yield session
-        session.rollback()
-        session.close()
-
-    @pytest.fixture
-    def user_repository(self, db_session):
-        """Create UserRepository with real database session."""
-        return UserRepository(session=db_session)
-
-    def test_create_and_find_user(self, user_repository):
-        """Test creating and finding a user in database."""
-        # Arrange
-        user_data = {
-            'name': 'John Doe',
-            'email': 'john@example.com',
-            'age': 30
-        }
-
-        # Act
-        created_user = user_repository.create(user_data)
-        found_user = user_repository.find_by_id(created_user.id)
-
-        # Assert
-        assert found_user is not None
-        assert found_user.id == created_user.id
-        assert found_user.name == user_data['name']
-        assert found_user.email == user_data['email']
-
-    def test_find_by_email(self, user_repository):
-        """Test finding user by email."""
-        # Arrange
-        user_data = {
-            'name': 'Jane Doe',
-            'email': 'jane@example.com',
-            'age': 25
-        }
-        created_user = user_repository.create(user_data)
-
-        # Act
-        found_user = user_repository.find_by_email('jane@example.com')
-
-        # Assert
-        assert found_user is not None
-        assert found_user.id == created_user.id
-        assert found_user.email == 'jane@example.com'
-
-    def test_update_user(self, user_repository):
-        """Test updating user information."""
-        # Arrange
-        user_data = {
-            'name': 'Original Name',
-            'email': 'original@example.com',
-            'age': 30
-        }
-        created_user = user_repository.create(user_data)
-
-        # Act
-        update_data = {'name': 'Updated Name', 'age': 31}
-        updated_user = user_repository.update(created_user.id, update_data)
-
-        # Assert
-        assert updated_user.name == 'Updated Name'
-        assert updated_user.age == 31
-        assert updated_user.email == 'original@example.com'  # Unchanged
-
-    def test_delete_user(self, user_repository):
-        """Test deleting a user."""
-        # Arrange
-        user_data = {
-            'name': 'To Be Deleted',
-            'email': 'delete@example.com',
-            'age': 25
-        }
-        created_user = user_repository.create(user_data)
-
-        # Act
-        result = user_repository.delete(created_user.id)
-        found_user = user_repository.find_by_id(created_user.id)
-
-        # Assert
-        assert result is True
-        assert found_user is None
-
-    def test_list_users_with_pagination(self, user_repository):
-        """Test listing users with pagination."""
-        # Arrange
-        users_data = [
-            {'name': f'User {i}', 'email': f'user{i}@example.com', 'age': 20 + i}
-            for i in range(5)
-        ]
-        created_users = [user_repository.create(data) for data in users_data]
-
-        # Act
-        page_1 = user_repository.list_users(page=1, per_page=2)
-        page_2 = user_repository.list_users(page=2, per_page=2)
-
-        # Assert
-        assert len(page_1) == 2
-        assert len(page_2) == 2
-        assert page_1[0].id != page_2[0].id  # Different users
-```
-
-### API Integration Testing
-
-```python
-# tests/integration/test_api_integration.py
-import pytest
-from fastapi.testclient import TestClient
-from sqlalchemy import create_engine
-from sqlalchemy.orm import sessionmaker
-from src.main import app
-from src.database.base import Base
-from src.dependencies import get_database_session
-
-class TestAPIIntegration:
-    """Integration tests for API with real database."""
-
-    @pytest.fixture(scope="class")
-    def test_engine(self):
-        """Create test database engine."""
-        engine = create_engine("sqlite:///:memory:", echo=False)
-        Base.metadata.create_all(engine)
-        yield engine
-        Base.metadata.drop_all(engine)
-
-    @pytest.fixture
-    def test_session(self, test_engine):
-        """Create test database session."""
-        Session = sessionmaker(bind=test_engine)
-        session = Session()
-        yield session
-        session.close()
-
-    @pytest.fixture
-    def client(self, test_session):
-        """Create test client with test database."""
-        def override_get_db():
-            yield test_session
-
-        app.dependency_overrides[get_database_session] = override_get_db
-        client = TestClient(app)
-        yield client
-        app.dependency_overrides.clear()
-
-    def test_full_user_crud_workflow(self, client):
-        """Test complete CRUD workflow for users."""
-        # Create user
-        user_data = {
-            "name": "Test User",
-            "email": "test@example.com",
-            "age": 30
-        }
-
-        create_response = client.post("/users/", json=user_data)
-        assert create_response.status_code == 201
-        created_user = create_response.json()
-        user_id = created_user["id"]
-
-        # Read user
-        get_response = client.get(f"/users/{user_id}")
-        assert get_response.status_code == 200
-        assert get_response.json()["name"] == user_data["name"]
-
-        # Update user
-        update_data = {"name": "Updated User", "age": 31}
-        update_response = client.patch(f"/users/{user_id}", json=update_data)
-        assert update_response.status_code == 200
-        assert update_response.json()["name"] == "Updated User"
-
-        # List users
-        list_response = client.get("/users/")
-        assert list_response.status_code == 200
-        users = list_response.json()
-        assert len(users) >= 1
-        assert any(user["id"] == user_id for user in users)
-
-        # Delete user
-        delete_response = client.delete(f"/users/{user_id}")
-        assert delete_response.status_code == 204
-
-        # Verify deletion
-        get_deleted_response = client.get(f"/users/{user_id}")
-        assert get_deleted_response.status_code == 404
-
-    def test_user_email_uniqueness_constraint(self, client):
-        """Test email uniqueness is enforced at API level."""
-        # Arrange
-        user_data = {
-            "name": "First User",
-            "email": "duplicate@example.com",
-            "age": 25
-        }
-
-        # Act - Create first user
-        first_response = client.post("/users/", json=user_data)
-        assert first_response.status_code == 201
-
-        # Act - Try to create second user with same email
-        user_data["name"] = "Second User"
-        second_response = client.post("/users/", json=user_data)
-
-        # Assert
-        assert second_response.status_code == 400
-        assert "email" in second_response.json()["detail"].lower()
-```
-
-## Async Testing
-
-### Async Function Testing
-
-```python
-# tests/unit/test_async_service.py
-import pytest
-import asyncio
-from unittest.mock import AsyncMock, Mock
-from src.services.async_user_service import AsyncUserService
-
-class TestAsyncUserService:
-    """Test suite for async user service."""
-
-    @pytest.fixture
-    def mock_async_repository(self):
-        """Mock async repository."""
-        mock = AsyncMock()
-        return mock
-
-    @pytest.fixture
-    def async_user_service(self, mock_async_repository):
-        """Async user service with mocked dependencies."""
-        return AsyncUserService(repository=mock_async_repository)
-
-    @pytest.mark.asyncio
-    async def test_get_user_by_id_async(self, async_user_service, mock_async_repository):
-        """Test async user retrieval."""
-        # Arrange
-        user_id = "123"
-        expected_user = {"id": user_id, "name": "John Doe"}
-        mock_async_repository.find_by_id.return_value = expected_user
-
-        # Act
-        result = await async_user_service.get_user_by_id(user_id)
-
-        # Assert
-        assert result == expected_user
-        mock_async_repository.find_by_id.assert_called_once_with(user_id)
-
-    @pytest.mark.asyncio
-    async def test_create_multiple_users_concurrently(
-        self, async_user_service, mock_async_repository
-    ):
-        """Test creating multiple users concurrently."""
-        # Arrange
-        users_data = [
-            {"name": f"User {i}", "email": f"user{i}@example.com"}
-            for i in range(3)
-        ]
-        mock_async_repository.create.side_effect = [
-            {"id": f"id_{i}", **data} for i, data in enumerate(users_data)
-        ]
-
-        # Act
-        tasks = [
-            async_user_service.create_user(data) for data in users_data
-        ]
-        results = await asyncio.gather(*tasks)
-
-        # Assert
-        assert len(results) == 3
-        assert all("id" in result for result in results)
-        assert mock_async_repository.create.call_count == 3
-
-    @pytest.mark.asyncio
-    async def test_timeout_handling(self, async_user_service, mock_async_repository):
-        """Test handling of timeout in async operations."""
-        # Arrange
-        async def slow_operation(*args, **kwargs):
-            await asyncio.sleep(2)  # Simulate slow operation
-            return {"id": "123", "name": "Slow User"}
-
-        mock_async_repository.find_by_id.side_effect = slow_operation
-
-        # Act & Assert
-        with pytest.raises(asyncio.TimeoutError):
-            await asyncio.wait_for(
-                async_user_service.get_user_by_id("123"),
-                timeout=1.0
-            )
-```
-
-## Mocking and Fixtures
-
-### Complex Fixture Patterns
-
-```python
-# tests/conftest.py
-import pytest
-from unittest.mock import Mock, patch
-from datetime import datetime, timedelta
-from src.models.user import User
-from src.services.email_service import EmailService
-
-@pytest.fixture
-def freeze_time():
-    """Fixture to freeze time for consistent testing."""
-    frozen_time = datetime(2023, 1, 1, 12, 0, 0)
-    with patch('src.utils.datetime.datetime') as mock_datetime:
-        mock_datetime.now.return_value = frozen_time
-        mock_datetime.utcnow.return_value = frozen_time
-        yield frozen_time
-
-@pytest.fixture
-def mock_email_service():
-    """Mock email service for testing."""
-    mock = Mock(spec=EmailService)
-    mock.send_email.return_value = True
-    mock.send_bulk_email.return_value = {"sent": 5, "failed": 0}
-    return mock
-
-@pytest.fixture(params=[
-    {"name": "John Doe", "age": 30, "email": "john@example.com"},
-    {"name": "Jane Smith", "age": 25, "email": "jane@example.com"},
-])
-def user_data_variations(request):
-    """Parametrized fixture for different user data."""
-    return request.param
-
-@pytest.fixture
-def users_factory():
-    """Factory fixture for creating multiple users."""
-    def _create_users(count=3, **overrides):
-        users = []
-        for i in range(count):
-            user_data = {
-                "name": f"User {i}",
-                "email": f"user{i}@example.com",
-                "age": 20 + i,
-                **overrides
-            }
-            users.append(User(**user_data))
-        return users
-    return _create_users
-
-@pytest.fixture(scope="session")
-def test_config():
-    """Session-scoped configuration for tests."""
-    return {
-        "database_url": "sqlite:///:memory:",
-        "debug": True,
-        "testing": True,
-        "email_backend": "mock"
-    }
-```
-
-### Advanced Mocking Patterns
-
-```python
-# tests/unit/test_advanced_mocking.py
-import pytest
-from unittest.mock import Mock, patch, MagicMock, call
-from datetime import datetime
-from src.services.notification_service import NotificationService
-
-class TestAdvancedMocking:
-    """Test suite demonstrating advanced mocking patterns."""
-
-    def test_property_mocking(self):
-        """Test mocking object properties."""
-        # Arrange
-        mock_user = Mock()
-        type(mock_user).is_active = PropertyMock(return_value=True)
-
-        # Act & Assert
-        assert mock_user.is_active is True
-
-    def test_context_manager_mocking(self):
-        """Test mocking context managers."""
-        # Arrange
-        with patch('builtins.open', mock_open(read_data='file content')) as mock_file:
-            # Act
-            with open('test.txt', 'r') as f:
-                content = f.read()
-
-        # Assert
-        assert content == 'file content'
-        mock_file.assert_called_once_with('test.txt', 'r')
-
-    def test_side_effect_with_exception(self):
-        """Test using side_effect to raise exceptions."""
-        # Arrange
-        mock_service = Mock()
-        mock_service.get_user.side_effect = [
-            {"id": "1", "name": "User 1"},  # First call succeeds
-            Exception("Service unavailable"),  # Second call fails
-            {"id": "3", "name": "User 3"},  # Third call succeeds
-        ]
-
-        # Act & Assert
-        result1 = mock_service.get_user("1")
-        assert result1["name"] == "User 1"
-
-        with pytest.raises(Exception, match="Service unavailable"):
-            mock_service.get_user("2")
-
-        result3 = mock_service.get_user("3")
-        assert result3["name"] == "User 3"
-
-    def test_mock_chain_calls(self):
-        """Test mocking chained method calls."""
-        # Arrange
-        mock_database = Mock()
-        mock_database.users.filter.return_value.order_by.return_value.limit.return_value = [
-            {"id": "1", "name": "User 1"}
-        ]
-
-        # Act
-        result = mock_database.users.filter(active=True).order_by('name').limit(10)
-
-        # Assert
-        assert len(result) == 1
-        assert result[0]["name"] == "User 1"
-
-    @patch('src.services.notification_service.EmailService')
-    @patch('src.services.notification_service.SMSService')
-    def test_multiple_patches(self, mock_sms_service, mock_email_service):
-        """Test using multiple patches."""
-        # Arrange
-        notification_service = NotificationService()
-        mock_email_service.return_value.send.return_value = True
-        mock_sms_service.return_value.send.return_value = True
-
-        # Act
-        result = notification_service.send_notification(
-            "user@example.com",
-            "Test message",
-            channels=["email", "sms"]
-        )
-
-        # Assert
-        assert result is True
-        mock_email_service.return_value.send.assert_called_once()
-        mock_sms_service.return_value.send.assert_called_once()
-```
-
-## Performance and Load Testing
-
-### Performance Testing with pytest-benchmark
-
-```python
-# tests/performance/test_user_performance.py
-import pytest
-from src.services.user_service import UserService
-from src.utils.data_processor import DataProcessor
-
-class TestUserServicePerformance:
-    """Performance tests for user service operations."""
-
-    @pytest.fixture
-    def large_user_dataset(self):
-        """Generate large dataset for performance testing."""
-        return [
-            {"name": f"User {i}", "email": f"user{i}@example.com", "age": 20 + (i % 50)}
-            for i in range(1000)
-        ]
-
-    def test_user_creation_performance(self, benchmark, user_service, large_user_dataset):
-        """Benchmark user creation performance."""
-        # Act & Assert
-        result = benchmark(user_service.create_bulk_users, large_user_dataset)
-        assert len(result) == 1000
-
-    def test_user_search_performance(self, benchmark, user_service):
-        """Benchmark user search performance."""
-        # Arrange
-        # Assume users are already created in database
-
-        # Act & Assert
-        result = benchmark(user_service.search_users, query="User", limit=100)
-        assert len(result) <= 100
-
-    @pytest.mark.parametrize("batch_size", [100, 500, 1000])
-    def test_batch_processing_performance(self, benchmark, batch_size):
-        """Test performance with different batch sizes."""
-        # Arrange
-        processor = DataProcessor(batch_size=batch_size)
-        data = list(range(10000))
-
-        # Act & Assert
-        result = benchmark(processor.process_batch, data)
-        assert len(result) == 10000
-```