Pruebas unitarias con FastAPI y Pytest: Configuración y Ejecución

Clase 20 de 23 • Curso de FastAPI

Contenido del curso

Introducción a FastAPI

Parámetros y Validación

CRUD en FastAPI

Arquitectura en FastAPI

12
Estructuración de Aplicaciones con FastAPI y API Router
09:37 min

Bases de Datos y Consultas

Middlewares

Unit Testing

Seguridad y Autenticación

Tomar examen

Resumen

Aprender a configurar pruebas unitarias es esencial para desarrollar aplicaciones con FastAPI. Esto asegura que tus desarrollos tengan calidad y que puedas detectar errores rápidamente, agilizando tu flujo de trabajo. FastAPI, combinado con el framework PyTest, permite escribir y ejecutar pruebas automatizadas de manera sencilla y efectiva.

¿Qué necesitas para configurar las pruebas de FastAPI?

Las pruebas en FastAPI requieren configuración local inicial y una base de datos separada específica para testing. Con esto, puedes ejecutar pruebas repetidamente sin afectar tu entorno de producción. Las herramientas principales son:

PyTest: framework especializado en pruebas unitarias.
TestClient de FastAPI: facilita simular solicitudes HTTP (GET, POST) como si las realizara un navegador.
SQLAlchemy y SQLModel: para configurar motores y sesiones de base de datos.

¿Cómo configurar el entorno local?

Para poder correr pruebas efectivamente, sigue estos pasos:

1. Crear archivo de configuración para pruebas

Crea un archivo llamado convTest.py. Aquí estarán todas las configuraciones específicas de pruebas.

2. Ajuste en motor de base de datos

No se recomienda usar la base de datos de producción para pruebas. En cambio, crea un motor específico para testing:

from sqlalchemy import create_engine
from sqlalchemy.pool import StaticPool

engine = create_engine(
    "db_testing_url",
    connect_args={"check_same_thread": False},
    poolclass=StaticPool
)

La opción check_same_thread en False evita conflictos entre distintos hilos, y StaticPool mantiene la base de datos en memoria para facilitar pruebas rápidas.

3. Manejo de tablas con fixtures de PyTest

PyTest emplea fixtures, funciones reutilizables entre diferentes pruebas. Utiliza un fixture para crear y luego eliminar tablas automáticamente:

import pytest
from sqlmodel import SQLModel, Session

@pytest.fixture(name="session")
def session_fixture():
    SQLModel.metadata.create_all(engine)
    with Session(engine) as session:
        yield session
    SQLModel.metadata.drop_all(engine)

¿Cómo sobrescribir funcionalidades para testing correctamente?

Para aislar las pruebas y usar configuraciones específicas sin afectar producción, utiliza la sobreescritura de dependencias:

from fastapi.testclient import TestClient
from app.main import app

@pytest.fixture(name="client")
def client_fixture(session: Session):
    def get_session_override():
        return session

    app.dependency_overrides[get_session] = get_session_override

    with TestClient(app) as client:
        yield client
        app.dependency_overrides.clear()

Este enfoque te permite probar endpoints especificando comportamientos únicos en ambiente controlado.

¿Cómo validar tu configuración correctamente?

Realiza una prueba simple en un archivo test.py para diagnosticar si la configuración funcionó correctamente:

from fastapi.testclient import TestClient

def test_client(client):
    assert type(client).__name__ == TestClient.__name__

Al ejecutar:

pytest app/test

PyTest te indicará con un icono verde el éxito de la configuración.

¡Comenta más abajo cualquier duda o idea que quieras compartir sobre esta configuración para pruebas!

Comentarios

Mario Alexander Vargas Celis

student•

Realizar pruebas unitarias en FastAPI utilizando Pytest y SQLAlchemy permite validar el correcto funcionamiento de tus endpoints y la lógica de negocio, garantizando que tu aplicación se comporte como se espera. A continuación, te muestro cómo configurar un entorno de pruebas con estas herramientas:

Pasos para Configurar Pruebas Unitarias en FastAPI

1. Instalación de Dependencias

Asegúrate de instalar las librerías necesarias:

pip install pytest pytest-asyncio sqlalchemy

2. Configurar la Base de Datos para Pruebas

Crea una base de datos en memoria para que tus pruebas no afecten los datos reales de producción.

from sqlalchemy import create_engine from sqlalchemy.ext.declarative import declarative_base from sqlalchemy.orm import sessionmaker

Base = declarative_base()

# Base de datos en memoria para pruebas TEST_DATABASE_URL = "sqlite:///:memory:"

