TDD, BDD y Gherkin: guia practica para entenderlos y escribirlos bien

# tests/test_descuentos.py
from app.descuentos import calcular_descuento


def test_sin_descuento_por_debajo_de_1000():
    assert calcular_descuento(999) == 0

$ pytest -q
E   ModuleNotFoundError: No module named 'app.descuentos'
1 error in 0.04s

# app/descuentos.py
def calcular_descuento(total):
    return 0

def test_diez_por_ciento_entre_1000_y_5000():
    assert calcular_descuento(1000) == 100
    assert calcular_descuento(4999) == 499.9

def calcular_descuento(total):
    if total < 1000:
        return 0
    return total * 0.10

def test_veinte_por_ciento_desde_5000():
    assert calcular_descuento(5000) == 1000
    assert calcular_descuento(12000) == 2400


def test_monto_negativo_es_invalido():
    import pytest
    with pytest.raises(ValueError):
        calcular_descuento(-1)

def calcular_descuento(total):
    if total < 0:
        raise ValueError("El total no puede ser negativo")
    if total < 1000:
        return 0
    if total < 5000:
        return total * 0.10
    return total * 0.20

from decimal import Decimal

# Tramos: (monto_minimo, porcentaje). Ordenados de mayor a menor.
TRAMOS = (
    (Decimal("5000"), Decimal("0.20")),
    (Decimal("1000"), Decimal("0.10")),
    (Decimal("0"),    Decimal("0.00")),
)


def calcular_descuento(total):
    total = Decimal(str(total))
    if total < 0:
        raise ValueError("El total no puede ser negativo")

    for minimo, porcentaje in TRAMOS:
        if total >= minimo:
            return total * porcentaje

    return Decimal("0")

   +---------------------+   "que problema
   |  Negocio / Producto |    queremos resolver?"
   +----------+----------+
              |
   +----------+----------+   "como lo
   |     Desarrollo      |    construimos?"
   +----------+----------+
              |
   +----------+----------+   "que pasa si...?"
   |    QA / Testing     |    (casos borde)
   +---------------------+

   LOOP EXTERNO (BDD / comportamiento - lenguaje de negocio)
   +----------------------------------------------------------+
   |                                                          |
   |   escribir escenario  -->  escenario en ROJO             |
   |          ^                        |                      |
   |          |                        v                      |
   |          |        LOOP INTERNO (TDD / unidades)          |
   |          |        +------------------------------+       |
   |          |        | test rojo -> codigo -> verde |       |
   |          |        |       ^                |     |       |
   |          |        |       +---- refactor <-+     |       |
   |          |        +------------------------------+       |
   |          |                        |                      |
   |          +---- escenario en VERDE +                      |
   |                                                          |
   +----------------------------------------------------------+

  Feature:          titulo y descripcion del conjunto de comportamientos
    |
    +-- Rule:       (opcional, Gherkin 6+) agrupa escenarios por regla de negocio
    |
    +-- Background: pasos comunes que corren antes de CADA escenario
    |
    +-- Scenario:   un ejemplo concreto de comportamiento
    |     |
    |     +-- Given  contexto / estado inicial
    |     +-- When   la accion que dispara el comportamiento
    |     +-- Then   el resultado esperado (observable)
    |     +-- And / But   encadenan al paso anterior
    |
    +-- Scenario Outline: plantilla parametrizada
          +-- Examples: tabla de datos que la alimenta

