Introducción a Live Unit Testing

Artículo
02/02/2025

Al habilitar Live Unit Testing en una solución de Visual Studio, muestra visualmente la cobertura de las pruebas y el estado de las pruebas. Live Unit Testing también ejecuta dinámicamente pruebas cada vez que modifica el código y le notifica inmediatamente cuando los cambios provocan un error en las pruebas.

Live Unit Testing se puede usar para probar soluciones destinadas a .NET Framework, .NET Core o .NET 5+. En este tutorial, aprenderá a usar Live Unit Testing mediante la creación de una biblioteca de clases sencilla destinada a .NET y creará un proyecto de MSTest destinado a .NET para probarlo.

La solución completa de C# se puede descargar desde el repositorio de MicrosoftDocs/visualstudio-docs en GitHub.

Prerrequisitos

Este tutorial exige la instalación previa de Visual Studio Enterprise con la carga de trabajo del desarrollo para escritorio de .NET.

Creación de la solución y el proyecto de biblioteca de clases

Comience creando una solución de Visual Studio denominada UtilityLibraries que consta de un único proyecto de biblioteca de clases de .NET, StringLibrary.

La solución es solo un contenedor para uno o varios proyectos. Para crear una solución en blanco, abra Visual Studio y haga lo siguiente:

Seleccione Archivo>Nuevo>Proyecto en el menú de nivel superior de Visual Studio.
Escriba solución en el cuadro de búsqueda de la plantilla y luego seleccione la plantilla Solución en blanco. Asigne al proyecto el nombre UtilityLibraries.
Termine de crear la solución.

Ahora que ha creado la solución, creará una biblioteca de clases denominada StringLibrary que contiene varios métodos de extensión para trabajar con cadenas.

En el Explorador de soluciones, haga clic con el botón derecho en la solución UtilityLibraries y seleccione Agregar>Nuevo proyecto.
Escriba Biblioteca de clases en el cuadro de búsqueda de plantillas y seleccione la plantilla Biblioteca de clases que tiene como destino .NET o .NET Standard. Haga clic en Siguiente.
Asigne al proyecto el nombre StringLibrary.
Haga clic en Crear para crear el proyecto.

Reemplace todo el código existente en el editor de código por el código siguiente:

using System;

namespace UtilityLibraries
{
    public static class StringLibrary
    {
        public static bool StartsWithUpper(this string s)
        {
            if (String.IsNullOrWhiteSpace(s))
                return false;

            return Char.IsUpper(s[0]);
        }

        public static bool StartsWithLower(this string s)
        {
            if (String.IsNullOrWhiteSpace(s))
                return false;

            return Char.IsLower(s[0]);
        }

        public static bool HasEmbeddedSpaces(this string s)
        {
            foreach (var ch in s.Trim())
            {
                if (ch == ' ')
                    return true;
            }
            return false;
        }
    }
}

StringLibrary tiene tres métodos estáticos:

StartsWithUpper devuelve true si una cadena comienza con un carácter en mayúsculas; de lo contrario, devuelve false.
StartsWithLower devuelve true si una cadena comienza con un carácter en minúsculas; de lo contrario, devuelve false.
HasEmbeddedSpaces devuelve true si una cadena contiene un carácter de espacio en blanco incrustado; de lo contrario, devuelve false.

Seleccione Compilar>Compilar solución en el menú de nivel superior de Visual Studio. La compilar debería ser correcta.

Creación del proyecto de prueba

El siguiente paso es crear el proyecto de prueba unitaria para probar la biblioteca StringLibrary. Cree las pruebas unitarias realizando los pasos siguientes:

En el Explorador de soluciones, haga clic con el botón derecho en la solución UtilityLibraries y seleccione Agregar>Nuevo proyecto.
Escriba prueba unitaria en el cuadro de búsqueda de plantillas, seleccione C# como lenguaje y luego seleccione Proyecto de prueba unitaria de MSTest para la plantilla de .NET. Haga clic en Siguiente.

Nota

En la versión 16.9 de Visual Studio 2019, el nombre de la plantilla de proyecto msTest es proyecto de prueba unitaria.
Asigne al proyecto el nombre stringLibraryTests y haga clic en Siguiente.
Elija la plataforma de destino recomendada o .NET 8 y, después, elija Crear.

Nota