engine = create_engine(TEST_DATABASE_URL, connect_args={"check_same_thread": False}) TestingSessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)

# Inicialización de la base de datos def init_test_db(): Base.metadata.create_all(bind=engine)

def drop_test_db(): Base.metadata.drop_all(bind=engine)

3. Crear un Cliente de Pruebas para FastAPI

FastAPI incluye un cliente de pruebas basado en Starlette para interactuar con la aplicación.

from fastapi.testclient import TestClient from myapp.main import app # Importa tu aplicación FastAPI

# Crea un cliente de pruebas client = TestClient(app)

4. Configuración de Sesiones de Base de Datos para Pruebas

Sobrescribe la dependencia de base de datos para que utilice la base de datos en memoria.

from fastapi import Depends from sqlalchemy.orm import Session from myapp.database import get_db # Tu dependencia real de la base de datos from myapp.models import Base

# Crea una sesión de prueba def override_get_db(): db = TestingSessionLocal() try: yield db finally: db.close()

# Sobrescribe la dependencia en tu aplicación app.dependency_overrides[get_db] = override_get_db

# Inicializa la base de datos de pruebas init_test_db()

5. Escribir Pruebas Unitarias

Crea un archivo de pruebas (por ejemplo, test_app.py) y escribe tus pruebas.

Ejemplo: Prueba de Creación de un Registro

from myapp.schemas import CustomerCreate

def test_create_customer(): # Datos de prueba data = {"name": "John Doe", "email": "johndoe@example.com"}

# Llama al endpoint para crear un cliente response = client.post("/customers/", json=data)

# Verifica el código de respuesta y los datos retornados assert response.status_code == 201 assert response.json()["name"] == data["name"] assert response.json()["email"] == data["email"]

Ejemplo: Prueba de Consulta de un Registro

def test_get_customer(): # Crea un cliente data = {"name": "Jane Doe", "email": "janedoe@example.com"} client.post("/customers/", json=data)

# Consulta el cliente creado response = client.get("/customers/1")

# Verifica que los datos sean correctos assert response.status_code == 200 assert response.json()["name"] == "Jane Doe" assert response.json()["email"] == "janedoe@example.com"

6. Ejecutar las Pruebas

Ejecuta las pruebas con Pytest desde la línea de comandos:

pytest -v

Prácticas Recomendadas

Usa Fixtures de Pytest: Define datos o configuraciones comunes que puedan reutilizarse entre múltiples pruebas.import pytest

@pytest.fixture def test_client(): init_test_db() yield client drop_test_db()
Aislar Pruebas: Asegúrate de que cada prueba se ejecute de manera independiente, sin depender del estado de otras pruebas.
Validar Errores: Además de probar casos exitosos, incluye pruebas para errores esperados (por ejemplo, registro no encontrado).
Limpiar la Base de Datos: Si no usas una base en memoria, asegúrate de limpiar los datos después de cada prueba.

Conclusión

Este enfoque asegura que tus endpoints en FastAPI sean robustos y se comporten correctamente. Puedes extender este modelo para probar funcionalidades más avanzadas, como autenticación, relaciones de modelos, y manejo de excepciones.

Rulfo Quintero

student•

Profe, con todo el respeto, cariño y admiración, una observación

Palabra: engine

no -en-yai-n-,

se dice en-gin (ˈenjən)

si tienen dudas de pronunciacion, siempre pueden pedirle a google translate que les hable para escuchar y aprender. Nunca pares de aprender.

Bryan Castano

student•

Tambien se pronuncia .py -> [pai] o si no quiere sonar 'English' .pi, llevo todo el curso atrofiado con eso de '.peye', suena tan feo y absurdo , especialmente si estas en Colombia, ["punto peye"]. Guido Van Rossum llora cada vez que alguien pronuncia asi la extencion .py.

José Fabián Beltrán Meza

student•

En esta clase si debo decir que quede más perdido que la mama del Chavo.

Juan Camilo Grisales Arias

student•

También pueden usar este código en conftest.py para que no se cree un archivo sqlite sino que para los tests se use una base de datos únicamente en memoria temporal:

import pytest
from fastapi.testclient import TestClient
from sqlmodel import Session, SQLModel, create_engine
from sqlmodel.pool import StaticPool

from app.db import get_session
from app.main import app


@pytest.fixture(name="session")
def session_fixture():
    engine = create_engine(
        "sqlite://", connect_args={"check_same_thread": False}, poolclass=StaticPool
    )
    SQLModel.metadata.create_all(engine)
    with Session(engine) as session:
        yield session


