theus-cli-linux-x64 0.2.84

package/vendor/theus-arsenal/skills/tdd-django/SKILL.md

@@ -0,0 +1,735 @@
+---
+name: tdd-django
+description: Estrategias de testing en Django con pytest-django, metodología TDD, factory_boy, mocking, cobertura y testing de API de Django REST Framework.
+---
+
+# Testing en Django con TDD
+
+Desarrollo guiado por tests (TDD) para aplicaciones Django usando pytest, factory_boy y Django REST Framework.
+
+## Cuándo activarla
+
+- Escribir nuevas aplicaciones Django
+- Implementar API con Django REST Framework
+- Testear modelos, vistas y serializers de Django
+- Montar la infraestructura de testing de un proyecto Django
+
+## Flujo TDD para Django
+
+### Ciclo Rojo-Verde-Refactor
+
+```python
+# Paso 1: ROJO - escribe un test que falle
+def test_creacion_de_usuario():
+    user = User.objects.create_user(email='test@example.com', password='testpass123')
+    assert user.email == 'test@example.com'
+    assert user.check_password('testpass123')
+    assert not user.is_staff
+
+# Paso 2: VERDE - haz que el test pase
+# Crea el modelo User o la factory
+
+# Paso 3: REFACTOR - mejora manteniendo los tests en verde
+```
+
+## Configuración
+
+### Configuración de pytest
+
+```ini
+# pytest.ini
+[pytest]
+DJANGO_SETTINGS_MODULE = config.settings.test
+testpaths = tests
+python_files = test_*.py
+python_classes = Test*
+python_functions = test_*
+addopts =
+    --reuse-db
+    --nomigrations
+    --cov=apps
+    --cov-report=html
+    --cov-report=term-missing
+    --strict-markers
+markers =
+    slow: marca tests lentos
+    integration: marca tests de integración
+```
+
+### Settings de test
+
+```python
+# config/settings/test.py
+from .base import *
+
+DEBUG = True
+DATABASES = {
+    'default': {
+        'ENGINE': 'django.db.backends.sqlite3',
+        'NAME': ':memory:',
+    }
+}
+
+# Desactiva las migraciones para acelerar
+class DisableMigrations:
+    def __contains__(self, item):
+        return True
+
+    def __getitem__(self, item):
+        return None
+
+MIGRATION_MODULES = DisableMigrations()
+
+# Hashing de contraseñas más rápido
+PASSWORD_HASHERS = [
+    'django.contrib.auth.hashers.MD5PasswordHasher',
+]
+
+# Backend de correo
+EMAIL_BACKEND = 'django.core.mail.backends.console.EmailBackend'
+
+# Celery siempre eager
+CELERY_TASK_ALWAYS_EAGER = True
+CELERY_TASK_EAGER_PROPAGATES = True
+```
+
+### conftest.py
+
+```python
+# tests/conftest.py
+import pytest
+from django.utils import timezone
+from django.contrib.auth import get_user_model
+
+User = get_user_model()
+
+@pytest.fixture(autouse=True)
+def timezone_settings(settings):
+    """Garantiza una zona horaria consistente."""
+    settings.TIME_ZONE = 'UTC'
+
+@pytest.fixture
+def user(db):
+    """Crea un usuario de prueba."""
+    return User.objects.create_user(
+        email='test@example.com',
+        password='testpass123',
+        username='testuser'
+    )
+
+@pytest.fixture
+def admin_user(db):
+    """Crea un usuario administrador."""
+    return User.objects.create_superuser(
+        email='admin@example.com',
+        password='adminpass123',
+        username='admin'
+    )
+
+@pytest.fixture
+def authenticated_client(client, user):
+    """Devuelve un cliente autenticado."""
+    client.force_login(user)
+    return client
+
+@pytest.fixture
+def api_client():
+    """Devuelve el cliente de API de DRF."""
+    from rest_framework.test import APIClient
+    return APIClient()
+
+@pytest.fixture
+def authenticated_api_client(api_client, user):
+    """Devuelve un cliente de API autenticado."""
+    api_client.force_authenticate(user=user)
+    return api_client
+```
+
+## Factory Boy
+
+### Definición de factories
+
+```python
+# tests/factories.py
+import factory
+from factory import fuzzy
+from datetime import datetime, timedelta
+from django.contrib.auth import get_user_model
+from apps.products.models import Product, Category
+
+User = get_user_model()
+
+class UserFactory(factory.django.DjangoModelFactory):
+    """Factory del modelo User."""
+
+    class Meta:
+        model = User
+
+    email = factory.Sequence(lambda n: f"user{n}@example.com")
+    username = factory.Sequence(lambda n: f"user{n}")
+    password = factory.PostGenerationMethodCall('set_password', 'testpass123')
+    first_name = factory.Faker('first_name')
+    last_name = factory.Faker('last_name')
+    is_active = True
+
+class CategoryFactory(factory.django.DjangoModelFactory):
+    """Factory del modelo Category."""
+
+    class Meta:
+        model = Category
+
+    name = factory.Faker('word')
+    slug = factory.LazyAttribute(lambda obj: obj.name.lower())
+    description = factory.Faker('text')
+
+class ProductFactory(factory.django.DjangoModelFactory):
+    """Factory del modelo Product."""
+
+    class Meta:
+        model = Product
+
+    name = factory.Faker('sentence', nb_words=3)
+    slug = factory.LazyAttribute(lambda obj: obj.name.lower().replace(' ', '-'))
+    description = factory.Faker('text')
+    price = fuzzy.FuzzyDecimal(10.00, 1000.00, 2)
+    stock = fuzzy.FuzzyInteger(0, 100)
+    is_active = True
+    category = factory.SubFactory(CategoryFactory)
+    created_by = factory.SubFactory(UserFactory)
+
+    @factory.post_generation
+    def tags(self, create, extracted, **kwargs):
+        """Añade tags al producto."""
+        if not create:
+            return
+        if extracted:
+            for tag in extracted:
+                self.tags.add(tag)
+```
+
+### Uso de factories
+
+```python
+# tests/test_models.py
+import pytest
+from tests.factories import ProductFactory, UserFactory
+
+def test_creacion_producto():
+    """Prueba la creación de un producto con la factory."""
+    product = ProductFactory(price=100.00, stock=50)
+    assert product.price == 100.00
+    assert product.stock == 50
+    assert product.is_active is True
+
+def test_producto_con_tags():
+    """Prueba un producto con tags."""
+    tags = [TagFactory(name='electronics'), TagFactory(name='new')]
+    product = ProductFactory(tags=tags)
+    assert product.tags.count() == 2
+
+def test_varios_productos():
+    """Prueba la creación de varios productos."""
+    products = ProductFactory.create_batch(10)
+    assert len(products) == 10
+```
+
+## Testing de modelos
+
+### Tests de modelos
+
+```python
+# tests/test_models.py
+import pytest
+from django.core.exceptions import ValidationError
+from tests.factories import UserFactory, ProductFactory
+
+class TestUserModel:
+    """Tests del modelo User."""
+
+    def test_crear_usuario(self, db):
+        """Prueba crear un usuario regular."""
+        user = UserFactory(email='test@example.com')
+        assert user.email == 'test@example.com'
+        assert user.check_password('testpass123')
+        assert not user.is_staff
+        assert not user.is_superuser
+
+    def test_crear_superusuario(self, db):
+        """Prueba crear un superusuario."""
+        user = UserFactory(
+            email='admin@example.com',
+            is_staff=True,
+            is_superuser=True
+        )
+        assert user.is_staff
+        assert user.is_superuser
+
+    def test_representacion_str(self, db):
+        """Prueba la representación en string del usuario."""
+        user = UserFactory(email='test@example.com')
+        assert str(user) == 'test@example.com'
+
+class TestProductModel:
+    """Tests del modelo Product."""
+
+    def test_creacion_producto(self, db):
+        """Prueba la creación de un producto."""
+        product = ProductFactory()
+        assert product.id is not None
+        assert product.is_active is True
+        assert product.created_at is not None
+
+    def test_generacion_slug(self, db):
+        """Prueba la generación automática del slug."""
+        product = ProductFactory(name='Test Product')
+        assert product.slug == 'test-product'
+
+    def test_validacion_precio(self, db):
+        """El precio no puede ser negativo."""
+        product = ProductFactory(price=-10)
+        with pytest.raises(ValidationError):
+            product.full_clean()
+
+    def test_manager_active(self, db):
+        """Prueba el método active del manager."""
+        ProductFactory.create_batch(5, is_active=True)
+        ProductFactory.create_batch(3, is_active=False)
+
+        active_count = Product.objects.active().count()
+        assert active_count == 5
+
+    def test_gestion_de_stock(self, db):
+        """Prueba la gestión de stock."""
+        product = ProductFactory(stock=10)
+        product.reduce_stock(5)
+        product.refresh_from_db()
+        assert product.stock == 5
+
+        with pytest.raises(ValueError):
+            product.reduce_stock(10)  # Stock insuficiente
+```
+
+## Testing de vistas
+
+### Tests de vistas Django
+
+```python
+# tests/test_views.py
+import pytest
+from django.urls import reverse
+from tests.factories import ProductFactory, UserFactory
+
+class TestProductViews:
+    """Tests de las vistas de productos."""
+
+    def test_lista_productos(self, client, db):
+        """Prueba la vista de listado de productos."""
+        ProductFactory.create_batch(10)
+
+        response = client.get(reverse('products:list'))
+
+        assert response.status_code == 200
+        assert len(response.context['products']) == 10
+
+    def test_detalle_producto(self, client, db):
+        """Prueba la vista de detalle de producto."""
+        product = ProductFactory()
+
+        response = client.get(reverse('products:detail', kwargs={'slug': product.slug}))
+
+        assert response.status_code == 200
+        assert response.context['product'] == product
+
+    def test_crear_producto_requiere_login(self, client, db):
+        """La creación de producto exige autenticación."""
+        response = client.get(reverse('products:create'))
+
+        assert response.status_code == 302
+        assert response.url.startswith('/accounts/login/')
+
+    def test_crear_producto_autenticado(self, authenticated_client, db):
+        """Prueba la creación de producto como usuario autenticado."""
+        response = authenticated_client.get(reverse('products:create'))
+
+        assert response.status_code == 200
+
+    def test_crear_producto_post(self, authenticated_client, db, category):
+        """Prueba crear un producto vía POST."""
+        data = {
+            'name': 'Test Product',
+            'description': 'Un producto de prueba',
+            'price': '99.99',
+            'stock': 10,
+            'category': category.id,
+        }
+
+        response = authenticated_client.post(reverse('products:create'), data)
+
+        assert response.status_code == 302
+        assert Product.objects.filter(name='Test Product').exists()
+```
+
+## Testing de API con DRF
+
+### Testing de serializers
+
+```python
+# tests/test_serializers.py
+import pytest
+from rest_framework.exceptions import ValidationError
+from apps.products.serializers import ProductSerializer
+from tests.factories import ProductFactory
+
+class TestProductSerializer:
+    """Tests de ProductSerializer."""
+
+    def test_serializar_producto(self, db):
+        """Prueba la serialización de un producto."""
+        product = ProductFactory()
+        serializer = ProductSerializer(product)
+
+        data = serializer.data
+
+        assert data['id'] == product.id
+        assert data['name'] == product.name
+        assert data['price'] == str(product.price)
+
+    def test_deserializar_producto(self, db):
+        """Prueba la deserialización de datos de producto."""
+        data = {
+            'name': 'Test Product',
+            'description': 'Descripción de prueba',
+            'price': '99.99',
+            'stock': 10,
+            'category': 1,
+        }
+
+        serializer = ProductSerializer(data=data)
+
+        assert serializer.is_valid()
+        product = serializer.save()
+
+        assert product.name == 'Test Product'
+        assert float(product.price) == 99.99
+
+    def test_validacion_precio(self, db):
+        """Prueba la validación del precio."""
+        data = {
+            'name': 'Test Product',
+            'price': '-10.00',
+            'stock': 10,
+        }
+
+        serializer = ProductSerializer(data=data)
+
+        assert not serializer.is_valid()
+        assert 'price' in serializer.errors
+
+    def test_validacion_stock(self, db):
+        """El stock no puede ser negativo."""
+        data = {
+            'name': 'Test Product',
+            'price': '99.99',
+            'stock': -5,
+        }
+
+        serializer = ProductSerializer(data=data)
+
+        assert not serializer.is_valid()
+        assert 'stock' in serializer.errors
+```
+
+### Testing de ViewSets de API
+
+```python
+# tests/test_api.py
+import pytest
+from rest_framework.test import APIClient
+from rest_framework import status
+from django.urls import reverse
+from tests.factories import ProductFactory, UserFactory
+
+class TestProductAPI:
+    """Tests de los endpoints de la API de productos."""
+
+    @pytest.fixture
+    def api_client(self):
+        """Devuelve el cliente de API."""
+        return APIClient()
+
+    def test_listar_productos(self, api_client, db):
+        """Prueba el listado de productos."""
+        ProductFactory.create_batch(10)
+
+        url = reverse('api:product-list')
+        response = api_client.get(url)
+
+        assert response.status_code == status.HTTP_200_OK
+        assert response.data['count'] == 10
+
+    def test_obtener_producto(self, api_client, db):
+        """Prueba la obtención de un producto."""
+        product = ProductFactory()
+
+        url = reverse('api:product-detail', kwargs={'pk': product.id})
+        response = api_client.get(url)
+
+        assert response.status_code == status.HTTP_200_OK
+        assert response.data['id'] == product.id
+
+    def test_crear_producto_sin_autenticar(self, api_client, db):
+        """Prueba crear un producto sin autenticación."""
+        url = reverse('api:product-list')
+        data = {'name': 'Test Product', 'price': '99.99'}
+
+        response = api_client.post(url, data)
+
+        assert response.status_code == status.HTTP_401_UNAUTHORIZED
+
+    def test_crear_producto_autenticado(self, authenticated_api_client, db):
+        """Prueba crear un producto como usuario autenticado."""
+        url = reverse('api:product-list')
+        data = {
+            'name': 'Test Product',
+            'description': 'Test',
+            'price': '99.99',
+            'stock': 10,
+        }
+
+        response = authenticated_api_client.post(url, data)
+
+        assert response.status_code == status.HTTP_201_CREATED
+        assert response.data['name'] == 'Test Product'
+
+    def test_actualizar_producto(self, authenticated_api_client, db):
+        """Prueba la actualización de un producto."""
+        product = ProductFactory(created_by=authenticated_api_client.user)
+
+        url = reverse('api:product-detail', kwargs={'pk': product.id})
+        data = {'name': 'Updated Product'}
+
+        response = authenticated_api_client.patch(url, data)
+
+        assert response.status_code == status.HTTP_200_OK
+        assert response.data['name'] == 'Updated Product'
+
+    def test_eliminar_producto(self, authenticated_api_client, db):
+        """Prueba la eliminación de un producto."""
+        product = ProductFactory(created_by=authenticated_api_client.user)
+
+        url = reverse('api:product-detail', kwargs={'pk': product.id})
+        response = authenticated_api_client.delete(url)
+
+        assert response.status_code == status.HTTP_204_NO_CONTENT
+
+    def test_filtrar_productos_por_precio(self, api_client, db):
+        """Prueba el filtrado de productos por precio."""
+        ProductFactory(price=50)
+        ProductFactory(price=150)
+
+        url = reverse('api:product-list')
+        response = api_client.get(url, {'price_min': 100})
+
+        assert response.status_code == status.HTTP_200_OK
+        assert response.data['count'] == 1
+
+    def test_buscar_productos(self, api_client, db):
+        """Prueba la búsqueda de productos."""
+        ProductFactory(name='Apple iPhone')
+        ProductFactory(name='Samsung Galaxy')
+
+        url = reverse('api:product-list')
+        response = api_client.get(url, {'search': 'Apple'})
+
+        assert response.status_code == status.HTTP_200_OK
+        assert response.data['count'] == 1
+```
+
+## Mocking y patching
+
+### Mocking de servicios externos
+
+```python
+# tests/test_views.py
+from unittest.mock import patch, Mock
+import pytest
+
+class TestPaymentView:
+    """Tests de la vista de pagos con pasarela simulada."""
+
+    @patch('apps.payments.services.stripe')
+    def test_pago_exitoso(self, mock_stripe, client, user, product):
+        """Prueba un pago exitoso con Stripe simulado."""
+        # Configura el mock
+        mock_stripe.Charge.create.return_value = {
+            'id': 'ch_123',
+            'status': 'succeeded',
+            'amount': 9999,
+        }
+
+        client.force_login(user)
+        response = client.post(reverse('payments:process'), {
+            'product_id': product.id,
+            'token': 'tok_visa',
+        })
+
+        assert response.status_code == 302
+        mock_stripe.Charge.create.assert_called_once()
+
+    @patch('apps.payments.services.stripe')
+    def test_pago_fallido(self, mock_stripe, client, user, product):
+        """Prueba un pago fallido."""
+        mock_stripe.Charge.create.side_effect = Exception('Tarjeta rechazada')
+
+        client.force_login(user)
+        response = client.post(reverse('payments:process'), {
+            'product_id': product.id,
+            'token': 'tok_visa',
+        })
+
+        assert response.status_code == 302
+        assert 'error' in response.url
+```
+
+### Mocking del envío de correo
+
+```python
+# tests/test_email.py
+from django.core import mail
+from django.test import override_settings
+
+@override_settings(EMAIL_BACKEND='django.core.mail.backends.locmem.EmailBackend')
+def test_correo_confirmacion_pedido(db, order):
+    """Prueba el correo de confirmación del pedido."""
+    order.send_confirmation_email()
+
+    assert len(mail.outbox) == 1
+    assert order.user.email in mail.outbox[0].to
+    assert 'Order Confirmation' in mail.outbox[0].subject
+```
+
+## Testing de integración
+
+### Testing de flujo completo
+
+```python
+# tests/test_integration.py
+import pytest
+from django.urls import reverse
+from tests.factories import UserFactory, ProductFactory
+
+class TestCheckoutFlow:
+    """Prueba el flujo completo de checkout."""
+
+    def test_flujo_de_invitado_a_compra(self, client, db):
+        """Prueba el flujo completo de invitado a compra."""
+        # Paso 1: registro
+        response = client.post(reverse('users:register'), {
+            'email': 'test@example.com',
+            'password': 'testpass123',
+            'password_confirm': 'testpass123',
+        })
+        assert response.status_code == 302
+
+        # Paso 2: login
+        response = client.post(reverse('users:login'), {
+            'email': 'test@example.com',
+            'password': 'testpass123',
+        })
+        assert response.status_code == 302
+
+        # Paso 3: navegar productos
+        product = ProductFactory(price=100)
+        response = client.get(reverse('products:detail', kwargs={'slug': product.slug}))
+        assert response.status_code == 200
+
+        # Paso 4: añadir al carrito
+        response = client.post(reverse('cart:add'), {
+            'product_id': product.id,
+            'quantity': 1,
+        })
+        assert response.status_code == 302
+
+        # Paso 5: checkout
+        response = client.get(reverse('checkout:review'))
+        assert response.status_code == 200
+        assert product.name in response.content.decode()
+
+        # Paso 6: completar la compra
+        with patch('apps.checkout.services.process_payment') as mock_payment:
+            mock_payment.return_value = True
+            response = client.post(reverse('checkout:complete'))
+
+        assert response.status_code == 302
+        assert Order.objects.filter(user__email='test@example.com').exists()
+```
+
+## Buenas prácticas de testing
+
+### SÍ
+
+- **Usa factories**: en lugar de crear objetos manualmente
+- **Una aserción por test**: mantén los tests enfocados
+- **Nombres descriptivos**: `test_usuario_no_puede_borrar_posts_ajenos`
+- **Prueba casos límite**: entradas vacías, valores None, condiciones de frontera
+- **Simula servicios externos**: no dependas de API externas
+- **Usa fixtures**: elimina duplicación
+- **Prueba los permisos**: verifica que la autorización funciona
+- **Mantén los tests rápidos**: usa `--reuse-db` y `--nomigrations`
+
+### NO
+
+- **No testees los internos de Django**: confía en que Django funciona
+- **No testees código de terceros**: confía en las librerías
+- **No ignores tests que fallan**: todos deben pasar
+- **No hagas tests dependientes**: deben poder ejecutarse en cualquier orden
+- **No abuses de los mocks**: simula solo dependencias externas
+- **No testees métodos privados**: prueba la interfaz pública
+- **No uses la base de datos de producción**: siempre la de test
+
+## Cobertura
+
+### Configuración de cobertura
+
+```bash
+# Ejecutar tests con cobertura
+pytest --cov=apps --cov-report=html --cov-report=term-missing
+
+# Generar el reporte HTML
+open htmlcov/index.html
+```
+
+### Metas de cobertura
+
+| Componente | Cobertura objetivo |
+|------------|--------------------|
+| Modelos | 90%+ |
+| Serializers | 85%+ |
+| Vistas | 80%+ |
+| Servicios | 90%+ |
+| Utilidades | 80%+ |
+| Global | 80%+ |
+
+## Referencia rápida
+
+| Patrón | Uso |
+|--------|-----|
+| `@pytest.mark.django_db` | Habilita el acceso a la base de datos |
+| `client` | Cliente de test de Django |
+| `api_client` | Cliente de API de DRF |
+| `factory.create_batch(n)` | Crea varios objetos |
+| `patch('modulo.funcion')` | Simula dependencias externas |
+| `override_settings` | Cambia settings temporalmente |
+| `force_authenticate()` | Evita la autenticación en tests |
+| `assertRedirects` | Verifica redirecciones |
+| `assertTemplateUsed` | Verifica el uso de la plantilla |
+| `mail.outbox` | Revisa los correos enviados |
+
+Recuerda: los tests son documentación. Un buen test explica cómo debería funcionar tu código. Mantenlos simples, legibles y mantenibles.
+
+## Skills relacionadas
+
+- `patrones-django` — Arquitectura y estructura de proyecto
+- `patrones-django-celery` — Testing de tareas asíncronas
+- `flujo-tdd` — Metodología TDD general
+- `testing-python` — Configuración de pytest y fixtures