Qué es una prueba Unitaria

Una Pruebas unitaria, es un trozo de código, en el que, simplemente, se comprueba que las unidades individuales de código (es decir las Funciones, y/o las propiedades) de una clase o modulo, funcionan como se espera.

Sirve para asegurar que cada unidad (cada función) funcione correctamente y eficientemente por separado. Además de verificar que el código hace lo que tiene que hacer, verificamos que sea correcto el nombre, los nombres y tipos de los parámetros, el tipo de lo que se devuelve, y que si el estado inicial es válido entonces el estado final es válido

La idea es escribir casos de prueba para cada función (no trivial) o método en el módulo, de forma que cada caso sea independiente del resto. Luego, con las Pruebas de Integración, se podrá asegurar el correcto funcionamiento del sistema o subsistema en cuestión.

Nota:

Pruebas integrales o pruebas de integración son aquellas que se realizan en el ámbito del desarrollo de software una vez que se han aprobado las pruebas unitarias y lo que prueban es que todos los elementos unitarios que componen el software, funcionan juntos correctamente probándolos en grupo. Se centra principalmente en probar la comunicación entre los componentes y sus comunicaciones ya sea hardware o software.

Lo normal, es que el usuario escriba las funciones de prueba, pero existen casos en las que pueden generarse automáticamente.

Una prueba unitaria tiene que ser muy simple, se escriben generalmente en forma de funciones que van a determinar si un valor es igual al valor que esperaba cuando escribiste la función. El objetivo de la unidad de pruebas es aislar una unidad y validar su corrección.

Lea más acerca de prueba unitarias en wikipedia.

↑↑↑

Por qué necesitamos pruebas unitarias

Uno de los beneficios más importantes de las Pruebas Unitarias es que el programador adquiere la confianza de que su código trabaja como se espera que funcione.

Hay varias razones para hacer las pruebas unitarias, por ejemplo:

Aumenta la confianza en el cambio / mantenimiento de código. Si se escriben buenas pruebas unitarias, y se ejecutan cada vez que cambia el código, podremos averiguar inmediatamente cualquier defecto introducido debido al cambio.
Los códigos son más reutilizables. Para hacer posibles las pruebas unitarias, hay que modular. Esto significa que los códigos son más fáciles de reutilizar.
Desarrollo es más rápido.
Los códigos son más confiables.
Fácil de automatizar.

↑↑↑

Crear una clase [Operaciones Básicas] para trabajar

Una Observación importante

Uno de los principios fundamentales de la unidad de prueba es seguir TDD (Test Driven Development) que indica que tenemos que escribir las pruebas primero y luego escribir el código más simple que la prueba pasa.

Pero en este artículo vamos a hacer justo lo contrario, vamos a escribir primero un código sencillo y luego vamos a crear las pruebas unitarias basadas en las posibles situaciones. Como comentamos anteriormente, podemos también escribir las pruebas primero y luego escribir el código que hará que la prueba pase.

A continuación se muestra una clase muy sencilla. (Evidentemente he creado un proyecto nuevo con su Solución correspondiente)

