Cómo agregar pruebas unitarias a su proyecto Django

El autor seleccionó el Open Internet/Free Speech Fund para recibir una donación como parte del programa Write for DOnations.

Introducción

Es casi imposible crear sitios web que funcionen perfectamente la primera vez sin errores. Por ese motivo, es necesario probar la aplicación web para encontrar estos errores y trabajar en ellos de forma proactiva. Para mejorar la eficiencia de las pruebas, es habitual dividirlas en unidades que prueban funcionalidades específicas de la aplicación web. Esta práctica se denomina prueba unitaria. Facilita la detección de errores porque las pruebas se centran en pequeñas partes (unidades) del proyecto independientemente de otras partes.

Probar un sitio web puede ser una tarea compleja, ya que está compuesto por varias capas de lógica, como el manejo de solicitudes HTTP, la validación de formularios y la representación de plantillas. Sin embargo, Django ofrece un conjunto de herramientas que facilitan la prueba de su aplicación web. En Django, la forma preferida de escribir pruebas es usar el unittestmódulo Python, aunque es posible usar otros marcos de prueba.

En este tutorial, configurará un conjunto de pruebas en su proyecto de Django y escribirá pruebas unitarias para los modelos y las vistas de su aplicación. Ejecutará estas pruebas, analizará sus resultados y aprenderá a encontrar las causas de las pruebas fallidas.

Prerrequisitos

Antes de comenzar este tutorial, necesitarás lo siguiente:

• Django instalado en tu servidor con un entorno de programación configurado. Para ello, puedes seguir uno de nuestros tutoriales Cómo instalar el framework web Django y configurar un entorno de programación.
• Un proyecto de Django creado con modelos y vistas. En este tutorial, hemos seguido el proyecto de nuestra serie de tutoriales de desarrollo de Django.

Paso 1: Agregar un conjunto de pruebas a su aplicación Django

Un conjunto de pruebas en Django es una colección de todos los casos de prueba en todas las aplicaciones de su proyecto. Para que la utilidad de pruebas de Django pueda descubrir los casos de prueba que tiene, debe escribir los casos de prueba en scripts cuyos nombres comiencen con test. En este paso, creará la estructura de directorios y los archivos para su conjunto de pruebas, y creará un caso de prueba vacío en él.

Si seguiste la serie de tutoriales de desarrollo de Django, tendrás una aplicación de Django llamada blogsite.

Vamos a crear una carpeta para guardar todos nuestros scripts de prueba. Primero, activamos el entorno virtual:

cd ~/my_blog_app
. env/bin/activate

Luego navegue hasta el blogsitedirectorio de la aplicación, la carpeta que contiene los models.pyarchivos views.pyy y luego cree una nueva carpeta llamada tests:

cd ~/my_blog_app/blog/blogsite
mkdir tests

A continuación, convertirá esta carpeta en un paquete de Python, así que agregue un __init__.pyarchivo:

cd ~/my_blog_app/blog/blogsite/tests
touch __init__.py

Ahora agregará un archivo para probar sus modelos y otro para probar sus vistas:

touch test_models.py
touch test_views.py

Por último, creará un caso de prueba vacío en test_models.py. Deberá importar la TestCaseclase Django y convertirla en una superclase de su propia clase de caso de prueba. Más adelante, agregará métodos a este caso de prueba para probar la lógica en sus modelos. Abra el archivo test_models.py:

nano test_models.py

Ahora agregue el siguiente código al archivo:

~/mi_aplicación_de_blog/blog/blogsite/pruebas/modelos_de_prueba.py

from django.test import TestCaseclass ModelsTestCase(TestCase):    pass

Ahora ha agregado correctamente un conjunto de pruebas a la blogsiteaplicación. A continuación, deberá completar los detalles del caso de prueba del modelo vacío que creó aquí.

Paso 2: prueba del código Python

