4.19.2012

Visual Studio Tips: Break points condicionales

Cuando se trabaja desarrollando software con alguna empresa, es sencillo identificar quién tiene un amplio dominio de Visual Studio como Herramienta y quién no. Hago la diferenciación acerca de del uso de Visual Studio como Herramienta ya que no es lo mismo dominar .NET que dominar Visual Studio.

Uno de los puntos más importantes a la hora del desarrollo del software es la depuración, y por lo tanto poder “debuguear” de la mejor forma el código se convierte en una herramienta fundamental para producir software de calidad. La mayoría de los desarrolladores saben como “debuguear” el código pero: ¿Saben cómo sacarle el máximo provecho al “debuguer”?

Un casi típico es ver a un desarrollador “debugueando” el recorrido de una lista ítem por ítem cuando en realidad quiere ver solo los ítems que tengan alguna condición en común. En este caso Visual Studio nos permite ponerle condiciones a los “break points” para que estos solamente se detengan cuando esta condición se cumple. Para entender esta característica veamos un ejemplo.

Break points condicionales

Supongamos que tenemos una clase Cliente con las siguientes características:

public class Cliente
{
public Int64 Id { get; set; }
public string Nombre { get; set; }
public string Pais { get; set; }
public DateTime FechaNacimiento { get; set; }
public string Email { get; set; }
public string Telefono { get; set; }
}

Supongamos que un método va a una base de datos y obtiene una cantidad muy grande de clientes; para nuestro ejemplo vamos a retornar una lista con cuatro clientes.

static IEnumerable<Cliente> ObtenerClientes()
{
var _lista = new List<Cliente>
{
new Cliente
{
Id = 1, Nombre = "Ana Cruz",
Email = "ana@yahoo.com",
FechaNacimiento = DateTime.Now.AddYears(-25),
Pais = "Panamá"
},
new Cliente
{
Id = 2,
Nombre = "Yorleny Prendas",
Email = "Yorleny@ymsn.com",
FechaNacimiento = DateTime.Now.AddYears(-35),
Pais = "Costa Rica"
},
new Cliente
{
Id = 3,
Nombre = "Carlos Porras",
Email = "cporras@ymsn.com",
FechaNacimiento = DateTime.Now.AddYears(-45),
Pais = "Costa Rica"
},
new Cliente
{
Id = 4,
Nombre = "Israel Arias",
Email = "iarias@gmail.com",
FechaNacimiento = DateTime.Now.AddYears(-23),
Pais = "Perú"
}
};
return _lista;
}

Supongamos que al recorrer la lista notamos un comportamiento inusual pero solamente los clientes con el Pais = “Costa Rica” lo producen. Si la lista no devuelve los registros ordenados y la cantidad de estos es muy alta, esta tarea depuración puede ser muy tortuosa y lenta. Sin embargo, el “debuguer” de Visual Studio nos permite poner condiciones a los “break points”; para lograrlo simplemente ponemos el break point y damos botón derecho sobre el mismo y seleccionamos la opción “condition”


image


Seguidamente nos aparecerá el diálogo para agregar el filtro que queremos que detenga el proceso de depuración. En nuestro caso queremos que se detenga cada vez que el cliente tenga como país “Costa Rica”.


image


Ahora cuando “debugueamos” el código { con F5 } el “debuguer” solo parará si se cumple esta condición.


image


Etiquetas de Technorati: ,

4.12.2012

Invitación al Expert Day 2012

El próximo martes 17 de abril estaré impartiendo la charla: Arquitectura de Software –> de donde venimos y hacia donde vamos. La charla es parte del evento Expert Day el cual se llevará a cabo en la Universidad de Costa Rica en la sede de Occidente. Les adjunto la agenda con todas las charlas que se van a impartir. Los espero.

image

Etiquetas de Technorati: ,

4.07.2012

¿Qué es un Unit Test?

Existen muchas definiciones acerca de lo que realmente es una prueba unitaria – unit test – sin embargo algunas son ambiguas y otras tienen un enfoque determinado de acuerdo a la situación en que se utilizan o se desarrollan. En este post vamos a tratar de caracterizar más que definir que es una prueba unitaria.

Identificar un Unit Test

Un unit test es un método que prueba una unidad de código. Al hablar de una unidad de código nos referimos a un requerimiento. Muchos desarrolladores tienen su propio concepto de lo que es una prueba unitaria; sin embargo, la gran mayoría coincide en que una prueba unitaria tiene las siguientes características:

  • Prueba solamente pequeñas cantidades de código: Solamente prueba el código del requerimiento específico.
  • Se aísla de otro código y de otros desarrolladores: El unit test prueba exclusivamente el código relacionado con el requerimiento y no interfiere con el trabajo hecho por otros desarrolladores.
  • Solamente se prueban los endpoints públicos: Esto principalmente porque los disparadores de los métodos privados son métodos públicos por lo tanto se abarca el código de los métodos privados dentro de las pruebas.
  • Los resultados son automatizados: Cuando ejecutamos las pruebas lo podemos hacer de forma individual o de forma grupal. Estas pruebas las hace el motor de prueba y los resultados de los mismos deben de ser precisos con respecto a cada prueba unitaria desarrollada
  • Repetible y predecible: No importa el orden y las veces que se repita la prueba, el resultado siempre debe de ser el mismo.
  • Son rápidos de desarrollar: Contrariamente a lo que piensan los desarrolladores –> que el desarrollo de pruebas unitarias quita tiempo – los unit test por lo general deben de ser simples y rápidos de desarrollar. Difícilmente una prueba unitaria deba de tomar más de cinco minutos en su desarrollo.

