Mis apuntes · Aprende Python desde PHP

Se guardan solos en este navegador mientras escribes. Puedes usar Markdown. Al descargarlos, la primera línea es tu enlace personal al curso.

Lección 47 de 47 · Proyecto final: CRUD de tareas con SQLite ✦ WebMCP implementado

Fase 6: tests y despliegue

10 min de lectura 4 retos

La app funciona, pero ¿lo sabes o lo crees? En esta última fase le pones tests con pytest a cada capa y la preparas para vivir fuera de tu portátil: configuración por variables de entorno, un Dockerfile, uvicorn con varios procesos y nginx por delante. Es el paso de «funciona en mi máquina» a «funciona».

¿De dónde vienen los nombres?

pytest = py (Python) + inglés test
La herramienta de tests más usada de Python. Busca las funciones que empiezan por test_ y las ejecuta. Es el PHPUnit de Python, sin clases obligatorias.
fixture = inglés fixture (pieza fija; lo que ya está montado antes de empezar)
Una función que prepara algo que los tests necesitan (un cliente, una base de datos limpia) y se lo entrega pidiéndolo por el nombre. Es el setUp() de PHPUnit, pero reutilizable.
tmp_path = inglés temporary path (ruta temporal)
Una fixture de pytest que da una carpeta nueva y vacía para cada test, y la borra después.
monkeypatch = inglés monkey patch (parche «a lo mono»: cambiar algo a la fuerza mientras se ejecuta)
Una fixture que cambia una variable de entorno o un atributo solo durante ese test y lo deja como estaba.
Dockerfile = inglés dock (muelle, donde se carga la mercancía) + file (fichero)
La receta para construir la imagen de un contenedor: qué base usar, qué copiar y qué comando ejecutar.
En 4 ideas
1/4

Un test de pytest es una función test_... con un assert normal, sin clases ni assertSame. Se prueba cada capa por separado: el dominio sin base de datos, el repositorio con ":memory:" y la API con TestClient. En PHP, PHPUnit.

1 · Probar cada capa por separado

Gracias a las capas, no hace falta levantar nada para probar casi todo. Un test es más rápido y más útil cuanto menos tiene que montar: el dominio se prueba sin base de datos, el repositorio con una base en memoria y solo la API necesita el cliente de pruebas. La regla: probar cada cosa en la capa más baja posible.

#CapaQué se pruebaCon quéVelocidad
1app/domainReglas: título limpio, etiquetas, erroresNada: solo assertInstantánea
2app/infrastructure/sqliteQue guarda, busca, borra y falla biensqlite3.connect(":memory:")Muy rápida
3app/applicationBuscar → cambiar → guardarUn repositorio falsoInstantánea
4app/infrastructure/apiCódigos HTTP, JSON, validaciónTestClient y un fichero temporalRápida

Un test de pytest es una función cuyo nombre empieza por test_ y que usa assert. Para entender qué hace pytest por dentro, aquí tienes uno de juguete que busca esas funciones y las ejecuta. Pulsa Ejecutar:

Pythonmain.py
from dataclasses import dataclass, field


class TituloVacio(Exception):
    pass


@dataclass
class Tarea:
    titulo: str
    etiquetas: list[str] = field(default_factory=list)

    def __post_init__(self):
        self.titulo = self.titulo.strip()
        if not self.titulo:
            raise TituloVacio("el título no puede estar vacío")


def test_el_titulo_se_limpia():
    assert Tarea("  Comprar pan ").titulo == "Comprar pan"


def test_titulo_vacio_no_puede_existir():
    try:
        Tarea("   ")
    except TituloVacio:
        return
    raise AssertionError("debería haber lanzado TituloVacio")


def test_las_etiquetas_no_se_comparten():
    a, b = Tarea("a"), Tarea("b")
    a.etiquetas.append("casa")
    assert b.etiquetas == []


# Un pytest de juguete: busca las funciones test_* de este fichero y las ejecuta.
pruebas = [(n, f) for n, f in list(globals().items()) if n.startswith("test_") and callable(f)]
for nombre, prueba in pruebas:
    try:
        prueba()
        print("PASSED", nombre)
    except AssertionError as error:
        print("FAILED", nombre, error)
print(len(pruebas), "pruebas")
PHP 8.5TareaTest.php
<?php
declare(strict_types=1);

use PHPUnit\Framework\TestCase;

