Inicio rápido: Desarrollo basado en pruebas con el Explorador de pruebas

Se recomienda crear pruebas unitarias para hacer que su código funcione correctamente en varios pasos incrementales de desarrollo.Hay varios marcos que se pueden utilizar para escribir pruebas unitarias, incluidos algunos desarrollados por terceros.Algunos marcos de prueba están especializados para pruebas en plataformas o lenguas diferentes.El Explorador de pruebas proporciona una sola interfaz para las pruebas unitarias en cualquiera de estos marcos.Los adaptadores están disponibles para los marcos más usuales y puede escribir sus propios adaptadores para los otros marcos.

El Explorador de pruebas reemplaza las ventanas de la prueba unitaria encontradas en versiones anteriores de Visual Studio.Los beneficios incluyen:

• Ejecutar .NET, no administrado, bases de datos y otros tipos de pruebas utilizando una única interfaz.

• Utilizar el marco de pruebas de unidad de su elección, tales como NUnit o los marcos de MSTest.

• Ver en una ventana toda la información que normalmente es necesaria.Pueden encontrarse más detalles en la ventana Propiedades.

Mediante el Explorador de pruebas

Para ejecutar pruebas unitarias mediante el Explorador de pruebas

1. Crear pruebas unitarias que utilizan los marcos de prueba de su elección.

   Por ejemplo, para crear una prueba que utiliza el marco de trabajo de MSTest:

   1. Crear un proyecto de prueba

      En el cuadro de diálogo Proyecto nuevo, expanda Visual Basic, Visual C#, o **Visual C++**y, a continuación, elija Prueba.

      Seleccione Proyecto de prueba unitaria.

   2. Escribir cada prueba unitaria como un método.Anteponga el atributo [TestMethod] en cada método de prueba.

2. En la barra de menú, elija Prueba, Ejecutar pruebas unitarias, Todas las pruebas.

   La solución se compila y se ejecutan las pruebas.

   El Explorador de pruebas se abre y se muestra un resumen de los resultados.

Para ver una lista completa de pruebas: elija Mostrar todo en cualquier categoría.

Para volver al resumen, elija la vista HOME.

Para ver los detalles de un resultado de pruebas: Seleccione la prueba en el Explorador de pruebas.Los detalles tales como los mensajes de excepción aparecen en el panel de detalles.También se pueden ver más detalles en la ventana Propiedades.

Para navegar por el código de una prueba: Haga doble clic en la prueba en el Explorador de pruebas, o elija Abrir prueba en el acceso directo.

Para depurar una prueba: Abra el acceso directo de una o varias pruebas y, a continuación, elija Depurar las pruebas seleccionadas.

Importante
Los resultados que se muestran son para la ejecución más reciente.La barra de resultados coloreados presenta sólo los resultados de las pruebas que se ejecutaron.Por ejemplo, si se ejecutan varias pruebas y algunas de ellas producen un error y, a continuación, se ejecutan sólo las pruebas con éxito, la barra de resultados mostrará todo en color verde.

[!NOTA]

Si no aparece ninguna prueba, asegúrese de instalar un adaptador para conectar el Explorador de pruebas al marco de pruebas que se está usando.Para obtener más información, consulte Mediante la prueba marcos diferentes con el Explorador de pruebas.

Tutorial: Utilizar pruebas unitarias para desarrollar un método

Este tutorial muestra cómo desarrollar un método probado en C# con el marco de pruebas unitarias de Microsoft.Se pueden adaptar fácilmente para otras lenguas y utilizar otros entornos de prueba como NUnit.Para obtener más información, consulte Utilizar distintos marcos de prueba.

Crear la prueba y el método

1. Crear un proyecto de biblioteca de clases de Visual C#.Este proyecto contiene el código que se va a entregar.En este ejemplo, se llama MyMath.

2. Crear un proyecto de prueba

   • En el cuadro de diálogo Proyecto nuevo, elija Visual C#, Prueba y, a continuación, elija Proyecto de prueba unitaria.

     

3. Escribir un método de prueba básico.Comprobar el resultado obtenido de una entrada específica:

     [TestMethod]
     public void BasicRooterTest()
     {
       // Create an instance to test:
       Rooter rooter = new Rooter();
       // Define a test input and output value:
       double expectedResult = 2.0;
       double input = expectedResult * expectedResult;
       // Run the method under test:
       double actualResult = rooter.SquareRoot(input);
       // Verify the result:
       Assert.AreEqual(expectedResult, actualResult,
           delta: expectedResult / 100);
     }
   

4. Generar el método de la prueba.

   1. Coloque el cursor en Rootery, a continuación, en el acceso directo elija Generar, Nuevo tipo.

   2. En el cuadro de diálogo Generar nuevo tipo, establezca Proyecto en el proyecto de biblioteca de clases.En este ejemplo, se establece en MyMath.

   3. Coloque el cursor en SquareRooty, a continuación, en el acceso directo elija Generar, Código auxiliar del método.

