Cómo escribir pruebas unitarias para una aplicación de .NET Core

En el enfoque TDD, antes de implementar una funcionalidad, se escribe una prueba unitaria para ella. Por ejemplo, si desea escribir una función para sumar dos números, primero escribirá una prueba unitaria con errores y, a continuación, implementará la funcionalidad para superar la prueba.

En esta publicación, crearemos una aplicación de calculadora. Para comenzar, sigamos la estructura de carpetas que se describe a continuación:

• CalculatorApp – Solution
• CalculatorApp.Services – Application project
• CalculatorApp.Services.Tests – Proyecto de prueba

Puede usar Visual Studio para crear proyectos; sin embargo, en esta publicación, usaré comandos de .NET Core para crear mis proyectos, agregar pruebas y ejecutar pruebas. También puede usar MSTest o NUnit para escribir pruebas unitarias, pero en este ejemplo, usaré xUnit y dotnet test para escribir y ejecutar mis pruebas unitarias.

Comencemos abriendo un shell de comandos y sigamos lo siguiente:

Creación del proyecto de aplicación

Para empezar, tendrás que crear un directorio llamado CalculatorApp. Tenga en cuenta que puede seguir cualquier convención de nomenclatura que desee para los directorios, pero si desea seguir esta publicación, le recomendaría seguir el mismo nombre de directorio. Entonces, vamos a crear el directorio CalculatorApp y navegar hasta él.

Dentro del directorio CalculatorApp, vamos a crear una nueva solución ejecutando el siguiente comando:

dotnet new sln

Después de ejecutar correctamente el comando, debería recibir el mensaje "El archivo de solución de plantilla se creó correctamente".  También dentro del directorio CalculatorApp, encontrará un archivo llamado calculatorapp.sln.

A continuación, cree un directorio denominado CalculatorApp.Services. Este directorio mantendrá las fuentes de la aplicación, es decir, todas las clases de la aplicación de calculadora. Vaya al directorio Calculatorapp.Services y cree una biblioteca de clases ejecutando el siguiente comando:

dotnet new classlib

Después de ejecutar con éxito este comando, debería recibir el mensaje "La biblioteca de clases de plantilla se creó correctamente". También encontrará un archivo denominado calculatorapp.services.csproj dentro del directorio CalculatorApp.Services. A continuación, debe agregar este proyecto de biblioteca de clases a la solución calculatorapp. Para ello, vuelva al directorio calculatorapp y ejecute el comando:

dotnet sln add .\calculatorapp.services\calculatorapp.services.csproj

Después de ejecutar correctamente el comando, debería recibir el mensaje "Proyecto agregado a la solución".

Dentro de la carpeta CalculatorApp.Services, encontrará una clase Class1: cámbiele el nombre a Calculator y modifique la clase como se muestra en la lista a continuación:

Calculator.cs

using System;
namespace calculatorapp.services {
    public class Calculator {
        public int Add(int num1, int num2) {
            throw new NotImplementedException();
        }
        public int Sub(int num1, int num2) {
            throw new NotImplementedException();
        }
    }
}

Observará en la lista anterior que las funciones Agregar y Sub no están implementadas. Primero, escribiremos una prueba unitaria y luego implementaremos estas funcionalidades.

Creación del proyecto de prueba

Para agregar proyectos de prueba, cree un directorio denominado CalculatorApp.Services.Tests y vaya al directorio. En este directorio, crearemos un proyecto de MS Test ejecutando el siguiente comando:

dotnet new mstest

Este comando crea el proyecto de prueba que utiliza MS Test como biblioteca de pruebas.  Una vez creado el proyecto de prueba, agregue la biblioteca de proyectos de origen en el proyecto de prueba. Para ello, ejecute el comando:

dotnet add reference .. /CalculatorApp.Services/CalculatorApp.Services.csproj

 Este comando agregará una referencia del proyecto CalculatorAppService al proyecto de prueba. Después de agregar la referencia, agregue el proyecto de prueba a la solución navegando al directorio raíz de calculatorapp y ejecute el comando:

dotnet sln add .\CalculatorAppServices.tests\CalculatorAppServices.Tests.csproj

Este comando agregará el proyecto de prueba a la solución. Después de ejecutar correctamente el comando, debería recibir el mensaje "Proyecto agregado a la solución".

Writing Unit Tests