Ejemplo

Para entender mejor que es una prueba unitaria vamos a proceder a hacer un ejemplo. Supongamos que tenemos un método que nos indica si en un arreglo de strings existe al menos un string que sea igual a la palabra que estamos pasando por parámetro. El código del método es el siguiente:

public class AdministradorDeArreglos
{
public bool ExisteEnArreglo(string[] pArreglo, string pPalabra)
{
return pArreglo.Any(p => p.ToUpper() == pPalabra.ToUpper());
}
}

Para probar el Código escribimos lo siguiente

static void Main(string[] args)
{
var _administradorDeArreglos = new AdministradorDeArreglos();
string[] _arreglo = {"Manaza", "Papaya", "Melón", "Sandía", "Piña", "Banano"};
Console.WriteLine( _administradorDeArreglos.ExisteEnArreglo(_arreglo, "Banano") );
}

Y el resultado final será:


image


Ahora vamos a proceder a probar el código creando una prueba unitaria. El primer paso es agregar un proyecto a la solución del tipo Test –> vamos a utilizar MSTest para hacer las pruebas unitarias en este ejemplo [Observación: Yo utilizo Visual Studio Ultimate por lo tanto algunas opciones de testing pueden no aparecer en otras versiones menores o pueden estar en otro orden].


image


Como vemos en la siguiente figura, se va a crear un proyecto de testing que tiene una referencia directa al componente – dll – en donde están todas las librerías para hacer pruebas unitarias con el MSTest. Además, se crea un archivo inicial de testing y un grupo de tres “Solution Items” desde donde vamos a poder configurar y administrar las funcionalidades de nuestros tests.


image


Ahora procedemos a borrar el archivo UnitTest1.cs y vamos a crear uno desde cero. Luego de borrar el archivo, procedemos a agregar una referencia al proyecto que queremos probar. Luego damos botón derecho sobre el proyecto de testing y seleccionamos agregar nuevo test.


image


Ahora procedemos a seleccionar el tipo de prueba de unidad que vamos a crear, en nuestro caso una prueba de unidad básica.


image


Este paso nos va a generar un archivo de pruebas básico con un método de pruebas de ejemplo que cual vamos a proceder a eliminar.

using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace Pruebas
{
[TestClass]
public class Pruebas_SeriePruebasUnitarias
{
[TestMethod]
public void TestMethod1()
{
}
}
}

En el código anterior vemos que la clase generada esta marcada con el atributo TestClass, esto le indica al motor de pruebas de visual studio que dentro de esta clase existen pruebas de unidad que debe ejecutar. Los métodos de prueba son métodos públicos de tipo void que están marcados por el atributo [TestMethod] como se ve en la figura anterior.


Ahora procedemos a crear nuestra primera prueba unitaria. El código de la prueba unitaria es el siguiente:

[TestClass]
public class Pruebas_SeriePruebasUnitarias
{
[TestMethod]
public void ExisteArreglo_RetornaTrue()
{

var _administradorDeArreglos = new AdministradorDeArreglos();

var _resultado =
_administradorDeArreglos.ExisteEnArreglo(new[] { "Argentina", "Brasil", "Perú" }, "Brasil");

Assert.IsTrue(_resultado);
}
}

La prueba unitaria anterior prueba específicamente la unidad de código “ExisteEnArreglo” de la clase AdministradorDeArreglos.


Al Ejecutar el unit test el resultado será el siguiente:


image


Como podemos ver, el test pasó y el panel de resultados de VS así me lo hace saber.


Estructura del Unit Test


Para terminar, es importante notar que los unit test tienen por lo general una estructura compuesta de tres partes:




  1. Arrange: Es la parte del unit test en donde se configura todo el código para ejecutar la prueba unitaria. En nuestro caso, el “arrange” es la creación de la instancia de la clase AdministradorDeArreglos.


  2. Act: Esta es la fase del unit test en donde se ejecuta el código a probar. En nuestro caso es la invocación del método de instancia ExisteEnArreglo.


  3. Assert: Es la sección de la prueba unitaria en donde se prueba el resultado del mismo. En este caso y por lo general, lo hacemos con la clase Assert –> en MSTest –> y es donde verificamos que la variable _resultado == true;


Etiquetas de Technorati: ,