final class TareaTest extends TestCase
{
    public function testElTituloSeLimpia(): void
    {
        $tarea = new Tarea("  Comprar pan ");

        $this->assertSame("Comprar pan", $tarea->titulo);
    }

    public function testTituloVacioNoPuedeExistir(): void
    {
        $this->expectException(TituloVacio::class);

        new Tarea("   ");
    }
}
Pythontest_dominio.pySolo lectura: necesita pytest
from dataclasses import dataclass

import pytest


class TituloVacio(Exception):
    pass


@dataclass
class Tarea:
    titulo: str

    def __post_init__(self):
        self.titulo = self.titulo.strip()
        if not self.titulo:
            raise TituloVacio("el título no puede estar vacío")


def test_el_titulo_se_limpia():
    assert Tarea("  Comprar pan ").titulo == "Comprar pan"


def test_titulo_vacio_no_puede_existir():
    with pytest.raises(TituloVacio):
        Tarea("   ")

¿Por qué? · En PHP no existe

¿Por qué un assert a secas y no assertSame, assertEquals…? En PHPUnit hay decenas

PHPUnit necesita un método por cada tipo de comparación porque assert de PHP no cuenta qué falló. pytest reescribe tus assert antes de ejecutarlos: guarda el valor de cada parte, y si falla, te dice exactamente qué había a cada lado. Un solo assert vale para todo: igualdad, in, is None, comparaciones.

Mira lo que cuenta pytest cuando un test falla (el test espera "Comprar pan ", con un espacio sobrante):

$ pytest
============================= test session starts ==============================
collected 1 item

tests/test_fallo.py F                                                    [100%]

=================================== FAILURES ===================================
___________________________ test_el_titulo_se_limpia ___________________________

    def test_el_titulo_se_limpia():
        titulo = "  Comprar pan ".strip()
>       assert titulo == "Comprar pan "
E       AssertionError: assert 'Comprar pan' == 'Comprar pan '
E         
E         - Comprar pan 
E         ?            -
E         + Comprar pan

tests/test_fallo.py:3: AssertionError
=========================== short test summary info ============================
FAILED tests/test_fallo.py::test_el_titulo_se_limpia - AssertionError: assert...
============================== 1 failed in 0.03s ===============================

El ? y el - señalan el carácter que sobra. Sin escribir un mensaje. Esto, en PHPUnit, son assertSame con un mensaje de tu cosecha.

2 · pytest y las fixtures: preparar sin repetir

Las fixtures son funciones que preparan lo que un test necesita. El test las pide escribiendo su nombre como parámetro, y pytest las ejecuta antes y le pasa el resultado. Con una sola fixture parametrizada, los mismos tests se ejecutan contra la memoria y contra SQLite, la prueba de que las dos cumplen el mismo contrato:

Pythonmain.py
import sqlite3

import pytest

from app.domain.errores import TareaNoEncontrada
from app.domain.tarea import Prioridad, Tarea
from app.infrastructure.memoria import RepositorioMemoria
from app.infrastructure.sqlite.migraciones import migrar
from app.infrastructure.sqlite.repositorio_sqlite import RepositorioSqlite


def sqlite_en_memoria():
    conexion = sqlite3.connect(":memory:")
    migrar(conexion)
    return RepositorioSqlite(conexion)


@pytest.fixture(params=[RepositorioMemoria, sqlite_en_memoria], ids=["memoria", "sqlite"])
def repositorio(request):
    return request.param()


def test_guardar_y_buscar(repositorio):
    guardada = repositorio.guardar(Tarea("Comprar pan", Prioridad.ALTA, etiquetas=["casa"]))
    assert guardada.id == 1
    assert repositorio.buscar_por_id(1) == guardada


def test_buscar_inexistente(repositorio):
    with pytest.raises(TareaNoEncontrada):
        repositorio.buscar_por_id(99)


def test_borrar(repositorio):
    repositorio.guardar(Tarea("Comprar pan"))
    repositorio.borrar(1)
    assert repositorio.listar() == []

params=[RepositorioMemoria, sqlite_en_memoria] hace que pytest ejecute cada test dos veces, una con cada repositorio (los nombres [memoria] y [sqlite] salen de ids). Si algún día añades un repositorio nuevo, lo metes en la lista y pasa los mismos tests. Esa misma idea, escrita sin pytest y ejecutable aquí:

Pythonmain.py
import sqlite3
from dataclasses import dataclass, replace


class TareaNoEncontrada(Exception):
    pass


