No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Tipos de Assert en xUnit

7/19
Recursos

¿Cómo implementar pruebas unitarias efectivas en proyectos de manipulación de strings?

Al adentrarnos en el mundo de las pruebas unitarias para proyectos de manipulación de strings, es crucial seguir enfoques metódicos que aseguren la eficiencia y claridad del código. Una de las prácticas esenciales involucra entender y aplicar la estructura AAA o AAAA (Arrange, Act, y Assert), que proporciona un estándar para organizar nuestras pruebas unitarias.

¿Qué significa AAA en las pruebas unitarias?

  • Arrange: Aquí configuramos los datos iniciales necesarios, las variables y los objetos clave que facilitan la ejecución de la prueba.
  • Act: En esta fase, llevamos a cabo la operación o función que deseamos probar y almacenamos el resultado.
  • Assert: Finalmente, comprobamos que el resultado coincide con nuestras expectativas.

Un ejemplo claro mostrado fue la prueba de la función concatenate strings, donde esta estructura fue aplicada para comprobar que la salida es "hello plexi".

¿Por qué es importante conocer los principios First para pruebas?

Los principios First tienen gran importancia al construir proyectos de prueba, especialmente aquellos en rápido crecimiento. Estos principios ayudan a mantener la estructura y lógica del código organizados, evitando el desarrollo de código 'espagueti', que es difícil de mantener. Dominar estos principios no solo mejora la calidad del código, sino que también es un tema común en entrevistas de trabajo.

¿Cuáles son las buenas prácticas al realizar comprobaciones con XUnit?

Al utilizar XUnit, una práctica recomendada es validar diferentes aspectos o posibles resultados de una función. Por ejemplo:

  • Verificar que un valor no sea nulo usando Assert.NotNull.
  • Comprobar que una cadena no esté vacía con Assert.NotEmpty.
  • Asegurar igualdad de valores utilizando Assert.Equal.

Este método no solo verifica la devolución del resultado esperado (como "hello plexi"), sino también que el valor no sea nulo y no esté vacío, proporcionando una cobertura más completa.

¿Cómo verificar funciones booleanas con XUnit?

Para funciones que devuelven valores booleanos, como la que comprueba si una palabra es un palíndromo, es crucial evaluar ambos escenarios: cuando la función devuelve true y false.

  • En la función de comprobación de palíndromos, se probaron dos casos:
    1. true: La palabra "ama" se lee igual de izquierda a derecha y de derecha a izquierda.
    2. false: La palabra "hello" no es un palíndromo.

Implementar pruebas así nos asegura que cubrimos todos los posibles resultados de nuestra función.

¿Cómo ejecutar pruebas unitarias de forma eficiente?

Adicionalmente al Test Explorer de Visual Studio, podemos utilizar la terminal para ejecutar pruebas unitarias. Con el comando dotnet test, es posible verificar todas las pruebas definidas en el proyecto de forma rápida y efectiva.

¿Cómo aplicar estas prácticas en otras funciones?

Ahora, un desafío es aplicar estas enseñanzas en la función removeWhitespace, que elimina espacios en blanco de un string. Siguiendo la estructura AAA y utilizando las diversas opciones de assert ofrecidas por XUnit, podemos crear robustas pruebas unitarias que fortalezcan nuestro código.

Explora el uso de diferentes tipos de comprobaciones para maximizar la cobertura de las pruebas y continúa alimentando tu curiosidad en el desarrollo de software de calidad.

Aportes 17

Preguntas 0

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Así pude validar el método RemoveWhitespace

[Fact]
        public void RemoveWhitespace()
        {
            var strStringManipulation = new StringOperations();
            var result = strStringManipulation.RemoveWhitespace("Hola, esta es una prueba");
            Assert.DoesNotContain(" ",result);
        }

Los “First Principles of Testing” (Primeros Principios de Pruebas) son una serie de conceptos fundamentales que sirven como base para la disciplina de la ingeniería de pruebas de software. Estos principios se utilizan para guiar la planificación, diseño y ejecución de pruebas de software de manera efectiva y eficiente. A continuación, se describen algunos de los principales primeros principios de pruebas:

El propósito de las pruebas es demostrar la presencia de defectos: El objetivo principal de las pruebas de software es encontrar defectos o errores en el software. Las pruebas no pueden demostrar que un software es completamente libre de errores, pero pueden proporcionar evidencia de la presencia de defectos.

La exhaustividad de las pruebas es imposible: No es posible probar todas las combinaciones posibles de entradas y condiciones en un programa. Por lo tanto, las pruebas se centran en áreas críticas y se basan en la priorización de riesgos para determinar qué probar.

Pruebas tempranas: Las pruebas deben comenzar tan pronto como sea posible en el ciclo de vida del desarrollo de software. Esto permite identificar y abordar problemas en etapas tempranas, lo que suele ser más económico y eficiente que corregir defectos más tarde.

Separación de responsabilidades: El equipo de pruebas debe ser independiente del equipo de desarrollo. Esto ayuda a garantizar una evaluación imparcial y objetiva del software.

Pruebas exhaustivas no garantizan la calidad: Incluso si se realizan pruebas exhaustivas, no se puede garantizar que el software sea completamente libre de defectos. Las pruebas son una parte importante, pero no la única, de un proceso de aseguramiento de la calidad más amplio.

Pruebas de acuerdo con especificaciones: Las pruebas deben basarse en las especificaciones del software, que incluyen requisitos funcionales y no funcionales. Las pruebas exitosas son aquellas que demuestran que el software cumple con estas especificaciones.

Pruebas de regresión: Después de realizar cambios en el software, es importante volver a ejecutar las pruebas existentes para asegurarse de que los cambios no introduzcan nuevos defectos o afecten negativamente a la funcionalidad existente.