Hasta ahora, hemos creado el proyecto de código fuente de la aplicación y un proyecto de prueba. En el proyecto de origen de la aplicación, hay funciones no implementadas. Ahora escribamos pruebas para estas funciones.

En el proyecto de prueba, he cambiado el nombre del archivo UnitTest1.cs a Calculator.Test.cs y el nombre de la clase a CalculatorTest. En el constructor de CalculatorTest, necesitamos crear un objeto de la clase Calculator. Esto se puede hacer como se muestra en el listado a continuación:

Calculator.Test.cs

using Microsoft.VisualStudio.TestTools.UnitTesting;
using calculatorapp.services;
namespace CalculatorApp.Services.Tests {
    [TestClass]
    public class CalculatorTest {
        Calculator _calc;
        public CalculatorTest() {
            _calc = new Calculator();
        }
    }
}

Prueba unitaria para agregar función

En la clase CalculatorTest, agregue un método de prueba unitaria para probar la funcionalidad de adición, como se muestra en la lista siguiente:

[TestMethod]
public void shouldaddtwonumbers() {
    int res = _calc.Add(5, 3);
    Assert.AreEqual(res, 8);
}

Para ejecutar la prueba, vaya al directorio CalculatorApp.Services.Tests y ejecute el comando:

dotnet test 

Obtendrá una salida de "prueba fallida" porque la función Agregar no está implementada, como se muestra en la imagen a continuación:

Para superar la prueba, implemente la función Add en la clase Calculator como se muestra en la lista siguiente:

public int Add(int num1, int num2) {
    int result = num1 + num2;
    return result;
}

Para ejecutar la prueba ahora, vaya al director CalculatorApp.Services.Tests y ejecute el comando:

dotnet test 

Como salida, obtendrá el mensaje 'prueba aprobada' como se muestra en la imagen a continuación:

Ahora ha implementado la funcionalidad Agregar mientras se adhiere al enfoque TDD en una aplicación .NET Core.

Prueba unitaria para subfunción

En la clase CalculatorTest, agregue un método de prueba unitaria para probar la subfuncionalidad, como se muestra en la lista siguiente:

[TestMethod]
public void shouldsubstracttwonumbers() {
    int res = _calc.Sub(5, 3);
    Assert.AreEqual(res, 2);
}

Para ejecutar la prueba, vaya al directorio CalculatorApp.Services.Tests y ejecute el comando:

dotnet test 

Aquí, se producirá un error en la prueba porque no se implementa la función Sub. Obtendrá un resultado de prueba fallido como se muestra en la imagen a continuación:

Para pasar la prueba, implemente la función Sub en la clase Calculator como se muestra en la siguiente lista:

public int Sub(int num1, int num2) {
    int result = num1 - num2;
    return result;
}

Ahora vuelva a ejecutar la prueba navegando al directorio CalculatorApp.Services.Tests y ejecutando:

dotnet test

Ahora encontrarás ambas pruebas superadas, como se ve aquí:

Ahora ha implementado la funcionalidad Sub mientras se adhiere al enfoque TDD en una aplicación de .NET Core.

Terminando

Hasta ahora en esta publicación, hemos creado una aplicación .NET Core Calculator mientras nos adherimos al enfoque TDD. Para crear pruebas, usamos las pruebas XUnit y dotnet. Para su referencia, este es el código fuente de la clase Calculator y su clase de prueba:

Calculator.cs

using System;
namespace calculatorapp.services {
    public class Calculator {
        public int Add(int num1, int num2) {
            int result = num1 + num2;
            return result;
        }
        public int Sub(int num1, int num2) {
            int result = num1 - num2;
            return result;
        }
    }
}

Calculator.test.cs

using Microsoft.VisualStudio.TestTools.UnitTesting;
using calculatorapp.services;
namespace CalculatorApp.Services.Tests {
    [TestClass]
    public class CalculatorTest {
        Calculator _calc;
        public CalculatorTest() {
                _calc = new Calculator();
            }
            [TestMethod]
        public void shouldaddtwonumbers() {
                int res = _calc.Add(5, 3);
                Assert.AreEqual(res, 8);
            }
            [TestMethod]
        public void shouldsubstracttwonumbers() {
            int res = _calc.Sub(5, 3);
            Assert.AreEqual(res, 2);
        }
    }
}

Y así es como se escriben las pruebas unitarias y luego se implementan sus funcionalidades. Espero que esta publicación le ayude a empezar a escribir pruebas unitarias para su próxima aplicación .NET Core.