@dataclass
class Tarea:
    titulo: str
    hecha: bool = False
    id: int | None = None


class RepositorioMemoria:
    def __init__(self):
        self._tareas = {}
        self._siguiente = 1

    def guardar(self, tarea):
        if tarea.id is None:
            tarea = replace(tarea, id=self._siguiente)
            self._siguiente += 1
        self._tareas[tarea.id] = replace(tarea)
        return tarea

    def buscar_por_id(self, id):
        if id not in self._tareas:
            raise TareaNoEncontrada(id)
        return replace(self._tareas[id])

    def borrar(self, id):
        if id not in self._tareas:
            raise TareaNoEncontrada(id)
        del self._tareas[id]


class RepositorioSqlite:
    def __init__(self):
        self._conexion = sqlite3.connect(":memory:")
        self._conexion.execute(
            "CREATE TABLE tareas (id INTEGER PRIMARY KEY AUTOINCREMENT, titulo TEXT NOT NULL, hecha INTEGER NOT NULL DEFAULT 0)"
        )

    def guardar(self, tarea):
        cursor = self._conexion.execute(
            "INSERT INTO tareas (titulo, hecha) VALUES (?, ?)", (tarea.titulo, int(tarea.hecha))
        )
        self._conexion.commit()
        return replace(tarea, id=cursor.lastrowid)

    def buscar_por_id(self, id):
        fila = self._conexion.execute("SELECT id, titulo, hecha FROM tareas WHERE id = ?", (id,)).fetchone()
        if fila is None:
            raise TareaNoEncontrada(id)
        return Tarea(fila[1], bool(fila[2]), fila[0])

    def borrar(self, id):
        cursor = self._conexion.execute("DELETE FROM tareas WHERE id = ?", (id,))
        if cursor.rowcount == 0:
            raise TareaNoEncontrada(id)
        self._conexion.commit()


def contrato_repositorio(repositorio):
    """Lo que TODO repositorio tiene que cumplir. Falla con assert si no."""
    guardada = repositorio.guardar(Tarea("Comprar pan"))
    assert guardada.id is not None, "guardar tiene que dar un id"
    assert repositorio.buscar_por_id(guardada.id).titulo == "Comprar pan"
    repositorio.borrar(guardada.id)
    try:
        repositorio.buscar_por_id(guardada.id)
    except TareaNoEncontrada:
        return
    raise AssertionError("buscar tras borrar tendría que lanzar TareaNoEncontrada")


for nombre, fabrica in [("memoria", RepositorioMemoria), ("sqlite", RepositorioSqlite)]:
    contrato_repositorio(fabrica())
    print("cumple el contrato:", nombre)

¿Por qué? · En PHP no existe

¿Por qué una fixture y no un setUp() como en PHPUnit?

setUp() se ejecuta antes de todos los tests de la clase, los necesiten o no, y vive atado a esa clase. Una fixture se ejecuta solo para los tests que la piden, vale para cualquier fichero (en conftest.py) y se puede combinar con otras (la fixture cliente usa tmp_path y monkeypatch).

Además, una fixture puede usar yield: lo que hay antes prepara y lo de después limpia (igual que el tearDown()), todo en una sola función. Es el gestor de contexto del módulo 07 aplicado a los tests.

3 · Probar la API con TestClient

Para la capa de arriba usamos el TestClient que ya viste: llama a la app sin abrir ningún puerto. Lo envolvemos en una fixture en tests/conftest.py, que además le da a cada test su propia base de datos en una carpeta temporal:

Pythonmain.py
import pytest
from fastapi.testclient import TestClient

from app.main import app


@pytest.fixture
def cliente(tmp_path, monkeypatch):
    monkeypatch.setenv("TAREAS_DB", str(tmp_path / "tareas.db"))
    with TestClient(app) as cliente:
        yield cliente
  1. tmp_path es una carpeta nueva y vacía por test. La base de datos de cada test nace ahí y nunca toca tu tareas.db.
  2. monkeypatch.setenv("TAREAS_DB", ...) cambia la variable de entorno que lee ruta_bd(), y al acabar el test la deja como estaba. Así la app usa el fichero de prueba sin cambiar una línea de código.
  3. with TestClient(app) as cliente hace que se ejecute el lifespan: se migra la base de datos al empezar, como en producción. Sin el with, la tabla no existiría.
  4. yield cliente entrega el cliente al test y, al terminar, el with se cierra solo.