# language: es
@transferencias @critico
Característica: Transferencias entre cuentas propias

  Como cliente del banco
  Quiero transferir dinero entre mis cuentas
  Para administrar mis fondos sin ir a una sucursal

  Antecedentes:
    Dado que estoy autenticado como "mlopez"
    Y tengo una caja de ahorro "CA-001" con saldo de 50000 pesos
    Y tengo una cuenta corriente "CC-002" con saldo de 10000 pesos

  Escenario: Transferencia exitosa entre cuentas propias
    Cuando transfiero 20000 pesos desde "CA-001" hacia "CC-002"
    Entonces la operación se confirma
    Y el saldo de "CA-001" es 30000 pesos
    Y el saldo de "CC-002" es 30000 pesos
    Y recibo un comprobante con número de operación

  Escenario: Se rechaza la transferencia por saldo insuficiente
    Cuando transfiero 80000 pesos desde "CA-001" hacia "CC-002"
    Entonces la operación es rechazada
    Y veo el mensaje "Saldo insuficiente"
    Y los saldos de mis cuentas no se modifican

  Esquema del escenario: Validación de montos inválidos
    Cuando transfiero <monto> pesos desde "CA-001" hacia "CC-002"
    Entonces la operación es rechazada
    Y veo el mensaje "<mensaje>"

    Ejemplos:
      | monto  | mensaje                             |
      | 0      | El monto debe ser mayor a cero      |
      | -500   | El monto debe ser mayor a cero      |
      | 999999 | Supera el límite diario de 500000   |

# features/steps/transferencias.py
from behave import given, when, then
from app.banco import Banco, SaldoInsuficiente, MontoInvalido


@given('que estoy autenticado como "{usuario}"')
def step_autenticar(context, usuario):
    context.banco = Banco()
    context.sesion = context.banco.login(usuario)


@given('tengo una {tipo} "{numero}" con saldo de {saldo:d} pesos')
def step_crear_cuenta(context, tipo, numero, saldo):
    context.banco.abrir_cuenta(context.sesion, numero, tipo, saldo)


@when('transfiero {monto:d} pesos desde "{origen}" hacia "{destino}"')
def step_transferir(context, monto, origen, destino):
    context.error = None
    try:
        context.resultado = context.banco.transferir(
            context.sesion, origen, destino, monto
        )
    except (SaldoInsuficiente, MontoInvalido) as e:
        context.error = e


@then('la operación se confirma')
def step_confirmada(context):
    assert context.error is None, f"Fallo inesperado: {context.error}"
    assert context.resultado.estado == "CONFIRMADA"


@then('la operación es rechazada')
def step_rechazada(context):
    assert context.error is not None, "Se esperaba un rechazo"


@then('el saldo de "{numero}" es {esperado:d} pesos')
def step_verificar_saldo(context, numero, esperado):
    real = context.banco.consultar_saldo(context.sesion, numero)
    assert real == esperado, f"Esperado {esperado}, obtenido {real}"


@then('veo el mensaje "{mensaje}"')
def step_mensaje(context, mensaje):
    assert str(context.error) == mensaje

// features/step_definitions/transferencias.js
const { Given, When, Then } = require('@cucumber/cucumber');
const assert = require('assert');
const { Banco, SaldoInsuficiente } = require('../../src/banco');

Given('que estoy autenticado como {string}', function (usuario) {
  this.banco = new Banco();
  this.sesion = this.banco.login(usuario);
});

When(
  'transfiero {int} pesos desde {string} hacia {string}',
  function (monto, origen, destino) {
    this.error = null;
    try {
      this.resultado = this.banco.transferir(this.sesion, origen, destino, monto);
    } catch (e) {
      this.error = e;
    }
  }
);

Then('el saldo de {string} es {int} pesos', function (numero, esperado) {
  const real = this.banco.consultarSaldo(this.sesion, numero);
  assert.strictEqual(real, esperado);
});

# Python / behave
behave --tags=@critico --lang=es

# JavaScript / Cucumber.js
npx cucumber-js --tags "@critico and not @wip"

# Java / Cucumber-JVM con Maven
mvn test -Dcucumber.filter.tags="@critico"

Escenario: Login
  Dado que abro el navegador en "https://banco.com/login"
  Cuando escribo "mlopez" en el campo con id "#username"
  Y escribo "secreto123" en el campo con id "#password"
  Y hago clic en el botón ".btn-primary"
  Y espero 3 segundos
  Entonces veo el div con clase ".dashboard-container"

Escenario: Login exitoso con credenciales válidas
  Dado que soy un cliente registrado
  Cuando ingreso con mis credenciales válidas
  Entonces accedo a mi panel de cuentas