En este tutorial de introducción se usa Live Unit Testing con el marco de pruebas de MSTest. También puede usar los marcos de pruebas xUnit y NUnit.
El proyecto de prueba unitaria no puede acceder automáticamente a la biblioteca de clases que está probando. Para conceder acceso a la biblioteca de pruebas, agregue una referencia al proyecto de biblioteca de clases. Para ello, haga clic con el botón derecho en el proyecto de StringLibraryTests y seleccione Agregar referencia de proyecto de>. En el cuadro de diálogo Administrador de referencias, asegúrese de que esté seleccionada la pestaña Solución y seleccione el Proyecto StringLibrary, como se muestra en la siguiente ilustración.

Reemplace el código de prueba unitaria reutilizable proporcionado por la plantilla por el código siguiente:

using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using UtilityLibraries;

namespace StringLibraryTest
{
    [TestClass]
    public class UnitTest1
    {
        [TestMethod]
        public void TestStartsWithUpper()
        {
            // Tests that we expect to return true.
            string[] words = { "Alphabet", "Zebra", "ABC", "Αθήνα", "Москва" };
            foreach (var word in words)
            {
                bool result = word.StartsWithUpper();
                Assert.IsTrue(result,
                              $"Expected for '{word}': true; Actual: {result}");
            }
        }

        [TestMethod]
        public void TestDoesNotStartWithUpper()
        {
            // Tests that we expect to return false.
            string[] words = { "alphabet", "zebra", "abc", "αυτοκινητοβιομηχανία", "государство",
                               "1234", ".", ";", " " };
            foreach (var word in words)
            {
                bool result = word.StartsWithUpper();
                Assert.IsFalse(result,
                               $"Expected for '{word}': false; Actual: {result}");
            }
        }

        [TestMethod]
        public void DirectCallWithNullOrEmpty()
        {
            // Tests that we expect to return false.
            string[] words = { String.Empty, null };
            foreach (var word in words)
            {
                bool result = StringLibrary.StartsWithUpper(word);
                Assert.IsFalse(result,
                               $"Expected for '{(word == null ? "<null>" : word)}': " +
                               $"false; Actual: {result}");
            }
        }
    }
}

Para guardar el proyecto, seleccione el icono Guardar de la barra de herramientas.

Dado que el código de prueba unitaria incluye algunos caracteres que no son ASCII, verá el siguiente cuadro de diálogo para advertir de que algunos caracteres se perderán si guarda el archivo en su formato ASCII predeterminado.
Elija el botón Guardar con otra codificación.
En la lista desplegable Codificación del cuadro de diálogo Opciones avanzadas para guardar, elija Unicode (UTF-8 sin signatura) - Página de códigos 65001, como se muestra en la ilustración siguiente:
Para compilar el proyecto de prueba unitaria, seleccione Compilar>Recompilar solución en el menú de nivel superior de Visual Studio.

Ha creado una biblioteca de clases, así como algunas pruebas unitarias la misma. Ya ha terminado los preliminares necesarios para usar Live Unit Testing.

Habilitación de Live Unit Testing

Hasta ahora, aunque ha escrito las pruebas para la biblioteca de clases StringLibrary, no las ha ejecutado. Live Unit Testing las ejecuta automáticamente una vez que la habilite. Para ello, haga lo siguiente:

Opcionalmente, seleccione la ventana del editor de código que contiene el código de StringLibrary. Esto es Class1.cs para un proyecto de C# o Class1.vb para un proyecto de Visual Basic. (Este paso le permite inspeccionar visualmente el resultado de las pruebas y la extensión de la cobertura de código una vez que habilite Live Unit Testing).
Seleccione Prueba>Live Unit Testing>Iniciar en el menú de nivel superior de Visual Studio.
Compruebe la configuración de Live Unit Testing asegurándose de que la raíz del repositorio incluye la ruta de acceso a los archivos de origen para el proyecto de utilidad y el proyecto de prueba. Seleccione Siguiente y luego Finalizar.

En la ventana Live Unit Testing, seleccione el vínculo incluir todas las pruebas. (O bien seleccione el icono del botón Lista de reproducción y, luego, seleccione StringLibraryTest, que selecciona todas las pruebas por debajo. Luego, anule la selección del botón de Lista de reproducción para salir del modo de edición).
Visual Studio recompilará el proyecto e iniciará Live Unit Test, que ejecuta automáticamente todas las pruebas.