Y con esa fixture, los tests de la API se leen casi como una conversación. Esto es tests/test_api.py:

Pythonmain.py
def test_crear_devuelve_201(cliente):
    respuesta = cliente.post("/tareas", json={"titulo": "Comprar pan", "prioridad": 2})
    assert respuesta.status_code == 201
    assert respuesta.json() == {
        "id": 1, "titulo": "Comprar pan", "prioridad": 2, "hecha": False, "etiquetas": [],
    }


def test_titulo_vacio_es_422(cliente):
    assert cliente.post("/tareas", json={"titulo": ""}).status_code == 422
    assert cliente.post("/tareas", json={"titulo": "   "}).status_code == 422


def test_completar_y_listar_pendientes(cliente):
    cliente.post("/tareas", json={"titulo": "Comprar pan"})
    cliente.post("/tareas", json={"titulo": "Llamar al banco"})
    assert cliente.post("/tareas/1/completar").json()["hecha"] is True
    pendientes = cliente.get("/tareas", params={"pendientes": True}).json()
    assert [t["titulo"] for t in pendientes] == ["Llamar al banco"]


def test_tarea_inexistente_es_404(cliente):
    respuesta = cliente.post("/tareas/7/completar")
    assert respuesta.status_code == 404
    assert respuesta.json() == {"detail": "No existe la tarea 7"}


def test_borrar_devuelve_204(cliente):
    cliente.post("/tareas", json={"titulo": "Comprar pan"})
    assert cliente.delete("/tareas/1").status_code == 204
    assert cliente.delete("/tareas/1").status_code == 404

Y así los ejecuta pytest, con todo el proyecto (dominio, repositorios y API):

$ pytest -v
tests/test_api.py::test_crear_devuelve_201 PASSED                        [  6%]
tests/test_api.py::test_titulo_vacio_es_422 PASSED                       [ 13%]
tests/test_api.py::test_completar_y_listar_pendientes PASSED             [ 20%]
tests/test_api.py::test_tarea_inexistente_es_404 PASSED                  [ 26%]
tests/test_api.py::test_borrar_devuelve_204 PASSED                       [ 33%]
tests/test_dominio.py::test_el_titulo_se_limpia PASSED                   [ 40%]
tests/test_dominio.py::test_titulo_vacio_no_puede_existir PASSED         [ 46%]
tests/test_dominio.py::test_etiquetas_no_se_comparten_entre_tareas PASSED [ 53%]
tests/test_dominio.py::test_prioridad_por_defecto_es_media PASSED        [ 60%]
tests/test_repositorios.py::test_guardar_y_buscar[memoria] PASSED        [ 66%]
tests/test_repositorios.py::test_guardar_y_buscar[sqlite] PASSED         [ 73%]
tests/test_repositorios.py::test_buscar_inexistente[memoria] PASSED      [ 80%]
tests/test_repositorios.py::test_buscar_inexistente[sqlite] PASSED       [ 86%]
tests/test_repositorios.py::test_borrar[memoria] PASSED                  [ 93%]
tests/test_repositorios.py::test_borrar[sqlite] PASSED                   [100%]
============================== 15 passed in 0.22s ==============================

¿Por qué? · En PHP no existe

¿Por qué comprobar 404 y 422, no solo el camino feliz?

Porque los errores son parte de la API. Un cliente depende de que «no existe» sea un 404 y no un 500, y de que un título vacío sea un 422. Un fallo en esos códigos no rompe nada a la vista, pero rompe a quien consume la API.

Los tests de errores son los que más valor dan: son justo el trabajo que cuesta recordar. Cada vez que arregles un bug de la API, empieza por escribir el test que lo reproduce: falla, lo arreglas, pasa, y no vuelve.

4 · Configuración: variables de entorno, no código

En tu portátil la base de datos es tareas.db; en el servidor, un fichero en otra carpeta. Si escribes la ruta en el código, hay que cambiar el código para cambiar el entorno. En su lugar, el programa pregunta al entorno, y quien lo ejecuta decide. En PHP lo haces con getenv() o $_ENV; en Python, con os.environ:

PHP 8.5config.php
<?php
declare(strict_types=1);

putenv("PUERTO=9000");

$ruta = getenv("TAREAS_DB") ?: "tareas.db";
$puerto = (int) (getenv("PUERTO") ?: 8000);

echo $ruta . " " . $puerto . PHP_EOL;
Pythonconfig.py
import os

os.environ["PUERTO"] = "9000"

