theus-cli-linux-arm64 1.2.1 → 1.3.0

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

@@ -1,735 +0,0 @@
----
-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