En este paso, probará la lógica del código escrito en el models.pyarchivo. En particular, probará el savemétodo del Postmodelo para asegurarse de que crea el slug correcto del título de una publicación cuando se lo llama.

Comencemos mirando el código que ya tienes en tu models.pyarchivo para el savemétodo del Postmodelo:

cd ~/my_blog_app/blog/blogsite
nano models.py

Verás lo siguiente:

~/my_blog_app/blog/blogsite/models.py

class Post(models.Model):    ...    def save(self, *args, **kwargs):        if not self.slug:            self.slug = slugify(self.title)        super(Post, self).save(*args, **kwargs)    ...

Podemos ver que comprueba si la publicación que se va a guardar tiene un valor de slug y, si no lo tiene, realiza una llamada slugifypara crear un valor de slug para ella. Este es el tipo de lógica que quizás quieras probar para asegurarte de que se creen realmente slugs al guardar una publicación.

Cerrar el archivo.

Para probar esto, regrese a test_models.py:

nano test_models.py

Luego actualízalo de la siguiente manera, agregando las partes resaltadas:

~/mi_aplicación_de_blog/blog/blogsite/pruebas/modelos_de_prueba.py

from django.test import TestCasefrom django.template.defaultfilters import slugifyfrom blogsite.models import Postclass ModelsTestCase(TestCase):    def test_post_has_slug(self):        """Posts are given slugs correctly when saving"""        post = Post.objects.create(title="My first post")        post.author = "John Doe"        post.save()        self.assertEqual(post.slug, slugify(post.title))

Este nuevo método test_post_has_slugcrea una nueva publicación con el título "My first post"y luego le asigna un autor y la guarda. Después de esto, usando el assertEqualmétodo del unittestmódulo Python, verifica si el slug de la publicación es correcto. El assertEqualmétodo verifica si los dos argumentos que se le pasan son iguales según lo determinado por el "=="operador y genera un error si no lo son.

Guardar y salir test_models.py.

Este es un ejemplo de lo que se puede probar. Cuanta más lógica agregue a su proyecto, más habrá para probar. Si agrega más lógica al savemétodo o crea nuevos métodos para el Postmodelo, querrá agregar más pruebas aquí. Puede agregarlas al test_post_has_slugmétodo o crear nuevos métodos de prueba, pero sus nombres deben comenzar con test.

Ha creado correctamente un caso de prueba para el Postmodelo en el que ha confirmado que los slugs se crean correctamente después de guardarlos. En el siguiente paso, escribirá un caso de prueba para probar las vistas.

Paso 3: Uso del cliente de prueba de Django

En este paso, escribirá un caso de prueba que pruebe una vista utilizando el cliente de prueba de Django. El cliente de prueba es una clase de Python que actúa como un navegador web ficticio, lo que le permite probar sus vistas e interactuar con su aplicación de Django de la misma manera que lo haría un usuario. Puede acceder al cliente de prueba haciendo referencia a self.clienten sus métodos de prueba. Por ejemplo, creemos un caso de prueba en test_views.py. Primero, abra el test_views.pyarchivo:

nano test_views.py

Luego añade lo siguiente:

~/mi_aplicación_de_blog/blog/blogsite/pruebas/vistas_de_prueba.py

from django.test import TestCaseclass ViewsTestCase(TestCase):    def test_index_loads_properly(self):        """The index page loads properly"""        response = self.client.get('your_server_ip:8000')        self.assertEqual(response.status_code, 200)

El ViewsTestCasecontiene un test_index_loads_properlymétodo que utiliza el cliente de prueba de Django para visitar la página de índice del sitio web ( , donde es la dirección IP del servidor que estás utilizando). Luego, el método de prueba verifica si la respuesta tiene un código de estado de , lo que significa que la página respondió sin errores. Como resultado, puedes estar seguro de que cuando el usuario la visite, también responderá sin errores.http://your_server_ip:8000your_server_ip200

