Introducción a las pruebas unitarias de .NET con NUnit
Por lo general, es una buena práctica tener pruebas unitarias automatizadas mientras se desarrolla el código. Hacerlo le ayuda a encontrar errores en las primeras etapas del ciclo de desarrollo y le ahorra tiempo a largo plazo.
Dhananjay Kumar
9min read
Las pruebas unitarias automatizadas durante el desarrollo del código se consideran una buena práctica. Hacerlo le ayuda a encontrar errores en las primeras etapas del ciclo de desarrollo y le ahorra tiempo a largo plazo. El desarrollador puede ejecutar estas pruebas varias veces para comprobar el comportamiento de una unidad de código determinada para diferentes conjuntos de entrada.
Las pruebas unitarias esencialmente verifican el comportamiento de una unidad particular del código o la función y son escritas por los desarrolladores que están implementando las funcionalidades.
Probamos el comportamiento de una función antes de que se convierta en parte de todo el sistema y entre en producción escribiendo un fragmento de código para probar este comportamiento en diferentes condiciones. Por lo general, una función se prueba de forma aislada con las otras funciones del sistema bajo prueba (SUT).
En .NET, hay dos opciones para escribir pruebas unitarias:
- Uso de MS Test
- Using NUnit
En este artículo, aprenderemos a iniciar pruebas unitarias de clases de C# usando NUnit. Caminaremos a través de:
- Creación del sistema bajo prueba
- Setting up NUnit
- Creación del proyecto de prueba
- Creación de clases y métodos de prueba
- Diferentes opciones para ejecutar las pruebas
- Understanding TestFixtures and TestTearDown
- Trabajar con la prueba Ignorar
System Under Test
En este ejemplo, vamos a escribir una prueba unitaria para un sistema de calculadora. Digamos que la interfaz de la Calculadora se define como se muestra en la siguiente lista:
namespace Calculator
{
public interface ICalculator
{
int Add(int num1, int num2);
int Mul(int num1, int num2);
}
}
La clase Calculator se implementa como se muestra en la lista siguiente:
namespace Calculator
{
public class Calculator :ICalculator
{
public int Add(int num1, int num2)
{
int result = num1 + num2;
return result;
}
public int Mul(int num1, int num2)
{
int result = num1 + num2;
return result;
}
}
}
Te darás cuenta de que hemos implementado la función Mul incorrectamente a propósito.
Para empezar a trabajar con NUnit y escribir la prueba, debemos seguir los siguientes pasos:
- Creación de un proyecto de prueba
- Agregar una referencia a la biblioteca NUnit
- Agregar una referencia al proyecto Sistema bajo prueba
- Creación de una clase de prueba y escritura del método de prueba
Configuración del proyecto de prueba
Para crear un proyecto de prueba, agregue un proyecto de biblioteca de clases como se muestra en la lista siguiente. Por lo general, debemos seguir la convención de nomenclatura para nombrar el proyecto de prueba como ProjectUnderTest.Test. Aquí vamos a probar el proyecto Calculator, por lo que el nombre del proyecto de prueba debe ser Calculator.Test.
Una vez creado un proyecto de prueba, tiene dos opciones para agregar una referencia a NUnit en el proyecto:
- Uso de la extensión y las actualizaciones
- Uso del paquete NuGet
Para trabajar con extensiones y actualizaciones, haga clic en Tool->Extension and Updates y, a continuación, seleccione NUnit Test Adapter.
Para trabajar con el paquete NuGet, haga clic con el botón derecho en el proyecto y, en el menú contextual, seleccione la opción de Administrar paquetes NuGet. En el administrador de paquetes NuGet, busque NUnit e instale el adaptador de prueba NUnit para VS y NUnit en el proyecto, como se muestra en la imagen siguiente:
Después de instalar el adaptador de prueba NUnit, podemos trabajar con NUnit.
Agregar una referencia al proyecto del sistema bajo prueba
A continuación, debemos agregar una referencia al proyecto Calculadora (sistema bajo prueba) en el proyecto de prueba. Para agregar eso, haga clic con el botón derecho en el proyecto de prueba y agregue una referencia al proyecto de calculadora.
Creación de la clase de prueba y los métodos de prueba
Antes de seguir adelante y crear una clase de prueba y métodos de prueba, comprendamos la estructura del proyecto de prueba. Dado que el nombre de nuestro proyecto SUT es Calculator, deberíamos nombrar el proyecto de prueba como Calculator.Tests. El nombre de la clase sometida a la prueba es Calculator, por lo que el nombre de la prueba debe ser CalculatorTest. Por último, el nombre de la función de prueba debe ser el nombre de la función sometida a la prueba, precedido por la palabra "should". La idea aquí es dar un nombre legible al proyecto, la clase y la función de prueba.
La relación entre el proyecto SUT y el proyecto de prueba se puede representar como se muestra en la siguiente imagen:
A continuación, sigamos adelante y creemos la clase de prueba y los métodos de prueba. Necesitamos usar:
- TestFixture para crear la clase de prueba
- Test para crear el método de prueba
Se puede crear una clase de prueba como se muestra en la lista a continuación:
using NUnit.Framework;
namespace Calculator.Tests
{
[TestFixture]
public class CalculatorTest
{
[Test]
public void ShouldAddTwoNumbers()
{
ICalculator sut = new Calculator();
int expectedResult = sut.Add(7, 8);
Assert.That(expectedResult, Is.EqualTo(15));
}
[Test]
public void ShouldMulTwoNumbers()
{
ICalculator sut = new Calculator();
int expectedResult = sut.Mul(7, 8);
Assert.That(expectedResult, Is.EqualTo(56));
}
}
}
En el listado anterior, estamos:
- Creación de un objeto de la clase SUT Calculator
- Llamar a los métodos
- Aserción del resultado usando NUnit assert (hablaremos más sobre la aserción en publicaciones posteriores)
Después de compilar el proyecto de prueba, debemos ejecutar la prueba.
Ejecución de la prueba
Hay tres opciones para ejecutar la prueba:
- Mediante el Explorador de pruebas de Visual Studio
- Mediante el uso de la GUI de NUnit
- Mediante el símbolo del sistema de NUnit
Visual Studio Test Explorer
Para usar Visual Studio Test Runner, inicie el Explorador de pruebas haciendo clic en la opción TEST-WINDOWS-TEST EXPLORER como se muestra en la imagen siguiente:
Debería poder ver la prueba unitaria en el Explorador de pruebas. Puede seleccionar una prueba concreta y ejecutarla o elegir ejecutar todas las pruebas. Después de ejecutar las pruebas del proyecto Calculator.Tests, en el Explorador de pruebas, el resultado se puede ver como se muestra en la imagen a continuación. Podemos ver que se ha superado la prueba ShouldAddTwoNumbers, mientras que se ha producido un error en la prueba ShouldMulTwoNumbers (lo que se espera).
NUnit GUI
Puedes descargar el MSI de la GUI de NUnit aquí. Una vez descargada, instale la GUI de NUnit y, en el menú Archivo, seleccione la opción de Abrir proyecto y, a continuación, agregue DLL al proyecto Calculator.Test. Después de agregar el archivo DLL, debería poder ver las pruebas cargadas en la interfaz de usuario. Para ejecutar una prueba, seleccione y haga clic en Ejecutar. En la interfaz de usuario de NUnit, puede ver claramente el mensaje de la prueba con errores.
Símbolo del sistema NUnit
La tercera opción para ejecutar la prueba es mediante el símbolo del sistema de NUnit. Vaya a la carpeta NUnit\Bin en Archivos de programa (su ubicación depende de la ruta de instalación que seleccionó) y ejecute el archivo nunit-console.exe. Entre comillas dobles, debe pasar la ruta de acceso completa de la dll del proyecto de prueba como segundo parámetro para ejecutar la prueba, como se muestra en la imagen siguiente:
La opción del símbolo del sistema NUnit es muy útil para la integración continua.
TestFixtureSetUp y TestFixtureTearDown
Dos conceptos muy importantes de las pruebas de NUnit son la configuración de la prueba y el desmontaje. En Calculator.Test, estamos creando objetos de la calculadora SUT en ambas pruebas. Esta no es la práctica correcta. Debemos crear todos los objetos necesarios para la prueba antes de la ejecución de cualquier prueba. Otros escenarios podrían ser:
- Creación de una conexión de base de datos antes de la ejecución de la primera prueba
- Cree una instancia de un objeto determinado antes de la ejecución de la primera prueba
- Eliminar todas las conexiones a la base de datos después de la ejecución de todas las pruebas
- Eliminar un archivo en particular del sistema antes de la ejecución de cualquier prueba
Podemos resolver los escenarios anteriores usando TestFixtureSetUp y TestFixtureTearDown. TestFixtureSetUp es un código que se ejecuta antes de la ejecución de cualquier prueba, y TestFixtureTearDown es un fragmento de código que se ejecuta después de la ejecución de todas las pruebas.
Consideremos Calculator.Test. En ambas pruebas, estamos creando un objeto de la calculadora SUT. Mientras que necesitamos un objeto de la clase Calculator antes de la ejecución de cualquier prueba y necesitamos deshacernos de él después de la ejecución de todas las pruebas. Podemos modificar la clase de prueba como con SetUp y TearDown como se muestra en la lista a continuación:
using NUnit.Framework;
namespace Calculator.Tests
{
[TestFixture]
public class CalculatorTest
{
ICalculator sut;
[TestFixtureSetUp]
public void TestSetup()
{
sut = new Calculator();
}
[Test]
public void ShouldAddTwoNumbers()
{
int expectedResult = sut.Add(7, 8);
Assert.That(expectedResult, Is.EqualTo(15));
}
[Test]
public void ShouldMulTwoNumbers()
{
int expectedResult = sut.Mul(7, 8);
Assert.That(expectedResult, Is.EqualTo(56));
}
[TestFixtureTearDown]
public void TestTearDown()
{
sut = null;
}
}
}
En el listado anterior, notará:
- Hay una función atribuida con [TestFixtureSetUp]. Esta función se ejecutará antes de la ejecución de cualquier prueba. Estamos creando un objeto de la Calculadora SUT dentro de esta función de modo que la instancia creada estará disponible para todas las pruebas.
- Hay una función atribuida con [TestFixtureTearDown]. Esta función se ejecutará después de la ejecución de todas las pruebas. Estamos disponiendo el objeto de SUT Calculator dentro de esta función.
Ignorar prueba
Otro escenario que puede encontrar al ejecutar una prueba es que es posible que desee omitir ciertas pruebas que se van a ejecutar. Por ejemplo, hay tres pruebas y desea que una de ellas se omita mientras se ejecutan el resto de las pruebas. Esto se puede hacer atribuyendo la prueba a ser ignorada con el atributo [ignore].
Una prueba se puede ignorar como se muestra en la lista a continuación:
[Test]
[Ignore]
public void ShouldNotMulTwoNumbers()
{
int expectedResult = sut.Mul(7, 8);
Assert.That(expectedResult, Is.EqualTo(15));
}
Cuando ejecute todas las pruebas en el explorador de pruebas, para la prueba ignorada, recibirá el mensaje como se muestra en la imagen a continuación:
Conclusión
En este artículo, comenzamos a hacer pruebas unitarias con NUnit en .NET. Aprendimos sobre varios componentes de las pruebas unitarias usando NUnit, como se muestra en los puntos a continuación:
- Creación del sistema bajo prueba
- Setting up NUnit
- Creación del proyecto de prueba
- Creación de clases y métodos de prueba
- Diferentes opciones para ejecutar las pruebas
- Understanding TestFixtures and TestTearDown
- Trabajar con la prueba Ignorar
Espero que este artículo te ayude a empezar con las pruebas unitarias, ¡gracias por leer y feliz codificación!
