Abriendo los test
Zanebug viene con cuatro dlls pre compiladas, que demuestran tests en NUnit y Zanebug. Los ejemplos se encuentran bajo la carpeta C:\Program Files\Zanebug\Examples folder.
NUnit v2.1.4 Example C:\Program Files\Zanebug\Examples\Examples.NUnit.v214\bin\Debug\Examples.NUnit.v214.dll NUnit v2.2.0 Example C:\Program Files\Zanebug\Examples\Examples.NUnit.v220\bin\Debug\Examples.NUnit.v220.dll Zanebug v1.4.1 Example C:\Program Files\Zanebug\Examples\Examples.Zanebug.v141\bin\Debug\Examples.Zanebug.v141.dll Zanebug v1.4.2 Example C:\Program Files\Zanebug\Examples\Examples.Zanebug.v142\bin\Debug\Examples.Zanebug.v142.dll
Para cargar todos los tests haga lo siguiente:
Abrá la interfaz de usuario de Zanebug (use el atajo del escritorio, o vaya a )
Una vez que la interfaz esté abierta, seleccione
Puede probar también usando . En la instalación, se coloca una referencia para todos los archivos de ejemplos en el menu de archivos recientes.
Navegue hacia una da las .dlls listadas
Presione Run para ejecutar los tests y mirar los resultados.
Código Fuente
Todos los ejemplos vienen con código fuente completo, localizado en el directorio raiz de cada ejemplo. Este es un excelente lugar para comenzar a cuando se está escribiendo tests.
Escribir tests con Zanebug es fácil. Hay 4 pasos que debe tomar:
Agregar una referencia a la dll del motor de test
Adapdev.UnitTest.dll
Normalmente se encuentra localizado en:
C:\Archivos de Programa\Zanebug\Adapdev.UnitTest.dll
(Sería mas amistos almacenarlo en el GAC, pero esto fue descartado por diversas razones...)
Agregue las referencias a los espacios de nombre en sus clases de prueba
using System;
using Adapdev.UnitTest;
namespace UnitTest
{
public class SimpleClassTest
{
}
}Agrege el atributo [TestFixture] sobre el nombre de la clase
using System;
using Adapdev.UnitTest;
namespace UnitTest
{
[TestFixture]
public class SimpleClassTest
{
}
}Esto le dice al motor de Zanebug que esta clase es una clase de test, y debe ser incluida en el arbol TestSuite. Si usted tiene una clase que contiene metodos marcados con el atributo [Test] pero no está marcada con el atributo [TestFixture], dicha clase sera ignorada por Zanebug.
Agregue el atributo [Test] sobre cada método que quiera correr como test, y la lógica específica para la prueba:
Todos los métodos marcados [Test] deben ser públicos y void sin retorna valor
using System;
using Adapdev.UnitTest;
namespace UnitTest
{
[TestFixture]
public class SimpleClassTest
{
[Test]
public void FirstTest()
{
// ... test logic goes here ...
}
[Test]
public void SecondTest()
{
// ... test logic goes here ...
}
}
}Aunque Zanebug contiene varios otros atributos y características, los pasos anteriores son el corazón de cualquier test unitario.
Para demostrar un test completo, usaremo una versión modificada del famoso ejemplo "Hola Mundo". Primero crearemos una clase simple con dos métodos:
Saludar() - simplemente retorna la "¡Hola!"
Saludar(string nombre) - retorna "¡Hola [nombre]!"
using System;
namespace Ejemplos
{
public class HolaMundo
{
public static string Saludar()
{
return "¡Hola!";
}
public static string Saludar(string nombre)
{
return String.Format("¡Hola {0}!", nombre);
}
}
}
En un ambiente de pruebas tradiciona, esto sería validado con una aplicación de consola simple:
using System;
using Examples;
namespace AplicacionConsola
{
class Clase1
{
[STAThread]
static void Main(string[] args)
{
Console.WriteLine(HolaMundo.Saludar());
Console.WriteLine(HelloWorld.Saludar("Sean"));
Console.ReadLine();
}
}
}
Lo que producirá la siguiente salida:
¡Hola!
¡Hola Sean!
Desafortunadamente esta es una forma muy rudimentaria de probar, y confía en la interacción con un operador humano, para validar que la componente se comportó correctamente. Mientras más compleja sea la componente, más propensa a errores.
Usando Zanebug, los testa automatizados pueden fácilmente ser escritos y re ejecutado de una manera continua. Para probar el ejemplo anterioe, deberíamos escribir el siguiente test unitario:
using System; using Adapdev.UnitTest; using Ejemplos; namespace Ejemplos.Test { [TestFixture] public class HolaMundoTest { [Test] public void Saludar() { Assert.AreEqual("¡Hola!", HolaMundo.Saludar()); } [Test] public void SaludarConNombre() { Assert.AreEqual("¡Hola Sean!", HolaMundo.Saludar("Sean")); } } }
El test anterior es muy simple. El primer test, Saludar(), simplemente valida que el texto retornado desde el método HolaMundo.Saludar() es el texto esperado. El segundo test, hace lo mismo, pero prueba los resultados con un nombre que se le pasa.
En ambas instancaias, la clase Assert se usa para probar el comportamiento. Assert es una parte clave para escribir tests unitarios, ya que es ella la que realmente hace el trabajo. Cuando una asercion es ejecutada, solo dos salidas son posibles, es correcta o incorrecta. If the response is correct, then that portion of the test passes. If the response is incorrect, an AssertionException is thrown and the test immediately fails without continuing.
The Assert class contains multiple methods. Listed below are some of the more common ones (see the API documentation for a full list):
AreEqual(object o1, object o2)
Valida que dos objetos son iguales.
string name1 = "Joe"; string name2 = "Joe"; string name3 = "Joe Schmoe"; Assert.AreEqual(name1,name2); // Passes Assert.AreEqual(name1,name3); // Fails
AreSame(object o1, object o2)
Valida que dos objetos tengan la misma referencia (es decir, apuntan al mismo objeto)
CustomObject o1 = new CustomObject(); CustomObject o2 = new CustomObject(); CustomObject o3 = o1; Assert.AreSame(o1, o2); // Fails Assert.AreSame(o1, o3); // Passes
IsFalse(bool condition)
Valida que una condición dada es falsa
int i = 1; int j = 2; int k = 2; Assert.IsFalse(i == j); // Passes Assert.IsFalse(j == k); // Fails
IsTrue(bool condition)
Valida que una condición dada es verdadera
int i = 1; int j = 2; int k = 2; Assert.IsTrue(i == j); // Fails Assert.IsTrue(j == k); // Passes
Los métodos de Test pueden (y normalmente deberían) contener multiples aserciones. Revisando nuestro ejemplo original HelloWorld agregaremos más asersiones:
using System;
using Adapdev.UnitTest;
using Examples;
namespace Ejemplos.Test
{
[TestFixture]
public class HolaMundoTest
{
[Test]
public void Saludar()
{
Assert.AreEqual("¡Hola!", HolaMundo.Saludar());
Assert.IsTrue(HolaMundo.Saludar().Length == 6);
}
[Test]
public void SaludarConNombre()
{
Assert.AreEqual("¡Hola Sean!", HolaMundo.Saludar("Sean"));
Assert.IsTrue(HolaMundo.Saludar("Sean").Length == 11);
}
}
}Las aserciones múltiples en el ejemplo anterior no agregan mucho valor en esta instancia, pero nos permiten establecer nuestro punto.
Ahora para redondear las cosas, mostremos un ejemplo explícito de un test fallando:
using System;
using Adapdev.UnitTest;
using Examples;
namespace Ejemplos.Test
{
[TestFixture]
public class HolaMundoTest
{
[Test]
public void Saludar()
{
// Test pasa y continua
Assert.AreEqual("¡Hola!", HolaMundo.Saludar());
// Test falla porque el largo es 6
Assert.IsTrue(HolaMundo.Saludar().Length == 5);
}
[Test]
public void SaludarConNombre()
{
// Test dajja porque el valor retornado es Hola en vez de Hello
Assert.AreEqual("Hello Sean!", HolaMundo.Saludar("Sean"));
// No probado dado que los test ya han fallado
Assert.IsTrue(HolaMundo.Saludar("Sean").Length == 11);
} }
}En resumen para escribir un teste, tu necesitas las siguientes componentes básicas:
Agregar una referencia al motor en su proyecto (Adapdev.UnitTest.dll)
Agregar el espacio de nombres en el código:
...
using Adapdev.UnitTest
...
Agregar un atributo TestFixture sobre la declaración de la clase
...
using Adapdev.UnitTest
...
namespace XXX{
[TestFixture]
public class YYY{
}
}
Agregar un atributo Test sobre un método de prueba
...
using Adapdev.UnitTest
...
namespace XXX{
[TestFixture]
public class YYY{
[Test]
public void ZZZ(){
}
}
}
Agregar asersione dentro de su método de test
...
using Adapdev.UnitTest
...
namespace XXX{
[TestFixture]
public class YYY{
...
Assert.IsTrue(some statement);
...
}
}