@pytest.fixture(name="client")
def client_fixture(session: Session):
    def get_session_override():
        return session

    app.dependency_overrides[get_session] = get_session_override
    client = TestClient(app)
    yield client
    app.dependency_overrides.clear()

Samuel Steven Bernal Martínez

student•

Woa iba bien el curso hasta aqui, muchos conceptos de golpe para un curso básico creo, se me ha complicado entender todo

Gregorio Torrejano Munevar

student•

confirmo.

Ernesto Jose Gomez Flores

student•

reto:

#test para crear un customer
def test_create_customer(client):
    response = client.post("/customers/", json={
        "name": "John Doe",
        "description": "This is a test customer",
        "email": "prueba@prueba.com",
        "age": 30
    })
    assert response.status_code == 200
    assert response.json()

Luis Martinez

teacher•

Buena solución, sigue revisando los asserts que tenemos disponibles!

Andrés González

student•

En esta clase tuve un error que me demoré un poco en detectar por si a alguien le pasa. en la siguiente línea: app.dependency_overrides[get_session] = get_session_override Yo había puesto get_session_override(), con (), lo que me retornaba un error

TypeError: 'Session' object is not callable

y entonces entendí el siguiente concepto:

Concept: Function Reference vs. Function Call

Angel Esteban Patiño Salazar

student•

El uso del engine con with yield en el contexto de pruebas y APIs es clave para gestionar la conexión a la base de datos. En las pruebas unitarias, esto permite crear un engine temporal para evitar alterar los datos de producción. En APIs, el yield facilita la creación de sesiones reutilizables, asegurando que cada solicitud obtenga una conexión válida y se cierre adecuadamente después de la operación, evitando fugas de conexión y mejorando el rendimiento. Esto es esencial para mantener la integridad y eficiencia en aplicaciones FastAPI.

Sebastian Pérez

student•

que locura los entornos de test, genial explicación

import pytest
from fastapi.testclient import TestClient
from sqlmodel import Session, SQLModel, create_engine
from sqlmodel.pool import StaticPool

from app.db import get_session
from app.main import app


@pytest.fixture(name="session")
def session_fixture():
    engine = create_engine(
        "sqlite://", connect_args={"check_same_thread": False}, poolclass=StaticPool
    )
    SQLModel.metadata.create_all(engine)
    with Session(engine) as session:
        yield session


@pytest.fixture(name="client")
def client_fixture(session: Session):
    def get_session_override():
        return session

    app.dependency_overrides[get_session] = get_session_override
    client = TestClient(app)
    yield client
    app.dependency_overrides.clear()

#test para crear un customer
def test_create_customer(client):
    response = client.post("/customers/", json={
        "name": "John Doe",
        "description": "This is a test customer",
        "email": "prueba@prueba.com",
        "age": 30
    })
    assert response.status_code == 200
    assert response.json()

Pruebas unitarias con FastAPI y Pytest: Configuración y Ejecución

Introducción a FastAPI

Creación de APIs rápidas y eficientes con FastAPI

Creación de APIs con FastAPI: Framework Rápido y Versátil

Creación de Entornos Virtuales y Configuración de FastAPI

Parámetros y Validación

Crear un Endpoint Dinámico con FastAPI para Obtener Hora por País y Formato

Validación de datos con Pydantic en FastAPI: Creación de endpoints

Modelado de Datos y Conexión de Modelos en FastAPI

Validación de Datos y Modelos en Endpoints de FastAPI

CRUD en FastAPI

Conexión de FastAPI con SQLite usando SQLModel

Integración de SQLModel en FastAPI para Manejo de Bases de Datos

Creación y Gestión de Endpoints en FastAPI para CRUD de Clientes

Actualización de Clientes: Implementación de Endpoint PATCH

Arquitectura en FastAPI

Estructuración de Aplicaciones con FastAPI y API Router

Bases de Datos y Consultas

Relaciones en FastAPI y SQL Model: Creación y Uso Práctico

Relaciones Muchos a Muchos en Bases de Datos con SQLModel

Creación y Suscripción de Planes y Clientes en FastAPI

Consultas Avanzadas con SQL Model y Filtrado de Estados en FastAPI

Validación de Emails Únicos en Bases de Datos con Pydantic y FastAPI

Middlewares

Implementación de Paginación en FastAPI con SQLModel

Implementación de Middlewares en FastAPI para Medir Tiempos de Request

Unit Testing

Pruebas unitarias con FastAPI y Pytest: Configuración y Ejecución

Pruebas Unitarias para CRUD de Clientes en FastAPI

Seguridad y Autenticación

Autenticación Básica HTTP con FastAPI

Creación de Endpoints y Bases de Datos con FastAPI