Además del código de estado, puedes leer sobre otras propiedades de la respuesta del cliente de prueba que puedes probar en la página Respuestas de prueba de la documentación de Django.

En este paso, creó un caso de prueba para comprobar que la representación de la vista de la página de índice funciona sin errores. Ahora hay dos casos de prueba en su conjunto de pruebas. En el siguiente paso, los ejecutará para ver sus resultados.

Paso 4: Ejecutar las pruebas

Ahora que ha terminado de crear un conjunto de pruebas para el proyecto, es hora de ejecutarlas y ver sus resultados. Para ejecutarlas, navegue hasta la blogcarpeta (que contiene el archivo de la aplicación manage.py):

cd ~/my_blog_app/blog

Luego ejecútalos con:

python manage.py test

Verás un resultado similar al siguiente en tu terminal:

OutputCreating test database for alias 'default'...System check identified no issues (0 silenced)...----------------------------------------------------------------------Ran 2 tests in 0.007sOKDestroying test database for alias 'default'...

En esta salida, hay dos puntos .., cada uno de los cuales representa un caso de prueba aprobado. Ahora, modificará test_views.pypara activar una prueba fallida. Primero abra el archivo con:

nano test_views.py

Luego cambie el código resaltado a:

~/mi_aplicación_de_blog/blog/blogsite/pruebas/vistas_de_prueba.py

from django.test import TestCaseclass ViewsTestCase(TestCase):    def test_index_loads_properly(self):        """The index page loads properly"""        response = self.client.get('your_server_ip:8000')        self.assertEqual(response.status_code, 404)

Aquí has ​​cambiado el código de estado de 200a 404. Ahora vuelve a ejecutar la prueba desde tu directorio con manage.py:

python manage.py test

Verás el siguiente resultado:

OutputCreating test database for alias 'default'...System check identified no issues (0 silenced)..F======================================================================FAIL: test_index_loads_properly (blogsite.tests.test_views.ViewsTestCase)The index page loads properly----------------------------------------------------------------------Traceback (most recent call last):  File "~/my_blog_app/blog/blogsite/tests/test_views.py", line 8, in test_index_loads_properly    self.assertEqual(response.status_code, 404)AssertionError: 200 != 404----------------------------------------------------------------------Ran 2 tests in 0.007sFAILED (failures=1)Destroying test database for alias 'default'...

Verá que hay un mensaje de error descriptivo que le indica el script, el caso de prueba y el método que fallaron. También le indica la causa del error, ya que el código de estado no es igual a 404en este caso, con el mensaje AssertionError: 200 != 404. El AssertionErrormensaje aquí se genera en la línea de código resaltada en el test_views.pyarchivo:

~/mi_aplicación_de_blog/blog/blogsite/pruebas/vistas_de_prueba.py

from django.test import TestCaseclass ViewsTestCase(TestCase):    def test_index_loads_properly(self):        """The index page loads properly"""        response = self.client.get('your_server_ip:8000')        self.assertEqual(response.status_code, 404)

Le indica que la afirmación es falsa, es decir, el código de estado de respuesta ( 200) no es el esperado ( 404). Antes del mensaje de error, puede ver que los dos puntos ..ahora han cambiado a .F, lo que le indica que el primer caso de prueba pasó mientras que el segundo no.

Conclusión

En este tutorial, creaste un conjunto de pruebas en tu proyecto de Django, agregaste casos de prueba para probar el modelo y la lógica de la vista, aprendiste a ejecutar pruebas y analizaste el resultado de las pruebas. Como siguiente paso, puedes crear nuevos scripts de prueba para el código Python que no está en models.pyy views.py.

A continuación se presentan algunos artículos que pueden resultar útiles al crear y probar sitios web con Django:

• La documentación de pruebas unitarias de Django
• La serie de tutoriales sobre cómo escalar Django

También puedes consultar nuestra página de temas de Django para obtener más tutoriales y proyectos.