Tu agente de programación no es un flujo de despliegue
Una aplicación creada con IA necesita un proceso que ponga en servicio la versión probada y permita volver atrás si a...
8 min de lectura
17.11.2026, Por Stephan Schwab
Un cliente pulsa «Cancelar» mientras alguien en el almacén todavía recoge los productos de su pedido. El sistema dice que ya está cancelado. En el almacén nadie ha confirmado que se detuvo el trabajo. Una función pequeña acaba de hacer una promesa que la empresa no puede cumplir. En un ejemplo con Python, una prueba que falla deja al descubierto la decisión pendiente. ¿Qué debe ver el cliente mientras el almacén sigue trabajando? Al hacer pasar la prueba, esa decisión queda en el código. La siguiente prueba fallida muestra qué seguimos entendiendo mal.
Usemos un sistema de pedidos ficticio y deliberadamente pequeño. Si el pedido todavía está en espera en el almacén, podemos cancelarlo de inmediato. Aún falta acordar qué pasa cuando alguien empieza a recoger los productos.
Escribe el primer ejemplo en test_order.py.
import unittest
from order import Order, cancel
class CancellationTests(unittest.TestCase):
def test_waiting_order_can_be_cancelled(self):
order = Order(state="waiting")
result = cancel(order)
self.assertEqual("cancelled", result.state)
Usa una versión de Python 3 que siga recibiendo soporte. Desde el directorio de los archivos de ejemplo, ejecuta unittest, que viene con la biblioteca estándar.
python3 -m unittest -v
Al principio falla la importación porque order.py no existe. Crea el archivo con la estructura mínima para que la prueba llegue al comportamiento que queremos comprobar.
from dataclasses import dataclass
@dataclass(frozen=True)
class Order:
state: str
def cancel(order: Order) -> Order:
raise NotImplementedError
Ejecuta la prueba otra vez. Ahora llega a cancel y falla con NotImplementedError. Sabemos por qué está en rojo. Un error de escritura en la importación nos diría algo sobre nuestra ortografía. Este fallo nos dice que la cancelación sigue sin implementar.
Fíjate en lo que ya decidimos. La cancelación es una operación sobre un pedido. Devuelve un pedido cuyo estado podemos inspeccionar. La entrada es un valor inmutable, así que quien llama a la función puede conservar el pedido original sin que cambie a sus espaldas. También podríamos haber elegido un objeto mutable o un manejador de comandos. La prueba nos lleva a ensayar una de esas opciones.
Ahora cambia el import de order.py a from dataclasses import dataclass, replace. Conserva la clase Order y reemplaza cancel por esta función.
def cancel(order: Order) -> Order:
return replace(order, state="cancelled")
La prueba pasa. La implementación cumple con nuestro único ejemplo. Y se equivoca con los pedidos que ya van de salida.
Conviene descubrir la diferencia mientras el programa todavía cabe en una pantalla.
Pregúntale a la compañera del almacén qué significa cancelar un pedido que ya están preparando. Ella no puede prometer que la preparación se detenga al instante. Quizá quien recoge los productos se ha alejado del dispositivo. El equipo de ventas acepta que el cliente vea una solicitud de cancelación hasta que el almacén confirme que ha dejado de preparar el pedido. Si el pedido ya salió, corresponde tramitar una devolución.
Son decisiones para este ejemplo. Otro negocio podría adoptar una política distinta. El desarrollador no debería zanjar la cuestión a escondidas con el primer if que se le ocurra.
Agrega estos dos métodos a CancellationTests en test_order.py.
def test_picking_order_records_a_request(self):
order = Order(state="picking")
result = cancel(order)
self.assertEqual("cancellation_requested", result.state)
def test_shipped_order_remains_shipped(self):
order = Order(state="shipped")
result = cancel(order)
self.assertEqual("shipped", result.state)
Ejecuta el conjunto de pruebas. El primer ejemplo sigue pasando. Los dos nuevos fallan porque la función devuelve cancelled para todo. De esas vergüenzas que sirven. Detectamos una promesa falsa antes de que le llegue al cliente por correo.
Cambia la función.
def cancel(order: Order) -> Order:
if order.state == "picking":
return replace(order, state="cancellation_requested")
if order.state == "shipped":
return order
return replace(order, state="cancelled")
Pasan tres ejemplos. Y ya tenemos otra pregunta.
¿Qué pasa si el cliente pulsa dos veces mientras en el almacén siguen preparando el pedido? La función convierte cancellation_requested en cancelled. El segundo clic se acaba de inventar una confirmación del almacén. Muy eficiente. Pura ficción.
Agrega el ejemplo del segundo clic a CancellationTests.
def test_repeated_request_does_not_confirm_cancellation(self):
order = Order(state="cancellation_requested")
result = cancel(order)
self.assertEqual("cancellation_requested", result.state)
Mira cómo falla. En cancel, cambia if order.state == "shipped": por if order.state in ("shipped", "cancellation_requested"): y vuelve a ejecutar las pruebas. La solicitud repetida ahora deja el estado intacto. Agrega una quinta prueba que reciba un pedido ya cancelado y espere cancelled. Debería pasar a la primera. El comportamiento ya existía. El ejemplo lo deja explícito.
Los condicionales ya expresan una pequeña regla de transición. Cuando escribimos los mismos estados como cadenas una y otra vez, es fácil cometer un error de escritura. Y el último caso da por hecho que cualquier estado desconocido admite una cancelación. Dales nombres explícitos a los estados conocidos y enumera los resultados posibles.
Reemplaza la versión anterior de order.py por esta, que está completa.
from dataclasses import dataclass, replace
from enum import Enum
class State(Enum):
WAITING = "waiting"
PICKING = "picking"
CANCELLATION_REQUESTED = "cancellation_requested"
CANCELLED = "cancelled"
SHIPPED = "shipped"
@dataclass(frozen=True)
class Order:
state: State
CANCELLATION_OUTCOME = {
State.WAITING: State.CANCELLED,
State.PICKING: State.CANCELLATION_REQUESTED,
State.CANCELLATION_REQUESTED: State.CANCELLATION_REQUESTED,
State.CANCELLED: State.CANCELLED,
State.SHIPPED: State.SHIPPED,
}
def cancel(order: Order) -> Order:
return replace(order, state=CANCELLATION_OUTCOME[order.state])
Vale la pena discutir si la tabla es la mejor opción. Con cinco estados, unos condicionales explícitos también pueden leerse bien. Aquí la tabla permite que el desarrollador y la compañera del almacén comprueben todos los resultados de la cancelación en un solo lugar. Los cinco resultados acordados se mantienen. Para los estados desconocidos quitamos deliberadamente el comportamiento por defecto. Si falta la entrada, se produce un KeyError. La aplicación todavía tiene que validar lo que recibe del exterior. Una anotación de tipo en Python no hace ese trabajo.
Reemplaza test_order.py por el conjunto completo que sigue. Los ejemplos ahora usan los estados por nombre y siguen comprobando el comportamiento acordado.
import unittest
from order import Order, State, cancel
class CancellationTests(unittest.TestCase):
def test_waiting_order_can_be_cancelled(self):
order = Order(State.WAITING)
result = cancel(order)
self.assertEqual(State.CANCELLED, result.state)
self.assertEqual(State.WAITING, order.state)
def test_picking_order_records_a_request(self):
result = cancel(Order(State.PICKING))
self.assertEqual(State.CANCELLATION_REQUESTED, result.state)
def test_shipped_order_remains_shipped(self):
result = cancel(Order(State.SHIPPED))
self.assertEqual(State.SHIPPED, result.state)
def test_repeated_request_does_not_confirm_cancellation(self):
order = Order(State.CANCELLATION_REQUESTED)
result = cancel(order)
self.assertEqual(State.CANCELLATION_REQUESTED, result.state)
def test_cancelled_order_stays_cancelled(self):
result = cancel(Order(State.CANCELLED))
self.assertEqual(State.CANCELLED, result.state)
Ejecuta el mismo comando. Deberían pasar las cinco pruebas. Sin instalar bibliotecas de pruebas, sin framework web, sin base de datos. Para examinar una regla, no hace falta convocar a toda la aplicación.
El ciclo rojo, verde y refactorización une la implementación y el diseño. Lo que descubrimos en cada paso cambia el siguiente. La definición de TDD de Agile Alliance incluye expresamente el diseño mediante la refactorización. Las pruebas escritas con la implementación ya terminada pueden comprobar el comportamiento. Llegan tarde para orientar las decisiones que ya tomamos.
La función da por hecho que recibe el estado actual. En producción, el almacén puede empezar a preparar el pedido entre el momento en que la aplicación lee waiting y el momento en que guarda cancelled. Que la prueba unitaria pase no dice cómo se resuelve esa carrera.
La aplicación debe aceptar el cambio solo si la versión almacenada sigue siendo la que leyó y tratar el conflicto de forma explícita. Según la base de datos y el resto del diseño, puede necesitar una actualización condicional o una transacción. Prueba ese límite con el sistema de almacenamiento real, incluidas las actualizaciones concurrentes.
La confirmación del almacén necesita su propia transición y sus propios ejemplos. Lo mismo pasa con los ajustes de pagos, las reservas de inventario y el envío. Si cambiar el pedido también exige enviar un mensaje que no se puede perder, prueba qué ocurre cuando se guarda el cambio pero falla el envío. Repetir un mensaje no debe provocar un segundo reembolso. Nada de eso le toca a la pequeña función de arriba.
La interfaz también tiene que distinguir los resultados. Si la función devuelve un pedido en estado SHIPPED, la interfaz no puede felicitar al cliente por haberlo cancelado. La función conserva el estado. Lo que se le dice al cliente es otra cuestión.
TDD también puede orientar el diseño de esos límites. Cinco pruebas unitarias no certifican que el sistema esté listo para producción. Un conjunto de pruebas que se mantiene en verde porque nunca se encuentra con la base de datos puede permitirse un optimismo admirable.
Imagina un proceso en el que primero se termina el análisis, luego se aprueba el diseño, los desarrolladores lo implementan y al final alguien prueba el resultado. La pregunta sobre la cancelación surge durante la implementación. En el diseño aprobado solo existen waiting, cancelled y shipped.
Ahora alguien tiene que decidir si el estado que falta es un hallazgo útil o un desvío sin autorización. Si para cambiar el documento hay que esperar a la reunión del jueves, la organización ha hecho que fingir salga más barato que entender.
Distintas personas aportan distintos conocimientos. Podemos fijar restricciones de arquitectura antes de abordar una función pequeña. Un sistema regulado puede exigir evidencia y aprobaciones explícitas. En todos esos casos se puede aprender algo nuevo aunque una fase ya se haya dado por cerrada.
La compañera del almacén sabía algo que faltaba en el ticket. Las pruebas le dieron una expresión precisa. La implementación destapó otra pregunta, la de las solicitudes repetidas. La refactorización dejó la regla más fácil de inspeccionar. Cada paso cambió lo que hacía falta en el siguiente.
Por eso el desarrollo de software es diseño. Un diagrama puede recoger una decisión importante. El trabajo de hacer que encaje con la realidad continúa cuando el código empieza a contestar.
Avanza en pasos lo bastante pequeños para aprovechar lo que descubres. Escribe el siguiente ejemplo. Mira cómo falla por un motivo que entiendes. Haz que pase. Mejora el diseño sin romper lo acordado.
Y cuando en el almacén hagan una pregunta incómoda, acerca una silla. El ticket nunca te la iba a contestar.
Cuénteme qué está pasando. Yo escucho, hago algunas preguntas prácticas y le devuelvo lo que veo: dónde puede estar el riesgo, qué puede estar bloqueando la entrega y qué parece valer la pena revisar después. Sin discurso comercial, sin compromiso. Confidencial y directo.
Iniciar una conversaciónUn desarrollador experimentado para tu equipo
Nuestro Developer Advocate programa código productivo con tu equipo, mejora el pipeline y acelera la entrega. 60-70% código, 30-40% coaching. Un compañero de equipo temporal que entrega desde el primer día.