Nivel inicial17 min de lectura · Publicado el

Qué es ATDD: desarrollo dirigido por tests de aceptación

ATDD: una hoja de encargo de tarta con cuatro criterios marcados, de chocolate, sin frutos secos, para 8 personas y con el nombre de Ana. ATDD: «hecho», por escritorubentejera.com ENCARGOde chocolatesin frutos secospara 8 personas«Feliz cumpleaños, Ana»Ana
La hoja de encargo son los tests de aceptación: criterios concretos que se acuerdan antes y se comprueban al recoger la tarta. En el software, esa lista se vuelve a comprobar sola con cada cambio.

Pides una funcionalidad, el equipo la programa y, al enseñarla, el cliente dice: «Esto no es lo que yo quería». Nadie ha mentido ni ha trabajado mal. Simplemente, cada uno entendió una cosa distinta.

ATDD (Acceptance Test-Driven Development, desarrollo dirigido por tests de aceptación) ataca ese problema: antes de programar, el equipo y el cliente se ponen de acuerdo en ejemplos concretos de lo que debe pasar, y esos ejemplos se convierten en tests automáticos. La funcionalidad está terminada cuando esos tests pasan.

Es como encargar una tarta. «Quiero una tarta rica» deja todo abierto. «De chocolate, sin frutos secos, para ocho personas y con “Feliz cumpleaños, Ana”» es una lista que el pastelero puede seguir y que tú puedes comprobar al recogerla. Los tests de aceptación son esa lista. El símil se queda corto en una cosa: en el software, la lista se comprueba sola cada vez que alguien cambia el código.

Qué es ATDD

El Desarrollo Dirigido por Tests de Aceptación (ATDD) es una práctica de equipo. La Agile Alliance la define como colaborar para escribir los tests de aceptación antes de implementar la funcionalidad correspondiente. Esos tests hacen de requisitos y, a la vez, comprueban que el sistema funciona como se esperaba.

También se la conoce como Story Test-Driven Development (SDD, según la Agile Alliance; no confundir con el spec-driven development, que usa la misma sigla), porque los tests salen de las historias de usuario, y está muy cerca de la especificación con ejemplos (Specification by Example). Según el glosario de la Agile Alliance, estos nombres existen para subrayar diferencias de enfoque que llevan a resultados parecidos.

El trabajo del analista de negocio cambia: en vez de escribir páginas y páginas de requisitos en lenguaje natural, que cada uno lee a su manera, se escriben ejemplos ejecutables que salen del consenso entre los miembros del equipo, incluido el cliente.

La lista de ejemplos de cada historia se escribe en una reunión con, al menos, tres perspectivas (en el mundo ágil se las llama «los tres amigos»):

  • Negocio: el dueño de producto o el cliente, que sabe qué necesita.
  • Desarrollo: quien lo va a programar y sabe qué es viable.
  • Calidad: quien piensa en los casos raros y en qué puede fallar.

Todo el equipo debe entender qué hay que hacer y por qué. Si no nos entendemos con el cliente, ni la mejor técnica de desarrollo dará un buen resultado.

ATDD, TDD y BDD: en qué se diferencian

Las tres empiezan por un test que falla. Cambia quién lo escribe, para quién y a qué nivel.

TDD ATDD BDD
Qué es Técnica de diseño del código Práctica de equipo para acordar requisitos Práctica de equipo centrada en el comportamiento
Quién escribe los tests Quien programa Negocio, desarrollo y calidad juntos Negocio, desarrollo y calidad juntos
Qué comprueba Que una pieza pequeña del código hace lo que debe Que la funcionalidad cumple lo que pidió el cliente Que el sistema se comporta como describen los ejemplos
En qué lenguaje El de programación El del negocio El del negocio, a menudo con Dado/Cuando/Entonces
Herramientas típicas JUnit, Jest, pytest… Cucumber, FitNesse, o tu framework de tests Cucumber, Reqnroll, Behave…