ruta = os.environ.get("TAREAS_DB", "tareas.db")
puerto = int(os.environ.get("PUERTO", "8000"))

print(ruta, puerto)
  1. os.environ se comporta como un diccionario: .get(clave, por_defecto) es el getenv(...) ?: por_defecto de PHP.
  2. Una variable de entorno es siempre texto: "9000", no 9000. Hay que convertirla (int(...)), igual que el (int) de PHP. Un bool con "False" sería True, porque cualquier texto no vacío lo es.
  3. Las dos primeras líneas de asignación solo están para la demostración: en la vida real quien pone PUERTO es el sistema, no tu programa.

¿Por qué? · En PHP no existe

¿Por qué configurar con el entorno y no con un fichero config.py por cada servidor?

Porque así la misma imagen de Docker sirve en tu portátil, en pruebas y en producción: lo único que cambia es el entorno que le das al arrancar. Sin reconstruir nada, sin editar ficheros dentro del contenedor.

Y porque los secretos no se escriben en el código: ni claves de APIs ni contraseñas de bases de datos van en el repositorio. Se inyectan al arrancar. Es el principio de la «aplicación de doce factores»: config in the environment.

5 · El Dockerfile: la app en una caja

Un contenedor es una caja con tu app y todo lo que necesita (Python, las librerías), igual en cualquier máquina. En PHP ya conoces el patrón: una imagen php:8.5-fpm con tu código copiado y nginx delante. En Python es más corto, porque uvicorn hace de servidor y no hace falta FPM. Este es el Dockerfile del proyecto (lo hemos construido y arrancado de verdad):

FROM python:3.14-slim

ENV PYTHONDONTWRITEBYTECODE=1 \
    PYTHONUNBUFFERED=1

WORKDIR /srv

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY app ./app

RUN useradd --uid 1000 --create-home tareas \
    && mkdir /data \
    && chown tareas /data
USER tareas

ENV TAREAS_DB=/data/tareas.db
EXPOSE 8000

CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]
#LíneaQué haceEn el Dockerfile de PHP
1FROM python:3.14-slimParte de una imagen con Python (la slim pesa poco)FROM php:8.5-fpm
2COPY requirements.txt . + pip installInstala las librerías antes de copiar el código, para que Docker reutilice esa capacomposer install
3COPY app ./appCopia el códigoCOPY src/ /var/www/
4USER tareasEjecuta con un usuario normal, no rootUSER www-data
5ENV TAREAS_DB=/data/tareas.dbPone la base de datos en /data, que será un volumenLas variables del .env
6CMD ["uvicorn", ...]El comando que arranca el servidorphp-fpm (y un nginx aparte)

Se construye y se arranca así. Fíjate en el volumen (-v tareas-datos:/data): sin él, la base de datos viviría dentro del contenedor y se perdería al borrarlo:

$ docker build -t tareas .
$ docker run -d --name tareas -p 8000:8000 -v tareas-datos:/data tareas
$ docker logs tareas
INFO:     Started server process [1]
INFO:     Waiting for application startup.
INFO:     Application startup complete.
INFO:     Uvicorn running on http://0.0.0.0:8000 (Press CTRL+C to quit)

¿Por qué? · En PHP no existe

¿Por qué --host 0.0.0.0? En PHP no tocabas esto

Por defecto, uvicorn escucha en 127.0.0.1: solo acepta conexiones de su propia máquina. Dentro de un contenedor, «su propia máquina» es solo el contenedor, así que ni tu navegador ni nginx podrían llegar, aunque publiques el puerto con -p.

0.0.0.0 significa «escucha en todas las direcciones del contenedor». Por eso no hace falta en tu portátil sin Docker, y es obligatorio dentro. En PHP no lo veías porque nginx y php-fpm hablaban por un socket interno.

6 · Detrás de nginx y con varios procesos

En producción no se expone uvicorn directamente. Lo normal es nginx por delante: gestiona el HTTPS, los ficheros estáticos y las peticiones lentas, y reenvía el resto a uvicorn. Es la misma foto que con PHP; solo cambia una directiva:

