Ejercicio: Creación de un conjunto de pruebas

  • 6 minutos

En el último ejercicio, ha agregado código de producto para la aplicación de calculadora y un primer método de prueba. Ahora, continuará con la creación del proyecto de prueba con un conjunto de pruebas.

Incorporación de más pruebas

Agregue más pruebas para asegurarse de probar toda la funcionalidad del código de producto de la calculadora.

  1. Agregue el siguiente método de prueba adicional a la clase de prueba:

    [TestMethod]
public void AddTest()
{
    // Arrange
    var calculator = new Calculator();

    // Act
    var actual = calculator.Add(1, 1);

    // Assert
    Assert.AreEqual(2, actual);
}

    En el código anterior se muestra una prueba sencilla para escribir dos números en el método Add y validar un resultado.

    Desafío: ¿Puede crear pruebas similares para los métodos Subtract, Multiply y Divide?

    Nota

    Si quiere comprobar el código, vea la sección sobre ejemplos esperados más adelante en esta unidad.

  2. Agregue otra prueba para el método Divide que genera un error. El método Divide de la calculadora todavía no puede controlar la división entre cero. Cree un método de prueba que escriba cero como divisor. Ejecute la prueba nueva para confirmar que se produce un error.

    No importa lo que hay en la instrucción de aserción, porque una excepción no detectada produce un error en la prueba. Por ahora, imagine que el método Divide debe devolver NULL al dividir entre cero. ¿Qué aserción debe usar?

    Nota

    Si quiere comprobar el código, vea la prueba de división por cero esperada más adelante en esta unidad.

Ahora que empieza a acumular un conjunto de pruebas, obtendrá más información sobre cómo administrar varias pruebas mediante el Explorador de pruebas de Visual Studio.

Filtrado por pruebas con errores

En un proyecto de mayor tamaño, es posible que tenga cientos de pruebas en ejecución en el Explorador de pruebas. Para identificar rápidamente en qué pruebas se han producido errores, puede usar la funcionalidad de filtro.

  1. En la barra de herramientas del Explorador de pruebas, seleccione el botón para las pruebas con error (el que tiene una X de color rojo). Este botón también resume cuántas pruebas tienen errores en la vista actual. En el ejemplo siguiente, este botón tiene el número 2, para indicar que hay dos pruebas con errores en la vista actual.

    Screenshot that shows the button for failed tests in Test Explorer.

    La vista de prueba se filtra para mostrar solo las pruebas con errores. En el ejemplo siguiente, solo aparecen dos pruebas en la lista de pruebas porque las otras cuatro (las que se superan) se han filtrado.

    Screenshot that shows a list of tests filtered to include only failed tests.

  2. Seleccione el botón del matraz para volver a la visualización de las pruebas con todos los resultados. Este botón también muestra el número total de pruebas y cuántas son visibles en la vista actual como una fracción. Con el filtrado actual, solo se ven dos pruebas de un total de seis.

    Screenshot that shows the flask button with a fraction that indicates two out of six.

Uso de las opciones Agrupar por

El uso de la agrupación facilita el trabajo con un gran número de pruebas. Ahora se explorarán algunos de los valores para la agrupación.

  1. Seleccione Agrupar por.

  2. Para probar una nueva agrupación, borre los valores preestablecidos y agrupe solo por estado (por ejemplo, superado, con error o sin ejecutar) y, después, la clase.

    Screenshot that shows Group By button in Test Explorer, with hierarchy levels selected.

  3. Haga clic fuera del menú. La nueva selección Agrupar por se aplica a la vista de prueba.

    En el ejemplo siguiente, el primer grupo consta de pruebas con errores organizadas por clase. El segundo grupo consta de pruebas superadas también organizadas por clase.

    Screenshot that shows the tests in Test Explorer organized into a hierarchy of state grouping and then class grouping.

Depuración de una prueba

