Pruebas Unitarias en .NET con XUnit: Resumen y Buenas Prácticas

**Está muy bien que hagamos un "Revisemos lo que hemos aprendido" ya que nos ayuda a recordar y poder implementarnos con información que probablemente no hayamos entendido del todo.**

**Resumen de TDD vs unit Testing:** El TDD (Test Driven Development) y las "Unit Testing" (Pruebas Unitarias) son dos prácticas relacionadas pero diferentes en el desarrollo de software. El TDD es una metodología de desarrollo de software en la que se enfatiza la creación de pruebas antes de escribir el código de la aplicación. Las pruebas unitarias son una práctica dentro del desarrollo de software en la que se crean pruebas específicas para cada componente o unidad individual del código (por ejemplo, una función, método o clase) aisladamente.

**Pruebas Unitarias (Unit Testing)** **TDD(Test-Driven Development): Desarrollo basado en pruebas** Al principio se crean las pruebas, gracias a las historias de usuario ya se conocen los resultados de las pruebas, buscando un fallo de las pruebas ya que no existe aun la implementación del código, a medida que se avanza se van implementando cada código a cada prueba. Fail – Pass – Refactor **Pruebas unitarias**: son pruebas que se realizan sobre una unidad de código; una propiedad, una función o un método. Deben ser automatizables para ir implementando el código. Deben ser reutilizables e independientes. Son piezas de código que prueban otras piezas de código. Importancia: · Nos ayuda a verificar de manera rápida la lógica del negocio de nuestro código · Detectan cambios que afectan la funcionalidad de manera rápida · Se implementan del lado del desarrollo · Son fáciles de implementar. **Librerias de pruebas unitarias:** · **Microsoft Test(MSTest)** o **Gran soporte por el equipo de Microsoft** o **Exelente integración con visual studio.** o **Alta complejidad para algunos escenarios** · **NUnit** o **JUnit para .Net.** o **Opensource con gran soporte** o **Muy fácil de usar.** · **xUnit** o **Creada por la comunidad.** o **Open source con gran soporte.** o **Simplifica todo el proceso de creación de pruebas.** o **Una de las mas populares para nuevos y modernos proyectos con .NET** **\[Fact]** **Public void MyTest()** **{** **Var objectToTest = new MyClass();** **String result = objectToTest.Method();** **Assert.Equal(“MyResult”,result);** **}** Se agrega un nuevo proyecto para la prueba en la misma solución del proyecto que deseamos probar, a este proyecto se le nombra con el mismo nombre del proyecto a probar y se le agrega .Test al final. Para crear las pruebas de las clases, se crean también con el mismo nombre y al final se le agrega la palabra Test al final (en singular y sin punto ya que es una clase común y corriente .cs) Luego se agrega la referencia al proyecto al que le estaremos realizando las pruebas, esto se hace dando click en dependencias->Add Project Reference Se crea un método tipo void con el nombre del método que queremos probar(en este caso ConcatenateStrings()) Se le agrega \[Fact] Esto lo convierte en una prueba. Se crea una variable de tipo StringOperations() <- Esta es la clase que vamos a probar(contiene los métodos a probar) Hacemos el llamado al método a probar y almacenamos el resultado en una variable que luego comparamos con el resultado esperado. \[Fact] Public void ConcatenateStrings() { var strOperations = new StringOperations(); *//Este método espera dos strings para concatenarlos* var results = StringOperations.ConcatenateStrings(“Hola”,”Mundo”); *//Assert.Equal Compara valores, En este caso el resultado esperado y la //respuesta del método.* Assert.Equal(“Hola Mundo”,results); } Buenas practicas sobre pruebas unitarias que debemos aprender · Estructura AAA **(Profundizar sobre esto)** o Arrange: Configurar datos iniciales, datos de pruebas y variables o Act: Ejecucion de la prueba y guardar el resultado, normalmente se prueba una función a la vez o Assert: Comparar resultado esperado. · F.I.R.S.T Principios de pruebas **(Investigar sobre esto)** o Fast o Isolated/Independent o Repeatable o Self-Validating o Thorough Otra buena practica es llamar a la prueba con el nombre del método a probar y al final colocarle el nombre del escenario en particular que estamos observando por ejemplo en el caso anterior donde comparamos la concatenación de los dos strings en el escenario que sean iguales deberíamos poner al final del nombre de la prueba la palabra \_iguales o \_equals, luego crear otra prueba igual comparando donde no sea el resultado esperado, y pasar los respectivos resultados esperados. Asserts Usados: * Assert.Equal() = Compara dos valores si son iguales o no. * Assert.NotEquals()=Compara dos valores que no sean iguales. * Asser.True/False = verifica si un valor es True/False Assert.StartsWith()=Revisa si un string empieza con una palabra en particular. * Assert.Contains()=Comprueba si un Texto contiene un texto en particular. Reutilización de pruebas Atributos **Theory e InlineData** \[Theory] \[InLineData(“V”,5)] \[InLineData(“III”,3)] \[InLineData(“X”,10)] public void FromRomanToNumber(string romanNumber,int expected) { Var strOperations = new StringOperations(); Var result = strOperations.FromRomanToNumber(romanNumber); Assert.Equal(expected,result); } Theory e InLineData nos permiten crear pruebas con multiples valores en una misma prueba. Atributo Skip \[Fact(Skip=”Razon para omitir”] Esto permite omitir una prueba dependiendo de la necesidad, si sabemos que la prueba fallara.

**Estructura AAA (Arrange, Act, Assert)** La estructura AAA es un patrón común para organizar pruebas unitarias, proporcionando una forma clara y consistente de escribir pruebas. Aquí hay una descripción de cada paso: **Arrange (Preparar):** Configura el entorno necesario para la prueba. Esto incluye la creación de objetos, configuración de dependencias, y cualquier inicialización necesaria. `var calculator = new Calculator();` `int a = 5;` `int b = 10;` **Act (Actuar):** Ejecuta la operación o método que se quiere probar. `int result = calculator.Add(a, b)` **Assert (Afirmar):** Verifica que el resultado de la operación es el esperado usando asserts. `Assert.Equal(15, result);` **Ejemplo Completo usando AAA** `public class CalculatorTests` `{` ` [Fact]` ` public void Add_TwoNumbers_ReturnsSum()` ` {` ` // Arrange` ` var calculator = new Calculator();` ` int a = 5;` ` int b = 10;` ` // Act` ` int result = calculator.Add(a, b);` ` // Assert` ` Assert.Equal(15, result);` ` }` `}`

De momento hasta este punto y sin ver el video completo de esta clase me genera aun dudas de como se pueden implementar por ejemplo servicios, inyeccion de dependencias y cosas similares en las pruebas, me ha gustado el curso :D

Sin duda creo que lo que me aporto más es \[Theory] y \[InLineData]

Me pareció muy práctico el `[Theoy]` y el `[InlineData]` para reutilizar pruebas con parámtros.