''' <summary>
'''  Clase con las cuatro operaciones básicas
''' </summary>
Public Class OperacionesBasicas

    Public Function Sumar(ByVal num1 As Double, ByVal num2 As Double) As Double
        Return (num1 + num2)
    End Function

    Public Function Restar(ByVal num1 As Double, ByVal num2 As Double) As Double
        Return (num1 - num2)
    End Function

    Public Function Dividir(ByVal num1 As Double, ByVal num2 As Double) As Double
        Return (num1 / num2)
    End Function

    Public Function Multiplicar(ByVal num1 As Double, ByVal num2 As Double) As Double
        'Para provocar un error en la prueba unitaria, 
        'se escribe el operador + en vez del  operador *.
        Return (num1 + num2)
    End Function

End Class

La clase tiene cuatro operaciones, sumar, restar, multiplicar, dividir. Cada una de las funciones tiene dos parámetros numéricos de tipo Double.

↑↑↑

Escribir pruebas unitarias

↑↑↑

Añadir un nuevo proyecto de prueba unitaria

En primer lugar hay que añadir un nuevo proyecto de prueba unitaria

Para ello primero

Abra el explorador de soluciones (método abreviado Ctrl + Alt + L ).
Haga clic con el botón derecho del ratón encima de la solución
Haga clic en agregar
Haga clic en nuevo proyecto

Añadir un nuevo proyecto

La ventana que se abre es la de agregar un nuevo proyecto

Añadir un nuevo proyecto

Haga clic en Prueba
Seleccione el proyecto de lista de plantillas disponibles. (en la parte central). En el caso de la imagen solo hay una plantilla disponible
Escriba el nombre del proyecto. Por ejemplo [UnitTestProjectOperacionesBasicas] compruebe la ubicación del nuevo proyecto, y haga clic en el botón Aceptar.

Explorador de soluciones

↑↑↑

Añadir una referencia al proyecto Operaciones Basicas

Ahora en la carpeta de la Solución, está el proyecto original [OperacionesBasicas], y el proyecto de prueba que acabamos de crear [UnitTestProjectOperacionesBasicas]. Para que el proyecto de pruebas unitarias, pueda acceder a las funciones, Sumar, restar, etc., es necesario agregar una referencia en el proyecto de [OperacionesBasicas]. Echa un vistazo a la imagen siguiente.

En el proyecto [UnitTestProjectOperacionesBasicas]. Haga clic con el botón derecho del ratón sobre el apartado [referencias]
Haga clic en Agregar referencia
Abrirá una ventana Administrador de referencias. Para agregar la referencia, haga clic en el check en proyectos – solución – OperacionesBasicas y haga clic en el botón Aceptar.

Puedes ver en la imagen siguiente del explrador de soluciones, que se ha agregado las referencias siguientes:

Microsoft.VisualStudio.QualityTools.UnitTestFramework - contiene todas las clases y métodos que proporcionan soporte de las pruebas unitarias.
OperacionesBasicas - con todas las funciones que deben ser probadas

En el proyecto Test Unitario debe haber una clase llamada [UnitTest1] con el código siguiente:

Imports System.Text

Imports Microsoft.VisualStudio.TestTools.UnitTesting

<TestClass()> 
Public Class UnitTest1

    <TestMethod()> 
    Public Sub TestMethod1()
    End Sub

End Class

↑↑↑

Algunos requisitos que deben seguirse

↑↑↑

Requisitos de la clase de prueba:

Los requisitos mínimos para una clase de prueba son los siguientes:

El atributo .[TestClass] es necesario (En el marco de código administrado) para cualquier clase que contenga métodos de prueba unitarios
El atributo. [TestMethod] es necesario en cada método de prueba.

↑↑↑

Requisitos del método de prueba:

Un método de prueba debe cumplir los siguientes requisitos:

El método debe estar decorado con el atributo.[TestMethod]
El método no devuelve datos. Debe escribirse como Sub
El método no tiene parámetros.

↑↑↑

Primer método de prueba

Ahora, vamos a escribir métodos de prueba unitarios para verificar el comportamiento del método Sumar de la clase [OperacionesBasicas].

El código será como sigue:

    <TestMethod()>
    Public Sub Test_SumarMethod()
        Dim OB As New OperacionesBasicas
        Dim valorCalculado As Double = OB.Sumar(10, 15)
        Dim valorEsperado As Double = 25D
        Assert.AreEqual(valorEsperado, valorCalculado)
    End Sub

↑↑↑

Resto de los métodos de prueba

Ahora escribimos el resto de los test unitarios. La clase quedara así:

Imports System.Text
Imports Microsoft.VisualStudio.TestTools.UnitTesting
Imports WpfPruebasUnitarias

<TestClass()>
Public Class UnitTest1

    <TestMethod()>
    Public Sub TestMethod1()
    End Sub


    <TestMethod()>
    Public Sub Test_SumarMethod()
        Dim OB As New OperacionesBasicas
        Dim valorCalculado As Double = OB.Sumar(10, 15)
        Dim valorEsperado As Double = 25D
        Assert.AreEqual(valorEsperado, valorCalculado)
    End Sub


    <TestMethod()>
    Public Sub Test_RestarMethod()
        Dim OB As New OperacionesBasicas
        Dim valorCalculado As Double = OB.Restar(15, 10)
        Dim valorEsperado As Double = 5D
        Assert.AreEqual(valorEsperado, valorCalculado)
    End Sub

    <TestMethod()>
    Public Sub Test_MultiplicarMethod()
        Dim OB As New OperacionesBasicas
        Dim valorCalculado As Double = OB.Multiplicar(15, 10)
        Dim valorEsperado As Double = 150D
        Assert.AreEqual(valorEsperado, valorCalculado)
    End Sub

    <TestMethod()>
    Public Sub Test_DividirMethod()
        Dim OB As New OperacionesBasicas
        Dim valorCalculado As Double = OB.Dividir(15, 10)
        Dim valorEsperado As Double = 1.5D
        Assert.AreEqual(valorEsperado, valorCalculado)
    End Sub

End Class

Observa que en cada método usamos la instrucción

     Assert.AreEqual(valorEsperado, valorCalculado)

para comprobar si los dos valores, el calculado y el esperado coinciden.

↑↑↑

Generar y ejecutar la prueba

↑↑↑

Primero compilar la solución

Con una de las siguientes opciones

Menú Compilar> compilar la solución
Clic con el botón derecho del ratón encima del explorador de soluciones. En el menú emergente que aparece escoger la opción [Compilar la solución (Ctrl + May + B)]

↑↑↑

Segundo ejecutar el programa

Menú, Opción Depurar > Iniciar depuración (F5)

Una observación importante

Hemos ejecutado el programa, pero no hemos ejecutado las pruebas unitarias, de hecho, en la ventana [Explorador de pruebas] podemos ver los test y que no se han ejecutados

↑↑↑

Tercero Ejecutar la prueba

Para ejecutar la prueba:

Elegir el menú Pruebas-> Ejecutar -> Todas las pruebas.

Observamos que ahora las pruebas si se han ejecutado y que una de ellas ha fallado.

Este error tenía que haberse producido porque la función Multiplicar tiene un error de operador intencionado, recuerda que pusimos le operador suma en lugar del operación multiplicación.

Si hacemos clic sobre el error, en la parte inferíos de la ventana se muestra un mensaje que explica el error

↑↑↑

Cuarto, Corregir el código y volver a ejecutar las pruebas

En primer lugar corregimos le código de la función multiplicar sustituyendo el operador sumar por el operador multiplicar

Public Function Multiplicar(ByVal num1 As Double, ByVal num2 As Double) As Double
        'Para provocar un error en la prueba unitaria, 
        'se escribe el operador + en vez del  operador *.
        Return (num1 + num2)
End Function

'Corregir el error – Para corregir el error, simplemente sustituya + con *.

Public Function Multiplicar(ByVal num1 As Double, ByVal num2 As Double) As Double
        Return (num1 * num2)
End Function