Pruebas Unitarias en C#

Las pruebas unitarias son una parte fundamental del desarrollo de software que se centra en evaluar el funcionamiento individual de componentes a nivel de unidad, como funciones, métodos o clases. El objetivo principal de las pruebas unitarias es asegurar que cada componente del código funcione correctamente de manera aislada antes de integrarlo en el sistema completo. Esto ayuda a identificar y corregir errores temprano en el ciclo de desarrollo, lo que a su vez mejora la calidad del software y facilita el mantenimiento.

A continuación, se describen los conceptos clave relacionados con las pruebas unitarias en C#:

1. Bibliotecas de Pruebas Unitarias: En C#, existen varias bibliotecas de pruebas unitarias populares, como NUnit, MSTest y xUnit. Estas bibliotecas proporcionan herramientas y estructuras para escribir, organizar y ejecutar pruebas unitarias de manera eficiente.
2. Aserciones: Las aserciones son declaraciones que verifican si un resultado es el esperado. En las pruebas unitarias, se utilizan aserciones para afirmar que el comportamiento de una unidad de código (por ejemplo, una función) es correcto. Si una aserción falla, se considera una prueba fallida.
3. Fixtures: Los fixtures son conjuntos de pruebas que comparten un contexto común. Permiten establecer un estado inicial, realizar pruebas y limpiar después de las pruebas. Los fixtures son útiles cuando se necesitan pruebas que dependen de un estado específico.
4. Mocks y Stub: En las pruebas unitarias, es común simular objetos o comportamientos que no se pueden o no se deben utilizar en un entorno de prueba. Los mocks y stubs son objetos falsos utilizados para aislar el componente bajo prueba.
5. Cobertura de Código: La cobertura de código es una métrica que indica qué porcentaje del código fuente se ha ejecutado durante las pruebas. Es útil para evaluar la calidad de las pruebas unitarias y asegurarse de que se ha probado adecuadamente todo el código.
6. Test Driven Development (TDD): Es una metodología de desarrollo que se basa en escribir pruebas unitarias antes de escribir el código real. Esto promueve un enfoque centrado en las pruebas y ayuda a garantizar que el código cumpla con los requisitos especificados.

Ejemplo de prueba unitaria en C# utilizando NUnit:

using NUnit.Framework;

public class Calculator
{
    public int Add(int a, int b)
    {
        return a + b;
    }
}

[TestFixture]
public class CalculatorTests
{
    [Test]
    public void Add_WhenGivenTwoNumbers_ReturnsSum()
    {
        // Arrange
        var calculator = new Calculator();

        // Act
        int result = calculator.Add(3, 5);

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

En este ejemplo, hemos creado una clase Calculator con un método Add. Luego, hemos escrito una prueba unitaria utilizando NUnit que verifica si el método Add funciona correctamente al sumar dos números.

Las pruebas unitarias son esenciales para garantizar la calidad del software y facilitar el mantenimiento continuo.

Ejemplo: Escritura de Pruebas Unitarias con NUnit:

Aquí tienes un ejemplo de cómo crear pruebas unitarias para una clase de ejemplo utilizando el marco de pruebas NUnit en C#.:

Supongamos que tenemos una clase Calculator con métodos para realizar operaciones matemáticas simples. Queremos escribir pruebas unitarias para asegurarnos de que estos métodos funcionen correctamente.

Primero, necesitarás instalar la biblioteca NUnit a través de NuGet en tu proyecto. Puedes hacerlo utilizando el Administrador de paquetes NuGet en Visual Studio o mediante la línea de comandos.

Luego, puedes crear un proyecto de pruebas unitarias en tu solución de Visual Studio y escribir las pruebas unitarias. Asegúrate de que el proyecto de pruebas tenga una referencia a la biblioteca NUnit.

using NUnit.Framework;

public class Calculator
{
    public int Add(int a, int b)
    {
        return a + b;
    }

    public int Subtract(int a, int b)
    {
        return a - b;
    }
}

[TestFixture]
public class CalculatorTests
{
    [Test]
    public void Add_WhenGivenTwoNumbers_ReturnsSum()
    {
        // Arrange
        var calculator = new Calculator();

        // Act
        int result = calculator.Add(3, 5);

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

    [Test]
    public void Subtract_WhenGivenTwoNumbers_ReturnsDifference()
    {
        // Arrange
        var calculator = new Calculator();

        // Act
        int result = calculator.Subtract(10, 4);

        // Assert
        Assert.AreEqual(6, result);
    }
}

En este ejemplo, hemos creado una clase Calculator con los métodos Add y Subtract. Luego, hemos creado una clase de pruebas llamada CalculatorTests. Dentro de esta clase, hemos escrito dos pruebas unitarias utilizando los atributos [Test].

• En la primera prueba, llamada Add_WhenGivenTwoNumbers_ReturnsSum, estamos probando el método Add.
• En la segunda prueba, llamada Subtract_WhenGivenTwoNumbers_ReturnsDifference, estamos probando el método Subtract.

Para ejecutar estas pruebas, puedes usar un corredor de pruebas compatible con NUnit, como el NUnit Test Runner en Visual Studio. Después de ejecutar las pruebas, obtendrás resultados que indican si las pruebas pasaron o fallaron. Esto te permitirá verificar si tu código funciona como se espera y si futuros cambios rompen alguna funcionalidad existente.