TDD es la base: escribes un test pequeño, lo ves fallar, escribes el código mínimo para que pase y refactorizas. Lo tienes explicado en TDD, Test Driven Development.

BDD (Behaviour-Driven Development) lo presentó Dan North en 2006 como una forma de explicar TDD hablando de «comportamiento» en lugar de «tests». Al llevarlo a los requisitos junto con Chris Matts, empezaron a describir los criterios de aceptación como escenarios con la plantilla Given / When / Then (Dado / Cuando / Entonces). Cucumber describe BDD en tres prácticas: descubrir ejemplos hablando, formularlos de forma que se puedan automatizar y automatizarlos para guiar el desarrollo.

En la práctica, ATDD y BDD se solapan tanto que muchos equipos usan los dos nombres para lo mismo. Si tienes que quedarte con una idea: TDD te ayuda a construir bien el código; ATDD te ayuda a construir lo que había que construir.

Si quieres profundizar en qué es BDD, tienes una guía rápida con lecturas para seguir.

Historias de usuario

El enunciado

El enunciado de una historia es una frase corta, de unas cinco palabras, que resume qué hay que hacer:

  • Formulario de inscripción
  • Iniciar sesión en el sistema
  • Reservar una habitación
  • Añadir un libro al carrito de la compra
  • Pago con tarjeta de crédito
  • Anotar un día festivo en el calendario
  • Informe de los artículos más vendidos
  • Darse de baja en el foro
  • Buscar casas de alquiler en Tenerife

Se escriben con el vocabulario del negocio del cliente, no con vocabulario técnico.

De la historia a los tests de aceptación

Cada historia provoca preguntas sobre los distintos contextos en que puede darse. Las respuestas son ejemplos, escritos en lenguaje humano, que convertimos en tests de aceptación que entienden el cliente, los desarrolladores y la máquina.

Una definición formal invita a la imprecisión y a que cada uno la interprete a su manera. Un ejemplo ilustrativo transmite la idea con mucha menos ambigüedad. Para «Añadir un libro al carrito»:

- Cuando el libro X se añade al carrito, el sistema devuelve
  un mensaje que dice: «El libro X ha sido añadido al carrito»
- Al mostrar el contenido del carrito aparece el libro X
- El libro X ya no aparece entre los libros que se pueden añadir

Cuantas menos palabras para decir lo mismo, mejor:

- Añadir el libro X en stock produce: «El libro X ha sido añadido al carrito»
- El libro X está en el carrito
- El libro X ya no está en el catálogo

Las preguntas pueden dar lugar a historias nuevas que pasan al backlog (la lista de trabajo pendiente): «Si el libro no está en stock, se enviará un email al usuario cuando llegue».

Ejemplo de ATDD con Cucumber.js, de principio a fin

¿Cómo entiende la máquina esas frases? Mágicamente, no. El equipo tiene que conectar cada frase con el código. Para eso existen herramientas libres como Cucumber, que lee ejemplos escritos en Gherkin (un formato de texto con palabras clave como Dado, Cuando y Entonces) y los ejecuta como tests.

Vamos a llevar la historia del carrito hasta el final con Node.js y Cucumber.js.

  1. Escribir el ejemplo acordado en Gherkin.
  2. Conectar cada frase con el código.
  3. Ejecutarlo y verlo fallar.
  4. Programar lo mínimo para que pase.

1. Prepara el proyecto

npm init -y
npm pkg set type=module
npm install --save-dev @cucumber/cucumber

2. Escribe el ejemplo en Gherkin

Gherkin admite más de 70 idiomas. Con # language: es en la primera línea puedes escribirlo en español. Este fichero es lo que se acuerda en la reunión con el cliente, y lo puede leer cualquiera:

# language: es
Característica: Añadir un libro al carrito de la compra

  Escenario: Añadir un libro que está en stock
    Dado que el catálogo tiene el libro "Diseño Ágil con TDD" en stock
    Cuando añado "Diseño Ágil con TDD" al carrito
    Entonces veo el mensaje "El libro Diseño Ágil con TDD ha sido añadido al carrito"
    Y el carrito contiene "Diseño Ágil con TDD"
    Y "Diseño Ágil con TDD" ya no está en el catálogo

Guárdalo en features/carrito.feature.

3. Conecta las frases con el código

Cada paso se enlaza con una función. Lo que va entre comillas en el ejemplo llega como parámetro ({string}). Guárdalo en features/step_definitions/carrito.steps.js:

import assert from 'node:assert/strict';
import { Given, When, Then } from '@cucumber/cucumber';
import { Tienda } from '../../src/tienda.js';

Given('que el catálogo tiene el libro {string} en stock', function (titulo) {
  this.tienda = new Tienda([titulo]);
});

When('añado {string} al carrito', function (titulo) {
  this.mensaje = this.tienda.anadirAlCarrito(titulo);
});

Then('veo el mensaje {string}', function (esperado) {
  assert.equal(this.mensaje, esperado);
});

Then('el carrito contiene {string}', function (titulo) {
  assert.ok(this.tienda.carrito().includes(titulo));
});

Then('{string} ya no está en el catálogo', function (titulo) {
  assert.ok(!this.tienda.catalogo().includes(titulo));
});

Fíjate en que el test habla con la tienda por sus puntos de entrada y salida (añadir, consultar el carrito, consultar el catálogo). No sabe nada de pantallas ni de bases de datos.

4. Ejecuta y míralo fallar (rojo)

Con una clase Tienda vacía en src/tienda.js, que todavía no hace nada:

export class Tienda {
  constructor(catalogo) {}
  anadirAlCarrito(titulo) {}
  carrito() { return []; }
  catalogo() { return []; }
}

Ejecutas Cucumber:

npx cucumber-js

Esta es la salida real:

..F--

Failed scenarios:
  1) Añadir un libro que está en stock # features/carrito.feature:4
       Entonces veo el mensaje "El libro Diseño Ágil con TDD ha sido añadido al carrito" # features/step_definitions/carrito.steps.js:13
           AssertionError [ERR_ASSERTION]: Expected values to be strictly equal:
           + actual - expected

           + undefined
           - 'El libro Diseño Ágil con TDD ha sido añadido al carrito'

1 scenario (1 failed)
5 steps (2 passed, 2 skipped, 1 failed)

Cada punto es un paso que pasa, la F es el que falla y los guiones son los que se saltan porque el escenario ya ha fallado. El fallo dice justo lo que falta: el mensaje al añadir el libro.

5. Programa lo mínimo para que pase (verde)

export class Tienda {
  #catalogo;
  #carrito = [];

  constructor(catalogo) {
    this.#catalogo = [...catalogo];
  }

  anadirAlCarrito(titulo) {
    this.#catalogo = this.#catalogo.filter((libro) => libro !== titulo);
    this.#carrito.push(titulo);
    return `El libro ${titulo} ha sido añadido al carrito`;
  }

