¡Hola, compañeros desarrolladores! Hoy, nos sumergimos en el mundo de las pruebas unitarias con FastAPI. Tanto si eres un profesional experimentado como si eres nuevo en FastAPI, esta guía te ayudará a asegurar que tu API sea lo más robusta posible. Cubriremos todo, desde los conceptos básicos de las pruebas unitarias hasta técnicas específicas para probar aplicaciones FastAPI. Además, te presentaremos una herramienta útil llamada Apidog que puede agilizar tu proceso de pruebas.
Por qué las pruebas unitarias son importantes
Antes de sumergirnos en los detalles de las pruebas unitarias de FastAPI, hablemos de por qué las pruebas unitarias son esenciales. En términos simples, las pruebas unitarias te permiten verificar que cada parte de tu aplicación funciona según lo previsto. Al probar componentes individuales, puedes detectar errores de forma temprana y asegurar que tu aplicación se comporte correctamente.
Aquí hay algunas razones convincentes para adoptar las pruebas unitarias:
- Detectar errores de forma temprana: Al probar pequeñas unidades de código, puedes identificar y solucionar problemas antes de que se conviertan en problemas importantes.
- Asegurar la calidad del código: Las pruebas unitarias actúan como una red de seguridad, ayudándote a mantener un código de alta calidad a medida que evoluciona tu proyecto.
- Facilitar la refactorización: Con un conjunto sólido de pruebas, puedes refactorizar tu código con confianza, sabiendo que cualquier problema se detectará de inmediato.
- Mejorar la documentación: Las pruebas sirven como documentación adicional, mostrando cómo se supone que deben funcionar las diferentes partes de tu aplicación.
Ahora que entendemos la importancia de las pruebas unitarias, sumergámonos en los detalles de las pruebas unitarias con FastAPI.
Configurando tu proyecto FastAPI
Lo primero es lo primero, necesitas tener un proyecto FastAPI configurado. Si aún no lo has hecho, puedes crear un nuevo proyecto FastAPI siguiendo estos pasos:
Instala FastAPI y Uvicorn: FastAPI es el framework web, y Uvicorn es el servidor ASGI.
pip install fastapi uvicorn
Crea tu aplicación FastAPI: Crea un archivo llamado main.py y añade el siguiente código:
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
def read_root():
return {"Hello": "World"}
Ejecuta tu aplicación: Inicia el servidor usando Uvicorn.
uvicorn main:app --reload
¡Tu aplicación FastAPI ahora está en funcionamiento!
Empezando con las pruebas unitarias
Instalando las dependencias de prueba
Para empezar con las pruebas unitarias, necesitarás un framework de pruebas. Recomendamos usar pytest porque es fácil de usar y ampliamente adoptado.
Instala pytest usando pip:
pip install pytest
Además, instala httpx para hacer peticiones HTTP a tu aplicación FastAPI durante las pruebas:
pip install httpx
Escribiendo tu primera prueba
Escribamos una prueba simple para verificar que nuestro endpoint raíz devuelve la respuesta esperada. Crea un archivo llamado test_main.py y añade el siguiente código:
from fastapi.testclient import TestClient
from main import app
client = TestClient(app)
def test_read_root():
response = client.get("/")
assert response.status_code == 200
assert response.json() == {"Hello": "World"}
En esta prueba, usamos TestClient de FastAPI para enviar una petición GET al endpoint raíz y afirmamos que la respuesta es correcta. Ejecuta la prueba usando pytest:
pytest
Estructurando tus pruebas
Para mantener tus pruebas organizadas, considera la siguiente estructura para tus archivos de prueba:
project/
├── app/
│ ├── main.py
│ └── ... (otro código de la aplicación)
├── tests/
│ ├── __init__.py
│ └── test_main.py
Al colocar tus pruebas en un directorio tests dedicado, puedes mantener una base de código limpia y organizada.
Técnicas avanzadas de pruebas unitarias
Probando endpoints con parámetros
FastAPI facilita el manejo de parámetros en tus endpoints. Añadamos un endpoint que tome un parámetro y escribamos una prueba para él.
Actualiza tu main.py con un nuevo endpoint:
@app.get("/items/{item_id}")
def read_item(item_id: int):
return {"item_id": item_id}
A continuación, añade una prueba para este endpoint en test_main.py:
def test_read_item():
item_id = 42
response = client.get(f"/items/{item_id}")
assert response.status_code == 200
assert response.json() == {"item_id": item_id}
Esta prueba verifica que el endpoint devuelve correctamente el ID del elemento pasado en la URL.
Probando la inyección de dependencias
El sistema de inyección de dependencias de FastAPI es potente y flexible. Veamos cómo puedes probar endpoints que usan dependencias.
Añade una dependencia a main.py:
from fastapi import Depends
def get_query(q: str = None):
return q
@app.get("/search/")
def search(query: str = Depends(get_query)):
return {"query": query}
Escribe una prueba para este endpoint en test_main.py:
def test_search():
query = "fastapi"
response = client.get(f"/search/?q={query}")
assert response.status_code == 200
assert response.json() == {"query": query}
Aquí, probamos que la inyección de dependencias maneja correctamente el parámetro de consulta.
Presentamos Apidog para pruebas mejoradas
¿Qué es Apidog?
Apidog es una herramienta fantástica que simplifica las pruebas y la documentación de API. Se integra perfectamente con FastAPI, permitiéndote automatizar y agilizar tu proceso de pruebas.
Usando Apidog en tus pruebas
Apidog proporciona decoradores para documentar y probar fácilmente tus endpoints. Aquí te mostramos cómo puedes usar Apidog con tu aplicación FastAPI.
Configura tu entorno de pruebas: Lo primero es lo primero, configura tu entorno de pruebas. Esto incluye los sistemas que quieres probar y Apidog. Abre Apidog y cambia a la pestaña de pruebas.
Define tus casos de prueba: A continuación, define tus casos de prueba. Piensa en los diferentes escenarios que quieres probar y anótalos.
Ejecuta tus pruebas: ¡Ahora, es el momento de dejar que Apidog haga su magia! Ejecuta tus pruebas y espera los resultados.
Analiza tus resultados: Una vez que tus pruebas estén hechas, analiza tus resultados. Busca cualquier error o comportamiento inesperado.
Si encuentras algún problema, soluciónalo y ejecuta tus pruebas de nuevo. Repite este proceso hasta que estés satisfecho con los resultados.
Con Apidog, puedes asegurar que tus pruebas no solo sean correctas, sino también bien documentadas.
Mejores prácticas para las pruebas unitarias de FastAPI
Mantén las pruebas aisladas
Asegura que cada prueba sea independiente y no dependa del estado de otras pruebas. Este aislamiento hace que las pruebas sean más fáciles de depurar y mantener.
Usa fixtures
Los fixtures en pytest pueden ayudarte a configurar y desmontar entornos de prueba. Aquí hay un ejemplo de fixture para tu aplicación FastAPI:
import pytest
from fastapi.testclient import TestClient
from main import app
@pytest.fixture
def client():
return TestClient(app)
def test_with_fixture(client):
response = client.get("/")
assert response.status_code == 200
assert response.json() == {"Hello": "World"}
Simula dependencias externas
Cuando tus endpoints dependen de servicios externos o bases de datos, usa la simulación (mocking) para simular esas dependencias durante las pruebas. Este enfoque te ayuda a concentrarte en probar la lógica de tu aplicación sin verse afectado por factores externos.
Conclusión
Las pruebas unitarias de aplicaciones FastAPI no tienen por qué ser desalentadoras. Siguiendo los pasos descritos en esta guía, puedes asegurar que tu API sea fiable, mantenible y bien documentada. Recuerda usar herramientas como Apidog para agilizar tu proceso de pruebas y mantener tus pruebas organizadas y aisladas.
Ahora, es tu turno de poner en práctica estos consejos y hacer que tu aplicación FastAPI sea a prueba de balas. ¡Felices pruebas!
