Introducción a las pruebas unitarias

Use Visual Studio para definir y ejecutar pruebas unitarias para conservar el estado del código, garantizar la cobertura del código y detectar errores y fallos antes de que lo hagan los clientes. Ejecute las pruebas unitarias con frecuencia para asegurarse de que el código funciona correctamente.

En este artículo, el código usa C# y C++, las ilustraciones están en C#, pero los conceptos y las características se aplican a los lenguajes .NET, C++, Python, JavaScript y TypeScript.

Crear pruebas unitarias

En esta sección se describe cómo crear un proyecto de prueba unitaria.

1. Abra el proyecto que quiere probar en Visual Studio.

   Para los fines de demostración de una prueba unitaria de ejemplo, en este artículo se prueba un proyecto de C# o C++ sencillo denominado HelloWorld. El código de ejemplo para dicho proyecto es el siguiente:

   .NET

   namespace HelloWorld
   {
      public class Program
      {
         public static void Main()
         {
            Console.WriteLine("Hello World!");
         }
      }
   }
   

   C++

   #include <iostream>
   
   int main()
   {
      std::cout << "Hello World!\n";
   }
   

2. En el Explorador de soluciones, seleccione el nodo de la solución. Después, en la barra de menús superior, seleccione Archivo>Agregar>Nuevo proyecto.