Visual Studio recompilará el proyecto e iniciará Live Unit Test, que ejecuta automáticamente todas las pruebas.

Cuando termine de ejecutar las pruebas, Live Unit Testing muestra los resultados generales y el resultado de las pruebas individuales. Además, la ventana del editor de código muestra gráficamente la cobertura de código de prueba y el resultado de las pruebas. Como se muestra en la ilustración siguiente, las tres pruebas se han ejecutado correctamente. También se muestra que nuestras pruebas han cubierto todas las rutas de acceso de código en el método StartsWithUpper, y esas pruebas se ejecutaron correctamente (que se indica mediante la marca de verificación verde, "✓"). Por último, muestra que ninguno de los otros métodos de StringLibrary tiene cobertura de código (que se indica mediante una línea azul, "➖").

La ventana del Explorador de Live Test y el editor de código después de iniciar Live Unit Testing

La ventana del Explorador de Tests en Vivo y el editor de código después de iniciar las Pruebas Unitarias en Vivo

También puede obtener información más detallada sobre la cobertura de pruebas y los resultados de las pruebas seleccionando un icono de cobertura de código determinado en la ventana del editor de código. Para examinar este detalle, haga lo siguiente:

Haga clic en la marca de verificación verde en la línea que dice if (String.IsNullOrWhiteSpace(s)) en el método StartsWithUpper. Como se muestra en la ilustración siguiente, Live Unit Testing indica que tres pruebas cubren esa línea de código y que todas se han ejecutado correctamente.
Haga clic en la marca de verificación verde en la línea que dice return Char.IsUpper(s[0]) en el método StartsWithUpper. Como se muestra en la ilustración siguiente, Live Unit Testing indica que solo dos pruebas cubren esa línea de código y que todas se han ejecutado correctamente.

cobertura de código

Cobertura de código

El problema principal que identifica Live Unit Testing es la cobertura de código incompleta. Lo abordarás en la sección siguiente.

Expandir la cobertura de pruebas

En esta sección, ampliarás las pruebas unitarias al método StartsWithLower. Mientras lo hace, Live Unit Testing seguirá probando dinámicamente el código.

Para ampliar la cobertura de código al método StartsWithLower, haga lo siguiente:

Agregue los siguientes métodos TestStartsWithLower y TestDoesNotStartWithLower al archivo de código fuente de prueba del proyecto:

// Code to add to UnitTest1.cs
[TestMethod]
public void TestStartsWithLower()
{
    // Tests that we expect to return true.
    string[] words = { "alphabet", "zebra", "abc", "αυτοκινητοβιομηχανία", "государство" };
    foreach (var word in words)
    {
        bool result = word.StartsWithLower();
        Assert.IsTrue(result,
                      $"Expected for '{word}': true; Actual: {result}");
    }
}

[TestMethod]
public void TestDoesNotStartWithLower()
{
    // Tests that we expect to return false.
    string[] words = { "Alphabet", "Zebra", "ABC", "Αθήνα", "Москва",
                       "1234", ".", ";", " "};
    foreach (var word in words)
    {
        bool result = word.StartsWithLower();
        Assert.IsFalse(result,
                       $"Expected for '{word}': false; Actual: {result}");
    }
}

Modifique el método DirectCallWithNullOrEmpty agregando el código siguiente inmediatamente después de la llamada al método Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsFalse.

// Code to add to UnitTest1.cs
result = StringLibrary.StartsWithLower(word);
Assert.IsFalse(result,
               $"Expected for '{(word == null ? "<null>" : word)}': " +
               $"false; Actual: {result}");

Live Unit Testing ejecuta automáticamente pruebas nuevas y modificadas al modificar el código fuente. Como se muestra en la ilustración siguiente, todas las pruebas, incluidas las dos que ha agregado y la que ha modificado, se han realizado correctamente.
Cambie a la ventana que contiene el código fuente de la clase StringLibrary. Live Unit Testing ahora muestra que nuestra cobertura de código se extiende al método StartsWithLower.

Cobertura de código

La cobertura de código

