Test unitarios y NUnit

Las máquinas no hacen lo que quieren, hacen lo que nosotros les decimos que hagan.

No sé muy bien dónde lo escuché, ni quien me lo dijo, o si lo vi en algún articulo o en una ppt. Pero es una verdad como un templo. Cuando escribimos código, tanto para un hola mundo como para un sistema de control de un aeropuerto, lo que esperamos de nuestros aporreos de teclado es lo que hagan lo que estábamos pensando mientras escribíamos.

Hay una gran diferencia entre lo que un programador piensa que debe hacer su código y lo que realmente hace el código recién escrito. Y ya no digamos del código que escribimos hace unas semanas.

Hace relativamente mucho tiempo que aparecieron los primeros frameworks para realizar test unitarios, y se van mejorando cada día. Pero, ¿qué son los test unitarios?, para los que no lo sepáis aún, según Ron Jeffries:  “ son programas escritos para ejecutarse uno tras otro. Normalmente comprueban que ante unas entradas predefinidas, los resultados obtenidos van a ser siempre los mismos.”

Es decir, son programas que van a comprobar que nuestro código haga lo que esperamos que haga.

NUnit.

NUnit es un framework más para poder realizar de forma homogénea y estructurada los menesteres que he descrito en el apartado anterior.

Por intentar demostrar que me he mirado esto un poco a fondo, aunque no mucho, os cuento que NUnit es la implementación para la plataforma .NET de otro framework para hacer test unitarios, JUnit. JUnit es un framework para realizar test unitarios para la plataforma Java, que a su vez viene de la plataforma … (y aquí me cansé de investigar).

Todo el tema de los test unitarios ha surgido con las técnicas de desarrollo rápido Extreme Programming. Éstas últimas son técnicas de programación usadas para explotar varios factores del desarrollo software, como son la calidad, claridad, tiempo de desarrollo, eficiencia, y un largo etcétera.

Al grano.
Hablando en plata (“talking in silver”) , básicamente lo que necesitamos para poder hacer test unitarios con NUnit es:  Primero descargárnoslo desde www.nunit.com, y lo segundo es instalarlo.

Una vez lo tengamos instalado ya podemos ponernos a hacer test a mansalva.
La forma en que los hago yo es la siguiente: Me creo un nuevo proyecto de librería C# en visual studio, le añado la referencia a la dll de NUnit. (En la documentación de NUnit os dice dónde la podéis encontrar).

Y listo, ya puedo crear las clases que testearan lo que yo quiera.

Sólo hay que tener en cuenta un par de cosas:

1. Añadir el atributo TestFixture  a las clases que van a contener los test, por ejempo:

using System;
using NUnit.Framework;
namespace UnitTestingExample
{
    [TestFixture]
    public class SomeTests
    {
    }
}

2. Tenemos que indicar los métodos que van a hacer los test mediante el atributo Test

 [TestFixture]
  public class SomeTests
  {
    [Test]
    public void UnTest()
    {
           //Hacer algo
    }
  }

Y listo, ya podemos testear lo que queramos.

NUnit nos ofrece un interfaz gráfico para ver los resultados de los test. ¿Cómo lo vemos? Muy fácil, compilamos nuestra librería, ejecutamos el interfaz gráfica que NUnit tiene preparado, en el menú File, seleccionamos Open, y podemos seleccionar la dll compilada que hemos generado con visual studio.

Muchas veces es necesario inicializar algunas cosas para que los test puedan ejecutarse. Por ejemplo, que haya un elemento en la base de datos, que se haya inicializado el valor de algunas variables, etc..

Para ello, están los atributos [TestFixtureSetUp] y  [TestFixtureTearDown]. El primero inicializa todo lo que haya que inicializar ANTES de ejecutar los test, y la última se ejecutará DESPUÉS de ejecutar todos los test, de esta forma:

[TestFixtureSetUp]
public void MetodoDeSetup()
{
  //Código necesario para la inicialización
}

[TestFixtureTearDown]
public void MetodoDeTearDown()
{
  //Codigo
}

Pues nada, espero que os sirva tanto como me ha servido a mi.

Pero NUnit no se queda sólo en esto, tiene muchas cosas más que dejaremos para otros post.

Hope this help.

Autor: Juan María Laó Ramos. Microsoft Student Partner

8 pensamientos en “Test unitarios y NUnit

  1. Christian López Espínola

    Añade esto a tu librería de tests, y te ahorras abrir el ensamblado en NUnit-GUI:

    using System;
    using System.Collections.Generic;
    using System.Windows.Forms;
    using NUnit.Framework;

    static class Program
    {
    static void Main (string[] args)
    {
    NUnit.Gui.AppEntry.Main(new string [] { System.Reflection.Assembly.GetExecutingAssembly().Location });
    }
    }
    }

    Ya sólo dale a “Play” en el VS

    Hope this helps,
    Christian López Espínola

  2. Vio

    Hubiera querido dejarlo para otro post, pero muchas gracias Penyaskito.
    Así es, con esa línea se lanza la interfaz de usuario que tiene NUnit. para no tener que estar abriendola y cargando las librerías que queramos testear.

  3. niniramos

    Buen post, una vez más se demuestra la habilidad de Microsoft (y sus chicos) en copiar cosas que funcionan en otras plataformas/lenguajes. En cualquier caso buen post.

    🙂

    1. Juanma

      Si los javeros también demuestran sus habilidades portanto XUnit a java a.k.a. JUnit, por lo tanto, los javeros copian cosas que funcionan en otras plataformas.
      Sómos todos iguales al fin y al cabo… Unos mercenarios. El que me pague más.
      Gracias por el comentario.

  4. Pingback: Las 5 maneras en las que hago pruebas con ASP.NET | rlbisbe @ dev

Los comentarios están cerrados.