A veces, no es evidente por qué se produce un error en una prueba. Es posible que tenga que realizar una inspección más minuciosa y establecer un punto de interrupción y depurar la prueba mientras se ejecuta.

  1. Haga clic en el margen del editor de código para establecer un punto de interrupción en DivideByZeroTest en la línea Assert.

  2. Haga clic con el botón derecho en el método de prueba en el editor de código y seleccione Depurar pruebas.

    Screenshot of the editor window with a breakpoint set on the Assert statement, and with Debug Tests selected on the right-click menu.

    El depurador no alcanza el punto de interrupción porque se produce un error en System.DivideByZeroException, según lo previsto. En la captura de pantalla siguiente se muestra una excepción del sistema de división por cero en medio de la depuración. La excepción aparece en una llamada encima del método Divide en la instrucción "return".

    Screenshot of Visual Studio throwing a divide-by-zero system exception.

Aplicación del patrón "rojo, verde, refactorización"

El proceso "rojo, verde, refactorización" consiste en empezar con una prueba con errores, para ver que se puede producir un error en la prueba, pero también que es posible que el código del producto no se haya escrito todavía. En los próximos pasos se adaptará esta mentalidad.

DivideByZeroTest producirá un error hasta que actualice el método Divide de Calculator.cs para controlar correctamente que el divisor sea cero. Por tanto, esta prueba está en "rojo", porque espera a que escriba el código de producto que falta.

  1. Escriba código para detectar la excepción si el divisor es cero y notifique al usuario un mensaje de consola como "No se puede dividir por cero". Después de detectar la excepción, el método Divide puede devolver null. Edite la firma del método Divide para permitir un tipo de valor devuelto int que admite un valor NULL.

    Ahora el método Divide debe ser similar al código siguiente.

    public int? Divide(int x, int y)
{
    try
    {
        return x / y;
    }
    catch (DivideByZeroException)
    {
        Console.WriteLine("Cannot divide by zero.");
        return null;
    }
}

  2. Vuelva a ejecutar la prueba DivideByZero para confirmar que ahora se supera. Ahora el método Divide devuelve null cuando el divisor es cero. Tenga en cuenta que la salida que advierte al usuario que no puede dividir por cero aparece en el resumen de detalles de la prueba en el Explorador de pruebas. Los detalles de la prueba incluyen la salida Console.Writeline.

    Screenshot of Test Explorer that shows a passing divide-by-zero test and the test details.

    La prueba ha pasado de rojo a verde porque ha agregado código de producto para hacer que se supere.

  3. Ahora que tiene código de producto operativo y una prueba, refactorice el código de producto para crear una solución mejor y más sólida, si es posible.

    Sugerencia

    Tenga en cuenta los escenarios que es posible que se deban actualizar debido a los cambios recientes. No dude en agregar comentarios para describir la nueva funcionalidad.

Felicidades. Ha agregado más pruebas y ha aprendido a usar un patrón "rojo, verde, refactorización". Ha empezado con el error DivideByZeroTest y ha modificado el código del producto hasta que ha pasado a color verde. El último paso antes de continuar ha sido el de refactorización.

Ejemplos esperados para pruebas de resta, multiplicación y división

[TestMethod]
public void SubtractTest()
{
    // Arrange
    var calculator = new Calculator();

    // Act
    var actual = calculator.Subtract(1, 1);

    // Assert
    Assert.AreEqual(0, actual);
}

[TestMethod]
public void MultiplyTest()
{
    // Arrange
    var calculator = new Calculator();

    // Act
    var actual = calculator.Multiply(1, 1);

    // Assert
    Assert.AreEqual(1, actual);
}

[TestMethod]
public void DivideTest()
{
    // Arrange
    var calculator = new Calculator();

    // Act
    var actual = calculator.Divide(1, 1);

    // Assert
    Assert.AreEqual(1, actual);
}

Prueba de división por cero esperada

[TestMethod]
public void DivideByZeroTest()
{
    // Arrange
    var calculator = new Calculator();

    // Act
    var actual = calculator.Divide(1, 0);

    // Assert
    Assert.IsNull(actual);
}