  carrito() {
    return [...this.#carrito];
  }

  catalogo() {
    return [...this.#catalogo];
  }
}
.....

1 scenario (1 passed)
5 steps (5 passed)

La historia cumple lo acordado con el cliente. Ahora toca la tercera fase de TDD: refactorizar con la red de seguridad del test.

El flujo de trabajo: de fuera hacia dentro

Para cada test de aceptación habrá un conjunto de tests unitarios y de integración más finos (qué es cada nivel). Primero ayudan a diseñar el software y, después, confirman que funciona como querían sus creadores. Es un doble ciclo: el test de aceptación marca la meta y los de TDD, los pasos para llegar.

Doble ciclo de ATDD: fuera, el test de aceptación en rojo marca la meta; dentro, varios ciclos de TDD (rojo, verde y refactor) con tests unitarios y de integración son los pasos para llegar; después, el test de aceptación en verde, que cumple lo acordado con el cliente, un refactor con la red de seguridad del test y el siguiente test de aceptación.
El ciclo de fuera es el del test de aceptación; el de dentro, el recuadro discontinuo, da tantas vueltas de TDD como hagan falta hasta que el test de aceptación pasa a verde.

No empezamos el diseño por una supuesta interfaz gráfica ni por las tablas de la base de datos, sino por los criterios de aceptación. Vamos del lado del negocio al lado técnico, centrados en lo que el cliente pide, ni más ni menos. Diseñado así, de fuera hacia dentro, el código es más fácil de cambiar. Lo cuento con más detalle en Inside-out TDD y Outside-in TDD.

Estimación

Una historia aislada sigue siendo difícil de estimar, incluso con este formato. A base de iterar, estimar en cada iteración y hacer una retrospectiva al final, se afina la habilidad de escribir historias y estimarlas.

Qué y no cómo

Una de las claves de ATDD es que nos centra en el qué y no en el cómo. Preguntamos al cliente qué quiere, no cómo lo quiere. Evitamos los ejemplos que se meten en cómo hacerlo.

Dice qué (bien)

  • Buscar «Tenerife» muestra los pisos de toda la provincia
  • Añadir un festivo lo deja anotado en el calendario
  • Borrar unos pedidos hace que dejen de aparecer

Dice cómo (evítalo)

  • Al rellenar el cuadro de búsqueda y pulsar el botón, los resultados salen en la tabla de la derecha
  • Los libros se guardan en la tabla Libro con los campos id, título y autor
  • Seleccionar «borrar» en el desplegable, marcar las líneas y pulsar «aplicar»

Otros ejemplos que se meten en el cómo:

- Al introducir la fecha y hacer clic en el botón de añadir,
  se crea un nuevo registro vacío
- Una web con destornilladores y tornillos girando en 3D
  para vender los artículos de mi ferretería por internet

Si partimos de especificaciones así, corremos el riesgo de pasar por alto el verdadero propósito de la aplicación: la información que de verdad aporta valor al negocio del cliente.

Las reuniones con el cliente

Con ATDD nos convertimos un poco en psicólogos en lugar de pretender ser adivinos. Colaborando, encontramos y ordenamos la información que más beneficio da al usuario.

En las primeras reuniones solo hay que identificar los módulos con valor de negocio, es decir, los conjuntos que tienen relación con una estrategia de negocio: un servicio de venta, de alquiler, de consultoría…

Una descripción insuficiente:

- Buscando por Santa Cruz de Tenerife, aparece una lista de pisos en alquiler.

Los ejemplos que pueden salir de ella:

- Buscando con un precio inferior a 600 € y el texto «Santa Cruz de Tenerife»,
  el sistema muestra los pisos de esa ciudad que no superan los 600 € al mes
- Buscando con un precio entre 500 € y 700 €, 2 habitaciones y el texto
  «Santa Cruz de Tenerife», el sistema muestra los pisos que cumplen las tres condiciones
- Buscando con 3 habitaciones, 2 cuartos de baño y el texto
  «Santa Cruz de Tenerife», el sistema muestra los pisos que cumplen las tres condiciones
- Buscando con el texto «Tenerife», el sistema muestra los pisos
  de toda la provincia de Santa Cruz de Tenerife
- En la lista, cada piso se muestra con una fotografía
  y el número de habitaciones que tiene

Cuando el cliente ve estos ejemplos, descubre él mismo dudas sobre lo que necesita. Suele preguntar: «¿Hay que pensar todas estas cosas?». Y la respuesta es que sí: los ordenadores siguen siendo máquinas muy tontas, y si esas decisiones de negocio no las toma él, las tendremos que tomar nosotros, que no somos expertos en su negocio.

A partir de ahí se involucra más en el desarrollo y todos empezamos a hablar el mismo idioma.

Tests de aceptación como especificación para un agente de IA

Lo de las máquinas tontas vale hoy también para los agentes de IA, con un matiz: un agente no se queda parado ante una duda, la rellena con lo que le parece más probable. Si nadie ha decidido qué pasa cuando el libro no está en stock, el agente lo decidirá por ti, y es posible que ni te enteres.

Por eso los tests de aceptación encajan tan bien con IA Limpia: son una especificación que el agente puede ejecutar, no solo leer. En el spec-driven development, en cambio, suele quedarse en Markdown y hace falta un test que la ate al código. Es un criterio propio, no una práctica que hayan formulado los autores de ATDD o BDD. Así se puede aplicar:

  1. Acuerda los ejemplos con personas. El fichero .feature sale de la conversación con negocio y calidad, no del agente. Puedes pedirle que proponga casos que se te han escapado, pero quien decide eres tú.
  2. Déjalo en rojo antes de pedir nada. Ejecuta los tests y comprueba que fallan por la razón esperada. Así sabes que miden algo.
  3. Da al agente la meta y los límites. Que el objetivo sea poner esos tests en verde, sin tocar los ficheros de features/, y avanzando con TDD.
  4. Revisa como revisarías a un compañero. Que pasen los tests no basta: mira que no haya cambiado la especificación (git diff --stat features/) y que el código se entienda.

Una plantilla de encargo podría ser esta:

Objetivo: que pase el escenario de features/carrito.feature (npx cucumber-js).
No modifiques nada dentro de features/. Si crees que un ejemplo está mal
o falta un caso, para y pregúntame.
Trabaja con TDD: un test unitario que falla, el código mínimo y refactor.
Cuando termines, enséñame la salida de npx cucumber-js y un resumen del diseño.
Si no decides tú qué debe pasar, lo decidirá el agente.

Tiene límites, y conviene tenerlos presentes:

  • Solo cubre lo que escribiste. Un agente puede dejar todo en verde y romper algo que ningún ejemplo describe.
  • Un test se puede «aprobar» haciendo trampa, por ejemplo devolviendo justo el texto esperado sin lógica detrás. Por eso hace falta más de un ejemplo por regla y una revisión humana.
  • No sustituye la conversación con el cliente. El valor de ATDD está en ponerse de acuerdo; el agente solo llega después.

Ventajas de ATDD

  • No trabajamos en funciones que al final no se van a usar.
  • El código está listo para cambiar porque su diseño no depende de una base de datos ni de una interfaz de usuario.
  • Se comprueba muy rápido si el programa cumple los objetivos.
  • Sabemos en qué punto estamos y cómo avanzamos.
  • El dueño de producto puede revisar los tests de aceptación y ver cuántos se cumplen, así que el trabajo del equipo gana confianza.
  • Con agentes de IA, son una especificación que se puede ejecutar y que avisa en cuanto el agente se aparta de lo acordado.

Es una gran manera de fomentar una colaboración estrecha entre todos los roles del equipo.

Tu siguiente paso

Elige una historia pequeña de tu proyecto, escribe con alguien de negocio tres ejemplos en Gherkin y ejecútalos con Cucumber antes de programar. Si quieres repasar antes el ciclo de TDD, empieza por TDD, Test Driven Development.

Fuentes

Comprobado en noviembre de 2026:

  • Agile Alliance, glosario: Acceptance Test Driven Development (ATDD). Definición, los «tres amigos» y los nombres alternativos (SDD, Specification by Example, BDD).
  • Dan North, Introducing BDD, publicado en Better Software en marzo de 2006. Origen de BDD y cómo, con Chris Matts, empezaron a escribir los criterios de aceptación como escenarios Given/When/Then.
  • Gojko Adzic, Specification by Example (2011), libro basado en casos de más de 50 proyectos.
  • Documentación oficial de Cucumber: referencia de Gherkin, idiomas de Gherkin (palabras clave en español) y qué es BDD.
  • La base del texto original es el libro Diseño Ágil con TDD, de Carlos Blé.

El ejemplo se ha ejecutado con Node.js 24.21.0 y @cucumber/cucumber 13.3.0 en Linux. Las salidas que aparecen son las reales (en la del fallo se ha quitado la ruta de la traza y el tiempo de ejecución).