metacoding 1.0.0 → 1.1.1

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

@@ -0,0 +1,1074 @@
+---
+description: 'Python-specific testing patterns and frameworks (pytest, Django, FastAPI)'
+applyTo: 'test/**/*.py,tests/**/*.py,**/test_*.py'
+language: 'python'
+---
+
+# 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
+```