Tutorial: Desarrollo controlado por pruebas mediante el Explorador de pruebas

Cree pruebas unitarias para ayudar a mantener el código funcionando correctamente a través de cambios incrementales en el código. Hay varios marcos que puede usar para escribir pruebas unitarias, incluidas algunas desarrolladas por terceros. Algunos marcos de pruebas están especializados para realizar pruebas en diferentes lenguajes o plataformas. El Explorador de pruebas proporciona una única interfaz para las pruebas unitarias en cualquiera de estos marcos. Para obtener más información sobre el Explorador de pruebas, vea Ejecutar pruebas unitarias con el Explorador de pruebas y preguntas más frecuentes sobre el Explorador de pruebas.

En este tutorial se muestra cómo desarrollar un método probado en C# mediante Microsoft Test Framework (MSTest). Puede adaptarlo fácilmente a otros lenguajes u otros marcos de pruebas, como NUnit. Para obtener más información, consulte Instalación de marcos de pruebas unitarias de terceros.

Creación de una prueba y generación de código

1. Cree un proyecto de biblioteca de clases de C# para .NET o .NET Standard. Este proyecto contendrá el código que queremos probar. Asigne al proyecto el nombre MyMath.

2. En la misma solución, agregue un nuevo proyecto de prueba de MSTest para .NET.

   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 de prueba el nombre MathTests.

   

3. En el proyecto de prueba, escriba un método de prueba simple que compruebe el resultado obtenido para una entrada específica. Agregue el código siguiente a la Test1 clase o UnitTest1 :

   [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. Genere un tipo a partir del código de prueba.

   1. Coloque el cursor en Rooter, y a continuación, abra el menú de bombilla.

      Elija Generar nuevo tipo.

      

   2. En el cuadro de diálogo Generar tipo , establezca Proyecto en MyMath, el proyecto de biblioteca de clases y, a continuación, elija Aceptar.

      

5. Genere un método a partir del código de prueba. Coloque el cursor en SquareRooty, a continuación, en el menú de bombilla, elija Generar método 'SquareRoot' o Generar método 'Rooter.SquareRoot'.

6. Ejecute la prueba unitaria.

   1. Abra el Explorador de pruebas.

      Para abrir el Explorador de pruebas en el menú Prueba , elija Explorador de pruebas.

   2. En el Explorador de pruebas, elija el botón Ejecutar todo para ejecutar la prueba.

   La solución se compila y la prueba se ejecuta y se produce un error.

7. Seleccione el nombre de la prueba.

   Los detalles de la prueba aparecen en el panel Resumen detallado de pruebas.

   

8. Seleccione el vínculo superior en Seguimiento de pila para ir a la ubicación donde se produjo un error en la prueba.

En este momento, ha creado una prueba y un código auxiliar que puede modificar para que la prueba pase.

Comprobación de un cambio de código

1. En el archivo Class1.cs , mejore el código de SquareRoot:

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

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

   La solución se compila y la prueba se ejecuta y se supera.

   

Ampliar el rango de entradas

Para mejorar nuestra 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 superen. En su lugar, agregue nuevas pruebas. Cambie las pruebas existentes solo cuando cambien los requisitos del usuario. Esta directiva ayuda a asegurarse de que no pierde la funcionalidad existente a medida que trabaja para ampliar el código.

1. En la clase de prueba, agregue la prueba siguiente, 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 expected = 1e-8; expected < 1e+8; expected *= 3.2)
       {
           RooterOneValue(rooter, expected);
       }
   }
   
   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 todo.

   Se produce un error en la nueva prueba (aunque la primera prueba sigue superada). Para buscar el punto de error, seleccione la prueba con errores y, a continuación, examine los detalles en el panel Resumen de detalles de la prueba.

3. Inspeccione el método sometido a prueba para ver lo que podría ser incorrecto. Modifique el código SquareRoot de la siguiente manera:

   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 todo.

   Ahora se superan ambas pruebas.

Adición de pruebas para casos excepcionales

1. Agregue una nueva prueba para entradas negativas:

   [TestMethod]
   public void RooterTestNegativeInput()
   {
       Rooter rooter = new Rooter();
       Assert.ThrowsException<ArgumentOutOfRangeException>(() => rooter.SquareRoot(-1));
   }
   

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

   Se produce un error en la nueva prueba.

   Si el método bajo prueba entra en un bucle, elija Cancelar en la barra de herramientas del Explorador de Pruebas. La prueba deja de ejecutarse y produce un error.

3. Corrija el SquareRoot código agregando la siguiente if instrucción al principio del método :

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

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

   Todas las pruebas superadas.

Refactorización del código en prueba

Refactorice el código, pero no cambie las pruebas.

Sugerencia

Una refactorización es un cambio que está pensado para que el código funcione mejor o sea más fácil de entender. No está pensado para modificar el comportamiento del código y, por tanto, no se cambian las pruebas.

Se recomienda realizar pasos de refactorización por separado de los pasos que amplían la funcionalidad. Mantener las pruebas sin cambios le da la confianza de que no ha introducido errores accidentalmente durante la refactorización.

1. Cambie la línea que calcula result en el método de la SquareRoot siguiente manera:

   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 todo y compruebe que todas las pruebas siguen superadas.