En algunos casos, las pruebas correctas en Explorador de pruebas pueden estar atenuadas. Esto indica que una prueba se está ejecutando actualmente o que la prueba no se ha vuelto a ejecutar porque no se han producido cambios en el código que afectarían a la prueba desde que se ejecutó por última vez.

Hasta ahora, todas nuestras pruebas se han realizado correctamente. En la siguiente sección, examinaremos cómo puede controlar los errores de pruebas.

Control de un error de prueba

En esta sección, explorará cómo puede usar Live Unit Testing para identificar, solucionar problemas y solucionar errores de prueba. Para ello, debe expandir la cobertura de las pruebas al método HasEmbeddedSpaces.

Agregue el siguiente método al archivo de prueba:

[TestMethod]
public void TestHasEmbeddedSpaces()
{
    // Tests that we expect to return true.
    string[] phrases = { "one car", "Name\u0009Description",
                         "Line1\nLine2", "Line3\u000ALine4",
                         "Line5\u000BLine6", "Line7\u000CLine8",
                         "Line0009\u000DLine10", "word1\u00A0word2" };
    foreach (var phrase in phrases)
    {
        bool result = phrase.HasEmbeddedSpaces();
        Assert.IsTrue(result,
                      $"Expected for '{phrase}': true; Actual: {result}");
    }
}

Cuando se ejecuta la prueba, Live Unit Testing indica que se ha producido un error en el método TestHasEmbeddedSpaces, como se muestra en la ilustración siguiente:
Seleccione la ventana que muestra el código de biblioteca. Live Unit Testing ha ampliado la cobertura de código al método HasEmbeddedSpaces. También informa de los errores de pruebas agregando un símbolo "🞩" rojo a las líneas cubiertas por pruebas erróneas.
Pase el cursor sobre la línea que tiene la firma del método HasEmbeddedSpaces. Live Unit Testing muestra un tooltip que indica que el método está cubierto por una prueba, tal como se ilustra en la imagen que sigue.
Seleccione la prueba errónea TestHasEmbeddedSpaces. Live Unit Testing ofrece algunas opciones, como ejecutar todas las pruebas y depurar todas las pruebas, como se muestra en la ilustración siguiente:
Seleccione Depurar todo para depurar la prueba con error.
Visual Studio ejecuta la prueba en modo de depuración.

La prueba asigna cada cadena de una matriz a una variable denominada phrase y la pasa al método HasEmbeddedSpaces. La ejecución del programa se pone en pausa e invoca al depurador la primera vez que la expresión de aserción es false. En la ilustración siguiente se muestra el cuadro de diálogo de excepción resultante del valor inesperado en la llamada al método Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsTrue.

cuadro de diálogo de excepción

Además, todas las herramientas de depuración que proporciona Visual Studio están disponibles para ayudarnos a solucionar problemas de la prueba con errores, como se muestra en la ilustración siguiente:

Tenga en cuenta que, en la ventana Automático, el valor de la variable phrase es "Name\tDescription", que es el segundo elemento de la matriz. El método de prueba espera que HasEmbeddedSpaces devuelva true cuando se pasa esta cadena; en su lugar, devuelve false. Evidentemente, no reconoce "\t", el carácter de tabulación, como un espacio insertado.
Seleccione Depurar>Continuar, presione F5o haga clic en el botón Continuar de la barra de herramientas para seguir ejecutando el programa de prueba. Dado que se produjo una excepción no controlada, la prueba finaliza. Esto proporciona suficiente información para una investigación preliminar del error. Ya sea TestHasEmbeddedSpaces (la rutina de prueba) hizo una suposición incorrecta o HasEmbeddedSpaces no reconoce correctamente todos los espacios incrustados.
Para diagnosticar y corregir el problema, comience con el método StringLibrary.HasEmbeddedSpaces. Examine la comparación en el método HasEmbeddedSpaces. Considera que U+0020 es un espacio insertado. Sin embargo, el estándar Unicode incluye una serie de otros caracteres de espacio. Esto sugiere que el código de biblioteca ha probado incorrectamente un carácter de espacio en blanco.
Reemplace la comparación de igualdad por una llamada al método System.Char.IsWhiteSpace:
```
if (Char.IsWhiteSpace(ch))
```
Live Unit Testing vuelve a ejecutar automáticamente el método de prueba con errores.

Live Unit Testing muestra que aparecen los resultados actualizados, que también aparecen en la ventana del editor de código.