3. Cuadro de diálogo del nuevo proyecto, busque el proyecto de la prueba unitaria que se va a usar.

   Escriba prueba en el cuadro de búsqueda para buscar una plantilla de proyecto de prueba unitaria para el marco de pruebas que quiera usar, como MSTest (C#) o el proyecto de prueba unitaria (C++), y selecciónela.

   A partir de la versión 14.8 de Visual Studio 2017, los lenguajes de .NET incluyen plantillas integradas para NUnit y xUnit. Para C++, en este ejemplo, seleccione el proyecto Native Unit Test que usa Microsoft Native Unit Test Framework. (Para usar otro marco de pruebas de C++, vea Escribir pruebas unitarias para C/C++). Para Python, consulte el artículo Configuración de pruebas unitarias para código de Python para configurar el proyecto de prueba.

   Sugerencia

   Solo para C#, puede crear proyectos de prueba unitaria a partir del código con un método más rápido. Para obtener más información, vea Crear proyectos de prueba unitaria y métodos de prueba. Para usar este método con .NET Core o .NET Standard, se requiere Visual Studio 2019 o versiones posteriores.

   En la ilustración siguiente se muestra una prueba unitaria de MSTest que es compatible con .NET.

   

   Haga clic en Siguiente, elija un nombre para el proyecto de prueba y luego haga clic en Crear.

   El proyecto se agrega a la solución.

   

4. En el proyecto de prueba unitaria, agregue una referencia al proyecto que quiere probar haciendo clic con el botón derecho en Referencias o Dependencias y luego elija Agregar referencia o Agregar referencia de proyecto.

5. Seleccione el proyecto que contiene el código que va a probar y haga clic en Aceptar.

   

6. Agregue código al método de prueba unitaria.

   Por ejemplo, puede usar el siguiente código mediante la selección de la pestaña de documentación correcta para su marco de pruebas: MSTest, NUnit o xUnit (solo se admiten en .NET) o C++ Microsoft Native Unit Test Framework.

   MSTest

   using Microsoft.VisualStudio.TestTools.UnitTesting;
   using System.IO;
   using System;
   
   namespace HelloWorldTests
   {
      [TestClass]
      public class UnitTest1
      {
         private const string Expected = "Hello World!";
         [TestMethod]
         public void TestMethod1()
         {
            using (var sw = new StringWriter())
            {
               Console.SetOut(sw);
               HelloWorld.Program.Main();
   
               var result = sw.ToString().Trim();
               Assert.AreEqual(Expected, result);
            }
         }
      }
   }
   

   NUnit

   using NUnit.Framework;
   using System.IO;
   using System;
   
   namespace HelloWorldTests
   {
      public class Tests
      {
         private const string Expected = "Hello World!";
   
         [SetUp]
         public void Setup()
         {
         }
         [Test]
         public void TestMethod1()
         {
            using (var sw = new StringWriter())
            {
               Console.SetOut(sw);
               HelloWorld.Program.Main();
   
               var result = sw.ToString().Trim();
               Assert.AreEqual(Expected, result);
            }
         }
      }
   }
   

   xUnit

   using System;
   using Xunit;
   using System.IO;
   
   namespace HelloWorldTests
   {
       public class UnitTest1
       {
           private const string Expected = "Hello World!";
           [Fact]
           public void Test1()
           {
               using (var sw = new StringWriter())
               {
                   Console.SetOut(sw);
                   HelloWorld.Program.Main();
   
                   var result = sw.ToString().Trim();
                   Assert.Equal(Expected, result);
               }
           }
       }
   }
   

   Microsoft Native Unit Test Framework

   #include "pch.h"
   #include "CppUnitTest.h"
   #include "../HelloWorldUnitTestCPP/HelloWorldUnitTestCPP.cpp"   // Update using your project name
   
   using namespace Microsoft::VisualStudio::CppUnitTestFramework;
   
   namespace HelloWorldTests
   {
      TEST_CLASS(HelloWorldTests)
      {
      public:
   
         TEST_METHOD(TestMethod)
         {
            std::string expected = "Hello World!\n";
   
            std::stringstream buffer;
            std::streambuf* sbuf = std::cout.rdbuf(); // Save cout's buffer
            std::cout.rdbuf(buffer.rdbuf()); // Redirect cout to the stringstream buffer
   
            // Call main() in your test
            int result = main();
   
            // When finished, redirect cout to the original buffer 
            std::cout.rdbuf(sbuf);
            std::cout << "std original buffer: \n";
            std::cout << buffer.get();
   
            // Test
            Assert::AreEqual(expected, buffer.str());
         }
      };
   }
   

Ejecutar pruebas unitarias

1. Abra el Explorador de pruebas.

   Para abrir el Explorador de pruebas, elija Probar>Explorador de pruebas en la barra de menús superior (o presione CTRL + E, T).

2. Haga clic en Ejecutar todas (o presione CTRL + R, V) para ejecutar las pruebas unitarias.

   

   Cuando se hayan completado las pruebas, una marca de verificación verde indica que una prueba se superó. Un icono "x" rojo indica que una prueba no se superó.

   

Sugerencia

Puede usar el Explorador de pruebas para ejecutar pruebas unitarias en el marco de pruebas integrado (MSTest) o en marcos de pruebas de terceros. Puede agrupar las pruebas en categorías, filtrar la lista de pruebas y crear, guardar y ejecutar listas de reproducción de pruebas. También puede depurar las pruebas, y analizar la cobertura de código y el rendimiento de la prueba.

Visualización de los resultados de pruebas unitarias en vivo (Visual Studio Enterprise)

Si está usando el marco de pruebas de MSTest, xUnit o NUnit en Visual Studio 2017 o versiones posteriores, puede ver los resultados en vivo de sus pruebas unitarias.

Nota

Para seguir estos pasos, se requiere Visual Studio Enterprise, junto con el código .NET y uno de los siguientes marcos de prueba: MSTest, xUnit o NUnit.

1. Active Live Unit Testing desde el menú Probar seleccionando Probar>Live Unit Testing>Iniciar.

   

2. Vea los resultados de las pruebas dentro de la ventana del editor de código a medida que escribe y edita el código.

   

3. Haga clic en un indicador de resultado de la prueba para obtener más información, como, por ejemplo, los nombres de las pruebas que contemplan ese método.

   

Para obtener más información sobre esta característica, vea Live Unit Testing.

Uso de un marco de pruebas de terceros

Es posible ejecutar pruebas unitarias en Visual Studio con un marco de pruebas de un tercero, como NUnit, Boost, Google C++ Testing Framework, en función del lenguaje de programación. Para usar un marco de pruebas de terceros:

• Use el Administrador de paquetes NuGet para instalar el paquete NuGet correspondiente al marco de trabajo que prefiera.

• (.NET) A partir de la versión 14.6 de Visual Studio 2017, Visual Studio incluye plantillas de proyecto de prueba preconfiguradas para los marcos de pruebas de NUnit y xUnit. Estas plantillas también incluyen los paquetes de NuGet necesarios para habilitar la compatibilidad.

• (C++) En Visual Studio 2017 y versiones posteriores, algunos marcos, como Google C++ Testing Framework, ya están incluidos. Para obtener más información, vea Escribir pruebas unitarias para C/C++ en Visual Studio.

Para agregar un proyecto de prueba unitaria:

1. Abra la solución que contiene el código que quiere probar.

2. Haga clic con el botón derecho en la solución en el Explorador de soluciones y seleccione Agregar>Nuevo proyecto.

3. Seleccione una plantilla de proyecto de prueba unitaria.

   En este ejemplo, seleccione NUnit.

   

   La plantilla de proyecto incluye referencias de NuGet para NUnit y NUnit3TestAdapter.

   

4. Agregue una referencia del proyecto de prueba al proyecto que contiene el código que quiera probar.

   Haga clic con el botón derecho en el proyecto en el Explorador de soluciones y, luego, seleccione Agregar>Referencia. (También puede agregar una referencia del menú contextual del nodo Referencias o Dependencias).

5. Agregue código a al método de prueba.

   

6. Ejecute la prueba desde el Explorador de pruebas o haga clic con el botón derecho en el código de prueba y elija Ejecutar pruebas (o presione CTRL + R, T).

Pasos siguientes

Conceptos básicos de prueba unitaria

Crear y ejecutar pruebas unitarias en código administrado

Escritura de pruebas unitarias para C/C++