Este post es continuación de este otro.

Supongamos que tenemos una aplicación que necesita recuperar una cadena. El Test que acá vamos a desarrollar es probar la recuperación de esta cadena.

Ya tendríamos que tener instalada la última versión de NUnit. Sino, podemos descargarla desde http://www.nunit.org e instalarla.

En el marco de nuestra solución vamos a agregar un proyecto de tipo Class Library donde iremos escribiendo el Test. El ejemplo lo desarrollo en Visual Basic .NET y C#.

Una característica curiosa de esta técnica es que estos proyectos no se ejecutan, sólo se compilan y la dll resultante es la que se prueba con la herramienta.

En el proyecto de test hay que agregar las referencias que exige NUnit, buscamos en la carpeta bin de la instalación de NUnit, tipicamente C:\Program Files\NUnit 2.4.6\bin dependiendo de la versión de la heramienta. Estas referencias son nunit.core y nunit.framework.

VB

En C# hay que agregar una referencia más, nunit.core.interfaces.dll

Para definir una clase básica para comenzar a practicar TDD veamos estos ejemplos:

C#

using nunit.core;

using nunit.framework;

 

namespace SyPCS.Test

{

    [TestFixture]

    public class Class1

    {

 

    }

}

VB

Imports NUnit.Core

Imports NUnit.Framework

 

Namespace SyPVB.Test

    <TestFixture()> _

    Public Class Class1

 

    End Class

End Namespace

Tenemos dos elementos novedosos. En primer lugar tenemos que importar las dlls de NUnit que posibilitan el trabajo con la herramienta y en segundo lugar el tag TestFixture que posibilita que NUnit reconozca a la clase como contenedore de Tests.

Compilemos esto.

Ya tenemos la base para programar nuestro primer Test.

Nuestra aplicación tiene que ser capaz de leer un valor que se recupera desde algún elemento de persistencia. De esto se tratará nuestro Test.

Entonces, siguiendo con el esquema de Ciclo TDD que presenté en el post anterior,

  • Escribir un Test, aún de algo que todavía no hayamos codificado,
  • Compilar, va a dar error, ya que todavía no hemos codificado lo que estamos probando,
  • Escribir la mínima cantidad de código para que compile, aunque sea la cabecera del método o función a probar,
  • Compilar, ahora no da error, estamos en condiciones de ejecutar nuestro Test,
  • Ejecutar el Test, falla, ya que habíamos escrito la mínima cantidad de código que garantice la compilación, pero no la ejecución del Test,
  • Escribir la mínima cantidad de código para que el Test no falle,
  • Ejecutar el Test, esta vez no falla,
  • Refactorizar, este es un tema aparte, hay variadas técnicas de refactorización y muchos buenos libros escritos, más adelante veremos someramente alguna de esas técnicas,
  • Recomenzar escribiendo un nuevo Test.

Comienzo por Escribir un Test, aún de algo que todavía no hayamos codificado:

C#

using NUnit.Core;

using NUnit.Framework;

 

namespace SyPCS.Test

{

    [TestFixture]

    public class Class1

    {

        [Test]

        public void Prueba

        {

            Recupera recupera = new Recupera;

            Assert.IsNotNull(recupera.Valor);

        }

    }

}

VB

Imports NUnit.Core

Imports NUnit.Framework

 

Namespace SyPVB.Test

    <TestFixture()> _

    Public Class Class1

        <Test()> _

        Public Sub Prueba()

            Dim mRecupera As New Recupera

            Assert.IsNotNull(mRecupera.Valor)

        End Sub

    End Class

End Namespace

Si. Ya sé…

Yo también me indigné la primera vez que vi algo como esto…

Obviamente… no compila…

No hay nada declarado con el nombre Recupera y menos su propiedad Valor.

Pero esta es la idea.

El segundo paso es Compilar.

Y falla, como se lee en el ciclo TDD.

Ahora tenemos que Escribir la mínima cantidad de código para que compile

Entonces voy a crear dos proyectos, uno C# y otro VB, ambos de tipo Class Library (para hacerlo más simple) que jugarán el papel de proyectos de desarrollo.

En ambos codificamos una función de nombre Valor.

C#

public class Recupera

{

    public void Valor()

    {

 

    }

}

VB

Public Class Recupera

    Public Function Valor()

 

    End Function

End Class

Compilamos ambos proyectos.

Ahora vamos a los proyectos de Testing, en cada uno de ellos agregamos una referencia, en TestCS agregamos la referencia a SyPCS y en TestVB agregamos una a SyPVB.

De esa forma podemos adicionar al código el using (en C#) o Imports (en VB) que corresponda.

Quedando así:

C#

using NUnit.Core;

using NUnit.Framework;

using SyPCS;

 

namespace SyPCS.Test

{

    [TestFixture]

    public class Class1

    {

        [Test]

        public void Prueba()

        {

            Recupera recupera = new Recupera();

            string s = recupera.Valor();

            Assert.IsNotNull(s);

        }

    }

}

 

VB

Imports NUnit.Core

Imports NUnit.Framework

Imports SyPVB

 

Namespace SyPVB.Test

    <TestFixture()> _

    Public Class Class1

        <Test()> _

        Public Sub Prueba()

            Dim mRecupera As New Recupera

            Dim s As String = mRecupera.Valor

            Assert.IsNotNull(s)

        End Sub

    End Class

End Namespace

Según el ciclo, nuestro próximo paso es Compilar.

Y compila. Estamos en condiciones de ejecutar nuestro primer Test.

Abrimos NUnit y vemos su IDE:

Vamos a File/New Project y le ponemos el nombre Ejemplo:

Ahora vamos a Project/Add assembly… y seleccionamos la dll de alguno de los proyectos de Testing, por ejemplo el de VB:

y veremos lo siguiente:

Vemos que el árbol de Test se ve en el Gris de Refactoring.

Siguiendo en el Cliclo TDD ejecutamos el Test. Hacemos Click sobre el botón Run en NUnit y …

¡Falló!…

Tal como dicta el Ciclo TDD.

Sigamos con Escribir la mínima cantidad de código para que el Test no falle.

Hacemos que nuestra función Valor devuelva un string cualquiera:

C#

public class Recupera

{

    public string Valor()

    {

        return “Prueba”;

    }

}

 

VB

Public Class Recupera

    Public Function Valor() As String

        Return “Prueba”

    End Function

End Class

Y volvemos a compilar los cuatro proyectos, primero los de Desarrollo, luego los de Prueba.

Volvemos a NUnit y vemos todo en Gris nuevamente:

Y ahora hacemos click nuevamente en Run y …

¡¡¡Green!!!

Anduvo. Según el Ciclo TDD nos toca Refactorizar.

Pero esto… en el próximo post. :)