El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Pruebas Unitarias

Siguiente ►
►

Las pruebas unitarias son una parte fundamental del desarrollo de software moderno. Permiten a los desarrolladores verificar que las unidades individuales de código (generalmente métodos o funciones) funcionan correctamente. En este tema, aprenderemos qué son las pruebas unitarias, cómo escribirlas en C# utilizando el framework MSTest, y cómo integrarlas en nuestro flujo de trabajo de desarrollo.

¿Qué son las Pruebas Unitarias?

Las pruebas unitarias son pruebas automatizadas que verifican el comportamiento de una pequeña parte del código, típicamente una función o un método. El objetivo es asegurarse de que cada unidad de código funcione como se espera en diferentes escenarios.

Beneficios de las Pruebas Unitarias

  • Detección temprana de errores: Permiten identificar errores en el código de manera temprana.
  • Facilitan el refactoring: Al tener pruebas que verifican el comportamiento del código, es más seguro realizar cambios y mejoras.
  • Documentación: Las pruebas unitarias actúan como documentación viva del comportamiento del código.
  • Mejor calidad del código: Fomentan la escritura de código más modular y menos acoplado.

Configuración del Entorno para Pruebas Unitarias

Para escribir pruebas unitarias en C#, utilizaremos el framework MSTest, que es uno de los frameworks de pruebas más populares en el ecosistema .NET.

Instalación de MSTest

  1. Crear un proyecto de pruebas unitarias:

    • En Visual Studio, selecciona Archivo > Nuevo > Proyecto.
    • Busca Pruebas Unitarias y selecciona Proyecto de prueba de MSTest.
    • Asigna un nombre al proyecto y haz clic en Crear.

  2. Agregar MSTest a un proyecto existente:

    • Abre la consola del Administrador de paquetes NuGet (Herramientas > Administrador de paquetes NuGet > Consola del Administrador de paquetes).
    • Ejecuta el siguiente comando para instalar MSTest: 
      Install-Package MSTest.TestFramework
Install-Package MSTest.TestAdapter

Escribiendo Pruebas Unitarias

Estructura de una Prueba Unitaria

Una prueba unitaria típica en MSTest sigue la estructura AAA (Arrange, Act, Assert):

  • Arrange: Configura las condiciones iniciales y los objetos necesarios.
  • Act: Ejecuta el método o función que se va a probar.
  • Assert: Verifica que el resultado es el esperado.

Ejemplo Práctico

Supongamos que tenemos una clase Calculadora con un método Sumar que queremos probar.

Clase a Probar

public class Calculadora
{
    public int Sumar(int a, int b)
    {
        return a + b;
    }
}

Clase de Pruebas

using Microsoft.VisualStudio.TestTools.UnitTesting;

[TestClass]
public class CalculadoraTests
{
    [TestMethod]
    public void Sumar_DosNumerosPositivos_RetornaSuma()
    {
        // Arrange
        var calculadora = new Calculadora();
        int a = 5;
        int b = 3;

        // Act
        int resultado = calculadora.Sumar(a, b);

        // Assert
        Assert.AreEqual(8, resultado);
    }
}

Explicación del Código

  • [TestClass]: Indica que la clase contiene métodos de prueba.
  • [TestMethod]: Marca un método como una prueba unitaria.
  • Assert.AreEqual: Verifica que el resultado de Sumar es igual a 8.

Ejercicios Prácticos

Ejercicio 1: Prueba de Multiplicación

Crea una clase Calculadora con un método Multiplicar y escribe una prueba unitaria para verificar que la multiplicación de dos números es correcta.

Solución

public class Calculadora
{
    public int Multiplicar(int a, int b)
    {
        return a * b;
    }
}

[TestClass]
public class CalculadoraTests
{
    [TestMethod]
    public void Multiplicar_DosNumerosPositivos_RetornaProducto()
    {
        // Arrange
        var calculadora = new Calculadora();
        int a = 4;
        int b = 5;

        // Act
        int resultado = calculadora.Multiplicar(a, b);

        // Assert
        Assert.AreEqual(20, resultado);
    }
}

Ejercicio 2: Prueba de División

Agrega un método Dividir a la clase Calculadora y escribe una prueba unitaria para verificar que la división de dos números es correcta. Asegúrate de manejar la división por cero.

Solución

public class Calculadora
{
    public int Dividir(int a, int b)
    {
        if (b == 0)
            throw new DivideByZeroException("No se puede dividir por cero.");
        return a / b;
    }
}

[TestClass]
public class CalculadoraTests
{
    [TestMethod]
    [ExpectedException(typeof(DivideByZeroException))]
    public void Dividir_DivisionPorCero_LanzaExcepcion()
    {
        // Arrange
        var calculadora = new Calculadora();
        int a = 10;
        int b = 0;

        // Act
        calculadora.Dividir(a, b);

        // Assert se maneja por ExpectedException
    }

    [TestMethod]
    public void Dividir_DosNumerosPositivos_RetornaCociente()
    {
        // Arrange
        var calculadora = new Calculadora();
        int a = 10;
        int b = 2;

        // Act
        int resultado = calculadora.Dividir(a, b);

        // Assert
        Assert.AreEqual(5, resultado);
    }
}

Conclusión

En esta sección, hemos aprendido qué son las pruebas unitarias, cómo configurarlas en un proyecto de C# utilizando MSTest, y cómo escribir pruebas unitarias básicas. Las pruebas unitarias son una herramienta poderosa para mejorar la calidad del código y facilitar el mantenimiento y la evolución del software. En el siguiente módulo, exploraremos mejores prácticas y patrones de diseño que complementan el uso de pruebas unitarias para crear software robusto y mantenible.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados