La Diferencia entre Programación DGP y DGC (TDD vs BDD)

Dos de las corrientes de Desarrollo más comunes actualmente son el Desarrollo Guiado por Pruebas (DGP) y el Desarrollo Guiado por Comportamiento (DGC). En este artículo vamos a darte una breve explicación de lo que cada corriente involucra, incluyendo el contraste entre ambas.

Desarrollo Guiado por Pruebas

Primero se define una lista de requisitos y después se ejecuta el siguiente ciclo:

1. Elegir un requisito. Se elige de una lista el requisito que se cree nos dará mayor conocimiento del problema y que a la vez sea sencillo de implementar
2. Escribir una prueba.  Se comienza escribiendo una prueba para el requisito. Para ello el programador debe entender claramente las especificaciones y los requisitos de la funcionalidad que está por implementar.
3. Verificar que la prueba falla. Si la prueba no falla es porque el requisito ya estaba implementado o porque la prueba es errónea.
4. Escribir la implementación. Escribir el código más sencillo que haga que la prueba funcione.
5. Ejecutar las pruebas automatizadas. Verificar si todo el conjunto de pruebas funciona correctamente.
6. Eliminación de duplicación. El paso final es la refactorización, que se utilizará principalmente para eliminar código duplicado.
7. Actualización de la lista de requisitos. Se actualiza la lista de requisitos tachando el requisito implementado.

Ejemplo:

Digamos que un desarrollador quiere escribir una función que calcule un factorial. Para este ejemplo, vamos a utilizar un Framework de pruebas de JavaScript llamado Mocha.

Aquí tenemos las pruebas:

var assert = require('assert'),
    factorial = require('../index');

suite('Test', function (){
    setup(function (){
    });

    suite('#factorial()', function (){
        test('equals 1 for sets of zero length', function (){
            assert.equal(1, factorial(0));
        });

        test('equals 1 for sets of length one', function (){
            assert.equal(1, factorial(1));
        });

        test('equals 2 for sets of length two', function (){
            assert.equal(2, factorial(2));
        });

        test('equals 6 for sets of length three', function (){
            assert.equal(6, factorial(3));
        });
    });
});

Estas pruebas deberán fallar debido a que la función no ha sido declarada aún. Escribamos la función para cumplir con las pruebas:

module.exports = function (n) {
    if (n < 0) return NaN;
    if (n === 0) return 1;

    return n * factorial(n - 1);
};

Ahora, si realizamos las pruebas, veremos que son satisfechas con éxito. Y así es como el DGP funciona.

Desarrollo Guiado por Comportamiento

El objetivo principal del DGC es eliminar los errores que el DGP pueda ocasionar.
Ejemplo:

var assert = require('assert'),
    factorial = require('../index');

describe('Test', function (){
    before(function(){
    });

    describe('#factorial()', function (){
        it('should return 1 when given 0', function (){
            factorial(0).should.equal(1);
        });

        it('should return 1 when given 1', function (){
            factorial(1).should.equal(1);
        });

        it('should return 2 when given 2', function (){
            factorial(2).should.equal(2);
        });

        it('should return 6 when given 3', function (){
            factorial(3).should.equal(6);
        });
    });

    after(function () {
    });
});

La diferencia principal es el texto, pues en este caso se utiliza un estilo más detallado para que pueda ser leído casi como una oración.
El argumento es que si puedes leer tu código de manera fluida, naturalmente escribirás pruebas mejores y más entendibles.

¿Qué corriente prefieres tú? Cuéntanos en un comentario.