Programación ágil (TDD en C#) -Introducción

Hola a todos.

Tras la fiestas navideñas,me incorporo con el ánimo y el propósito de añadir y mantener actualizado este blog ( a ver si el trabajo me deja algo de tiempo ;P).

El tema que hoy voy a tratar, era desconocido para mi,supongo que a más de uno le pasará lo mismo y hasta hace poco no he empezado a aplicarlo en el ambito laboral.Se trata de la programación ágil..

Esta metodología fomenta las iteraciones en el desarrollo de las aplicaciones, a lo largo de todo el ciclo de vida del proyecto.
Cada iteración consta de :

• Planificación
• Análisis
• Diseño y codificación
• Revisión y documentación.

Esta técnica de programación enfatiza la comunicación cara a cara con el cliente.Siendo la responsable de mostrar al cliente como la aplicación va evolucionando en cada iteración cubriendo todas las pruebas de aceptación(requisitos funcionales).Se trata de poder mostrar una demo totalmente funcional en cada iteración.

TDD Test Driven Development o Desarrollo dirigido por Test,habla de la arquitectura surgida a base de iterar y refactorizar , en lugar de diseñarla completamente de antemano.

Algorítmo TDD:

1.Escribir la especificación del requisito

2.Implementar el código según el requisito

3.Refactorizar para eliminar la duplicidad.

Es cierto que implementar siguiendo esta técnica,hará que tardemos más en el desarrollo inicial,pero tendremos la certeza de que nuestra aplicación funcionarás bajo cualquier circunstancia.

Si a esto le añadimos la cobertura de código,sabremos el porcentaje desarrollado correctamente con respecto al total y esto es de gran utilidad para el cliente,ya que ve en todo momento el progreso del equipo.
En este post voy a mostrar un pequeño ejemplo para C# usando NUnit.

Comencemos.

La idea: Crear una calculadora de aritmética básica.

Suponemos nuestra prueba de aceptación es: la suma.

Debemos desarrollar las pruebas unitarias que verifiquen que mi implementación es correcta.Para ello, primero voy a definir el test que tiene que superar y con respecto a eso,especifico el método que usaremos en nuestra aplicación.

Es importante señalar ,que el código debe ser lo más simple posible,para que a medida que vayamos haciendo pruebas al mismo método vayamos modificandolo para el correcto funcionamiento.

Pasos:

1.Para empezar a usar NUnits desacagamos de esta web la aplicación que nos indicará la aceptación o rechazo de las pruebas realizadas

2.Abrimos Visual Studio y creamos dos proyectos de libreria de clases en la misma solución.A una la llamaremos BasicAritmethic y la segunda BasicAritmethics.Test

3.En el proyecto BasicArithmetics.Test añadimos las referencias a NUnits.Se encuentran en la carpeta bin del directorio de instalación de NUnits(según la versión instalada) añadimos las librerias core y framework.

4.En el proyecto Test las importamos y tambien el proyecto BasicAritmethic.

5.Creamos la primera prueba ,la cual será muy simple,queremos comprobar que dos numero se sumen y den un valor correcto

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using NUnit.Framework;
using BasicAritmethic;

namespace BasicAritmethics.Test
{
    [TestFixture]
    public class CalculatorTest
    {
        [Test]
        public void Add()
        {
            
            Calculator calculator = new Calculator();
            int result = calculator.Add(2, 2);
            Assert.AreEqual(4,result);

        }

El código anterior muestra la etiqueta TestFixture,indica que la clase es un conjunto de test(test case) y la etiqueta Test por deducción ,es una prueba test.
En este momento no hemos implementado la clase Calculator,con lo cual a estas alturas nos daría error de compilación,pero no pasa nada,si nos damos cuenta hemos sido capaces de modelar el constructor y los parámetros que precisará el método Add.Hemos definido según la necesidad que tenemos ,esto hace que nuestro código sea más preciso.

Hemos indicado que el objeto calculator calcule con Add 2+2, y ese valor se almacene en una variable,que seguidamente usaremos para comparar su resultado.

6.Ahora implementamos en la clase BasicArithmetic el constructor y el método Add.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace BasicAritmethic
{
    public class Calculator
    {
        public Calculator()
        {

        }
        public int Add(int valor1,int valor2)
        {
            return 4;

        }
    }
}

Lo se…,¿porqué no generalizo?Cuando empezamos con las pruebas unitarias ,no tenemos la suficiente pericia para hacer casos básicos que muestren la exactitud del método,por eso recomiendan que el código vaya evolucionando a medida que vamos implementando las pruebas para tener la certeza que cumple todos los casos.En este ejemplo es tán básico que no tiene sentido,pero no pasa nada,así nos servirá para ver cuando la prueba falla…eso lo mostraré en un par de pasos.

7.En este punto,nuestra aplicación no tiene errores ,todos los métodos están definidos.Compilamos

8.Ejecutamos NUnits,creamos un nuevo proyecto File/New Proyect

9.Abrimos nuestra .dll BasicAritmethic.Test ,haciendo esto aparecerá un árbol con las pruebas que tenemos implementadas

10.Pulsamos el botón Run ,como podemos ver, todo ha ido bien y las pruebas se han pasado con éxito.

11.Ahora vamos a crear otra prueba, para seguir testando el método Add,es este ejemplo vamos a sumar otras numero,pero vamos a mantener el método de BasicAritmethic como estaba.

        [Test]

        public void Add1()
        {

            Calculator calculator = new Calculator();
            int result = calculator.Add(5, 2);
            Assert.AreEqual(7, result);
        }

12.Compilamos y pulsamos el botón Run de NUnits.Como podíamos intuir la prueba no es correcta.En el ejemplo puesto,sabemos perfectamente el dominio de la aplicación y somos capaces de dar con la implementación adecuada sin pensarlo dos veces ,pero hay veces que no conocemos en profundidad la extensión del dominio e ir desarrollando poco a poco en base a los resultados del test hace que demos con la mejor solución.

13.Tras esto ,sólo queda generalizar,compilar y pulsar Run.Como vemos todo OK.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace BasicAritmethic
{
    public class Calculator
    {
        public Calculator()
        {

        }
        public int Add(int valor1,int valor2)
        {
            return valor1+valor2;

        }
    }
}

14.Ahora toca refactorizar,eliminar duplicidades en el código del Test.En las dos pruebas Test hemos hecho la llamada al constructor,para evitar esto hacemos uso de un método específico [SET UP] encargado de crear variables y definir el escenario adecuado para el método a testear.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using NUnit.Framework;
using BasicAritmethic;

namespace BasicAritmethics.Test
{
    [TestFixture]
    public class CalculatorTest
    {
        private Calculator _calculator;

        [SetUp]
        public void SetUp()
        {
            _calculator = new Calculator();
        }
        
        [Test]
        public void Add()
        {
            
            Calculator calculator = new Calculator();
            int result = calculator.Add(2, 2);
            Assert.AreEqual(4,result);

        }

        [Test]

        public void Add1()
        {

            Calculator calculator = new Calculator();
            int result = calculator.Add(5, 2);
            Assert.AreEqual(7, result);
        }
    }
}

Quien quiera ya sabe….quedan por hacer el resto de operaciones 🙂

Este post se ha desarrollado principalmente tras la lectura de un gran libro que encontré por internet “Diseño ágil con TDD” por Carlos Blé Jurado.(Libro gratuito)
Nos vemos en el próximo.
Un saludo.