#AspectoPHPPython
1nginx reenvía confastcgi_pass unix:/run/php/php-fpm.sock;proxy_pass http://127.0.0.1:8000;
2Protocolo entre nginx y la appFastCGIHTTP normal (o ASGI por socket)
3Quién ejecuta tu códigophp-fpm, un proceso por peticiónuvicorn, procesos que siguen vivos
4Más capacidadpm.max_children de php-fpmMás workers de uvicorn
5Reinicio tras un desplieguekill -USR2 / reload de php-fpmReiniciar el contenedor o enviar HUP a gunicorn
server {
    listen 80;
    server_name tareas.ejemplo.com;

    location / {
        proxy_pass http://127.0.0.1:8000;
        proxy_set_header Host $host;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

Las tres líneas proxy_set_header le cuentan a uvicorn quién llamó de verdad (X-Forwarded-For) y por qué protocolo (X-Forwarded-Proto), porque desde su punto de vista todas las peticiones llegan desde nginx. Uvicorn las usa si le dices en qué IPs confiar (--forwarded-allow-ips) y trae --proxy-headers activado por defecto.

Un proceso de uvicorn usa un núcleo de la CPU. Para aprovechar más, hay dos caminos:

  1. uvicorn app.main:app --workers 4: uvicorn arranca y supervisa 4 procesos. Es lo más sencillo y suficiente para empezar.
  2. gunicorn con workers de uvicorn: gunicorn app.main:app -k uvicorn_worker.UvicornWorker -w 4 -b 0.0.0.0:8000. Gunicorn es un gestor de procesos veterano (reinicia los que caen, recarga sin cortar). Hay que instalar gunicorn y uvicorn-worker. El módulo uvicorn.workers está obsoleto: usa el paquete uvicorn-worker.

¿Cuántos? Para empezar, la regla de gunicorn: (2 × núcleos) + 1. Con un servidor async como uvicorn suele bastar con menos (a veces uno por núcleo). Mide antes de subirlo: más workers consumen más memoria y no ayudan si el cuello de botella es la base de datos.

¿Por qué? · En PHP no existe

¿Por qué con varios workers hay que mirar SQLite con cuidado? En PHP-FPM tampoco era un problema

Cada worker es un proceso con sus propias conexiones al mismo fichero. SQLite deja un solo escritor a la vez: si dos workers escriben a la vez, uno espera (sqlite3.connect espera 5 segundos por defecto antes de dar database is locked). Para una app de tareas con poco tráfico es de sobra, pero es un límite real.

Para aliviarlo, SQLite tiene el modo WAL (PRAGMA journal_mode=WAL), que deja leer mientras otro escribe. Y si el límite aprieta de verdad, el siguiente paso no es más workers, sino otra base de datos. Con la arquitectura de capas de este proyecto, ese cambio vive entero dentro de app/infrastructure/sqlite.

La pregunta que te vas a hacer

Vale, pero… ¿cómo lo despliego en un servidor de verdad, con HTTPS y todo?

Lo habitual es un servidor con Docker, nginx (o Caddy) por delante y un certificado de Let's Encrypt. Estos son los recursos más usados:

Hora de practicar

Retos · 0/4 resueltos

Reto 1 de 4

Leer la configuración

Escribe leer_ajustes(entorno): recibe un diccionario (tu os.environ) y devuelve otro con db (variable TAREAS_DB, por defecto "tareas.db"), puerto (variable PUERTO como int, por defecto 8000) y debug (variable DEBUG: True solo si vale 1, true o si, en cualquier mayúscula; por defecto False). Es el getenv() de PHP con conversiones.

Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.

Pythonmain.py · editable

Resumen

Lo que te llevas de esta lección

  1. Cada capa se prueba en la más baja posible: el dominio con un assert, el repositorio con ":memory:" y la API con TestClient (en PHP, PHPUnit con mocks).
  2. Las fixtures preparan lo que el test pide por su nombre; tmp_path y monkeypatch dan a cada test su propia base de datos (en PHP, setUp()).
  3. La configuración va en el entorno: os.environ.get("TAREAS_DB", "tareas.db") (en PHP, getenv()), y siempre llega como texto.
  4. En el contenedor uvicorn escucha en --host 0.0.0.0, y la base de datos SQLite vive en un volumen (/data).
  5. En producción, nginx hace proxy_pass a uvicorn (con --workers N o gunicorn + uvicorn-worker), igual que antes hacía fastcgi_pass a php-fpm.

Para recordarlo: «Capas, Entorno, Caja»

CCapas
cada una con su test
EEntorno
os.environ.get(...)
CCaja
Dockerfile + --host 0.0.0.0

Para pasar de tu portátil al servidor: Capas probadas una a una, configuración en el Entorno y todo en una Caja (Docker) con nginx delante.