Automatización de pruebas: La automatización de pruebas puede mejorar la eficiencia de las pruebas, especialmente en casos de pruebas repetitivas o de regresión. Sin embargo, no todas las pruebas son adecuadas para la automatización.

Estos principios proporcionan una base sólida para el desarrollo de estrategias de pruebas efectivas y ayudan a los equipos de desarrollo de software a garantizar la calidad y confiabilidad de sus productos.

Estructura AAA

![](https://static.platzi.com/media/user_upload/image-6b66e89c-2721-4143-83f3-cd22cde4c55c.jpg)
Los principios F.I.R.S.T. de pruebas unitarias son: 1. **Fast (Rápidas)**: Las pruebas deben ejecutarse rápidamente para facilitar el ciclo de desarrollo. 2. **Independent (Independientes)**: Cada prueba debe ser independiente para evitar que fallos en una afecten a otras. 3. **Repeatable (Repetibles)**: Las pruebas deben dar los mismos resultados en cada ejecución, en cualquier entorno. 4. **Self-validating (Auto-validantes)**: Las pruebas deben proporcionar resultados claros, indicando si pasan o fallan sin intervención manual. 5. **Timely (Oportunas)**: Deben escribirse en el momento adecuado, preferiblemente antes de escribir el código que están probando. Estos principios son esenciales para mantener un código de prueba limpio y efectivo.
La estructura AAA se refiere a Arrange, Act y Assert, un patrón utilizado en las pruebas unitarias, especialmente en xUnit. 1. **Arrange (Preparar)**: Configura los datos de prueba y las variables necesarias para la prueba. 2. **Act (Ejecutar)**: Ejecuta la función que deseas probar. 3. **Assert (Afirmar)**: Verifica que el resultado obtenido sea el esperado, utilizando diversas técnicas de comprobación como `Assert.Equal`, `Assert.NotNull`, entre otros. Esta estructura ayuda a que las pruebas sean legibles y mantenibles.
```c# [Fact] public void RemuveWhiteSpaceTest() { //arrange StringOperations strOperation = new(); //Act string result = strOperation.RemoveWhitespace("Hello Edward"); //Assert Assert.DoesNotContain(" ", result); } ``` \[Fact] public void RemuveWhiteSpaceTest() { //arrange StringOperations strOperation = new(); //Act string result = strOperation.RemoveWhitespace("Hello Edward"); //Assert Assert.DoesNotContain(" ", result); }
\[Fact] public async Task GetCountTestReturnsOk() { var mockCountServices = new Mock\<ICountServices>(); var mockDeviceSitodepServices = new Mock\<IDeviceSitodepServices>(); var controller = new CountsController(mockCountServices.Object, mockDeviceSitodepServices.Object); var result = await controller.GetCount(302); Assert.IsType\<ActionResult\<List\<CountGetDto>>>(result); }
Me quedo algo más o menos asi: ![](https://static.platzi.com/media/user_upload/image-7c6c44fb-c5cd-4fc5-9fbb-4765f7f906e8.jpg) Al verificar, queda correcto: ![](https://static.platzi.com/media/user_upload/image-055fcc24-bcdb-411d-9eaf-477f8df28ed0.jpg)
quiero compartir un repositorio que contiene informacion mas detallada sobre F.I.R.S.T. principles of testing. <https://github.com/tekguard/Principles-of-Unit-Testing>
![](https://static.platzi.com/media/user_upload/image-c6f91b3c-13d7-4933-9bdd-4cf9c96dbd6d.jpg)
Esta es mi prueba, difiere un poquito con la sintaxis pero igual funciona. ![](https://static.platzi.com/media/user_upload/image-55bcf018-3846-4e91-a7ad-b658c3fd9d6f.jpg)
```js public void RemoveWhitespace() { var strOperations = new StringOperations(); var Result = strOperations.RemoveWhitespace("He llo"); Assert.Equal("Hello", Result); } ```public void RemoveWhitespace() { var strOperations = new StringOperations(); var Result = strOperations.RemoveWhitespace("He llo"); Assert.Equal("Hello", Result); }
```js [Fact] public void RemovedSpace() { var strOperation = new StringOperations(); var result = strOperation.RemoveWhitespace("hola emran como estas"); Assert.NotNull(result); Assert.NotEmpty(result); Assert.False(result.Contains(" ")); } ``` \[Fact] public void RemovedSpace() { var strOperation = new StringOperations(); var result = strOperation.RemoveWhitespace("hola emran como estas"); Assert.NotNull(result); Assert.NotEmpty(result); // Assert.DoesNotContain(" ",result); Assert.False(result.Contains(" ")); }
`[Fact]` `public void RemoveWhitespace()` `{` ` var strOperations = new StringOperations();` ` var result = strOperations.RemoveWhitespace("Hola Platzi");` ` Assert.NotNull(result);` ` Assert.NotEmpty(result);` ` Assert.Equal("HolaPlatzi", result);` `}` Aquí estaría mi codigo de RemoveWhitespace

Así hice la prueba unitaria de RemoveWhitespace:

[Fact]
public void RemoveWhitespace()
{
    // Arrange
    var strOperation = new StringOperations();

    // Act
    var result = strOperation.RemoveWhitespace("Hello World");

    // Assert
    Assert.NotNull(result);
    Assert.NotEmpty(result);
    Assert.Equal("HelloWorld", result);
}

Este seria el Método.

[Fact]
public void RemoveWhitespace()
 {
            var strOperations = new StringOperations();

            var result = strOperations.RemoveWhitespace("Miguel Teheran  .");

            Assert.NotNull(result);
            Assert.NotEmpty(result);
            Assert.Equal("MiguelTeheran.", result);
        }

Así saldría el Test.