El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia

HOME

Las pruebas son una parte esencial del desarrollo de software, ya que aseguran que el código funcione como se espera y que los cambios futuros no introduzcan errores. Django proporciona un marco de pruebas robusto que facilita la creación y ejecución de pruebas para tu aplicación.

Introducción a las Pruebas en Django

¿Por qué son importantes las pruebas?

Confiabilidad: Aseguran que el código funcione correctamente.
Mantenimiento: Facilitan la detección de errores cuando se realizan cambios.
Documentación: Actúan como documentación viva del comportamiento del código.

Tipos de pruebas en Django

Pruebas Unitarias: Prueban funciones o métodos individuales.
Pruebas de Integración: Verifican que diferentes partes del sistema funcionen juntas.
Pruebas Funcionales: Simulan el comportamiento del usuario para probar la aplicación completa.

Configuración del Entorno de Pruebas

Django utiliza el módulo unittest de Python para las pruebas. Para comenzar, asegúrate de que tu entorno esté configurado correctamente.

Configuración básica

Crear un archivo de pruebas: Por convención, las pruebas se colocan en un archivo llamado tests.py dentro de cada aplicación.

Estructura básica de una prueba:

from django.test import TestCase

class SimpleTest(TestCase):
    def test_basic_addition(self):
        self.assertEqual(1 + 1, 2)

Ejecutar pruebas

Para ejecutar todas las pruebas de tu proyecto, usa el siguiente comando:

python manage.py test

Pruebas Unitarias

Las pruebas unitarias se centran en probar funciones o métodos individuales.

Ejemplo de prueba unitaria

Supongamos que tenemos una función en utils.py que suma dos números:

# utils.py
def add(a, b):
    return a + b

Podemos escribir una prueba unitaria para esta función:

# tests.py
from django.test import TestCase
from .utils import add

class UtilsTest(TestCase):
    def test_add(self):
        self.assertEqual(add(1, 2), 3)
        self.assertEqual(add(-1, 1), 0)

Pruebas de Modelos

Las pruebas de modelos verifican que los modelos de Django funcionen correctamente.

Ejemplo de prueba de modelo

Supongamos que tenemos el siguiente modelo:

# models.py
from django.db import models

class Item(models.Model):
    name = models.CharField(max_length=100)
    price = models.DecimalField(max_digits=10, decimal_places=2)

Podemos escribir una prueba para este modelo:

# tests.py
from django.test import TestCase
from .models import Item

class ItemModelTest(TestCase):
    def test_create_item(self):
        item = Item.objects.create(name="Test Item", price=10.00)
        self.assertEqual(item.name, "Test Item")
        self.assertEqual(item.price, 10.00)

Pruebas de Vistas

Las pruebas de vistas verifican que las vistas de Django funcionen correctamente.

Ejemplo de prueba de vista

Supongamos que tenemos la siguiente vista:

# views.py
from django.http import HttpResponse

def index(request):
    return HttpResponse("Hello, world!")

Podemos escribir una prueba para esta vista:

# tests.py
from django.test import TestCase
from django.urls import reverse

class IndexViewTest(TestCase):
    def test_index_view(self):
        response = self.client.get(reverse('index'))
        self.assertEqual(response.status_code, 200)
        self.assertContains(response, "Hello, world!")

Pruebas de Formularios

Las pruebas de formularios verifican que los formularios de Django funcionen correctamente.

Ejemplo de prueba de formulario

Supongamos que tenemos el siguiente formulario:

# forms.py
from django import forms

class ItemForm(forms.Form):
    name = forms.CharField(max_length=100)
    price = forms.DecimalField(max_digits=10, decimal_places=2)

Podemos escribir una prueba para este formulario:

# tests.py
from django.test import TestCase
from .forms import ItemForm

class ItemFormTest(TestCase):
    def test_valid_form(self):
        form_data = {'name': 'Test Item', 'price': 10.00}
        form = ItemForm(data=form_data)
        self.assertTrue(form.is_valid())

    def test_invalid_form(self):
        form_data = {'name': '', 'price': 10.00}
        form = ItemForm(data=form_data)
        self.assertFalse(form.is_valid())

Pruebas de Integración

Las pruebas de integración verifican que diferentes partes del sistema funcionen juntas.

Ejemplo de prueba de integración

Podemos escribir una prueba que verifique la creación de un objeto a través de una vista:

# tests.py
from django.test import TestCase
from django.urls import reverse
from .models import Item

class ItemIntegrationTest(TestCase):
    def test_create_item_view(self):
        response = self.client.post(reverse('create_item'), {'name': 'Test Item', 'price': 10.00})
        self.assertEqual(response.status_code, 302)  # Redirección después de la creación
        self.assertTrue(Item.objects.filter(name='Test Item').exists())

Pruebas Funcionales

Las pruebas funcionales simulan el comportamiento del usuario para probar la aplicación completa.

Ejemplo de prueba funcional

Podemos usar Selenium para escribir una prueba funcional:

# tests.py
from django.test import LiveServerTestCase
from selenium import webdriver

class FunctionalTest(LiveServerTestCase):
    def setUp(self):
        self.browser = webdriver.Firefox()

    def tearDown(self):
        self.browser.quit()

    def test_home_page(self):
        self.browser.get(self.live_server_url)
        self.assertIn("Welcome", self.browser.title)

Conclusión

Las pruebas son una parte crucial del desarrollo de software y Django proporciona herramientas poderosas para facilitar la creación y ejecución de pruebas. En este módulo, hemos cubierto los conceptos básicos de las pruebas en Django, incluyendo pruebas unitarias, de modelos, de vistas, de formularios, de integración y funcionales. Con esta base, estarás mejor preparado para asegurar la calidad y confiabilidad de tu aplicación Django.

Ejercicio Práctico

Ejercicio: Escribe una prueba para una vista que crea un nuevo usuario y verifica que el usuario se ha creado correctamente en la base de datos.

Solución:

# views.py
from django.shortcuts import render, redirect
from django.contrib.auth.models import User

def create_user(request):
    if request.method == 'POST':
        username = request.POST['username']
        password = request.POST['password']
        User.objects.create_user(username=username, password=password)
        return redirect('success')
    return render(request, 'create_user.html')

# tests.py
from django.test import TestCase
from django.urls import reverse
from django.contrib.auth.models import User

class CreateUserViewTest(TestCase):
    def test_create_user(self):
        response = self.client.post(reverse('create_user'), {'username': 'testuser', 'password': 'password123'})
        self.assertEqual(response.status_code, 302)  # Redirección después de la creación
        self.assertTrue(User.objects.filter(username='testuser').exists())

Con esta práctica, habrás reforzado tu comprensión sobre cómo escribir y ejecutar pruebas en Django, asegurando que tu aplicación sea robusta y confiable.

Pruebas en Django