5. Ejecutar la prueba unitaria

   • En el menú Prueba, elija Ejecutar pruebas unitarias, Todas las pruebas.

     Se compila y se ejecuta la solución.

     El Explorador de pruebas se abre y se muestran los resultados.

     La prueba aparece bajo Error de pruebas.

6. Seleccionar el nombre de la prueba.

   Los detalles de la prueba aparecen en la parte inferior del Explorador de pruebas.

7. Seleccionar los elementos bajo Seguimiento de pila para ver dónde falló la prueba.

En este punto, se ha creado una prueba y un código auxiliar que se modificarán para que pasen la prueba.

Después de cada cambio, haga que pasen todas las pruebas

1. En MyMath\Rooter.cs, mejore el código de SquareRoot:

    public double SquareRoot(double input)
     {
       return input / 2;
     }
   

2. En el Explorador de pruebas, elija Ejecutar todas.

   El código se compila y se ejecuta la prueba.

   La prueba se supera.

   

Agregar pruebas para ampliar la gama de entradas

1. Para mejorar su confianza de que el código funciona en todos los casos, agregue pruebas que prueben una gama más amplia de valores de entrada.

   Sugerencia
   Evite modificar las pruebas existentes que tienen éxito.En su lugar, agregue nuevas pruebas.Cambie las pruebas existentes sólo si se cambian los requisitos de usuario.Esta directiva ayuda a garantizar que no se pierda la funcionalidad existente mientras se trabaja para extender el código.

   En la clase de prueba, agregue la siguiente prueba, que intenta un intervalo de valores de entrada:

     [TestMethod]
     public void RooterValueRange()
     {
       // Create an instance to test:
       Rooter rooter = new Rooter();
       // Try a range of values:
       for (double expectedResult = 1e-8;
           expectedResult < 1e+8;
           expectedResult = expectedResult * 3.2)
       {
         RooterOneValue(rooter, expectedResult);
       }
     }
   
     private void RooterOneValue(Rooter rooter, double expectedResult)
     {
       double input = expectedResult * expectedResult;
       double actualResult = rooter.SquareRoot(input);
       Assert.AreEqual(expectedResult, actualResult,
           delta: expectedResult / 1000);
     }
   

2. En el Explorador de pruebas, elija Ejecutar todas.

   La nueva prueba no se supera, aunque la primera aún pasa.

   Para encontrar el punto de error, seleccione la prueba que fallaba y en la parte inferior del Explorador de pruebas, seleccione el elemento superior del Seguimiento de la pila.

3. Inspeccione el método de prueba para ver lo que podría ser incorrecto.En la clase MyMath.Rooter, vuelva a escribir el código:

     public double SquareRoot(double input)
     {
       double result = input;
       double previousResult = -input;
       while (Math.Abs(previousResult - result) > result / 1000)
       {
         previousResult = result;
         result = result - (result * result - input) / (2 * result);
       }
       return result;
     }
   

4. En el Explorador de pruebas, elija Ejecutar todas.

   Ahora pasan ambas pruebas.

Agregue pruebas para casos excepcionales

1. Agregue una prueba de entradas negativas:

          [TestMethod]
           public void RooterTestNegativeInputx()
           {
               Rooter rooter = new Rooter();
               try
               {
                   rooter.SquareRoot(-10);
               }
               catch (ArgumentOutOfRangeException e)
               {
                   return;
               }
               Assert.Fail();
           }
   

2. En el Explorador de pruebas, elija Ejecutar todas.

   El método en prueba entra en bucle y debe cancelarse manualmente.

3. Elija Cancelar.

   La prueba se para después de 10 segundos.

4. Corrija el código del método:

     public double SquareRoot(double input)
     {
       if (input <= 0.0) 
       {
         throw new ArgumentOutOfRangeException();
       } 
     ...
   

5. En el Explorador de pruebas, elija Ejecutar todas.

   Se pasan todas las pruebas.

Refactorizar sin cambiar las pruebas

1. Simplifique el código, pero no cambian las pruebas.

   Sugerencia

   Una refactorización es un cambio que está pensado para que el código se ejecute mejor o para hacer que el código sea más fácil de entender.No está pensado para alterar el comportamiento del código y, por tanto, no se cambian las pruebas. Se recomienda realizar los pasos de refactorización independientemente de los pasos que amplían la funcionalidad.Mantener las pruebas sin cambios da confianza de que no se han introducido accidentalmente errores mientras la refactorización.

     public class Rooter
     {
       public double SquareRoot(double input)
       {
         if (input <= 0.0) 
         {
           throw new ArgumentOutOfRangeException();
         }
         double result = input;
         double previousResult = -input;
         while (Math.Abs(previousResult - result) > result / 1000)
         {
           previousResult = result;
           result = (result + input / result) / 2;
           //was: result = result - (result * result - input) / (2*result);
         }
         return result;
       }
     }
   

2. Elija Ejecutar todas.

   Pasan todas las pruebas.