Cobertura completa de la aplicación de consola .NET C# con pruebas unitarias

Mejores prácticas para lograr una cobertura del 100 % mediante el desarrollo dirigido por pruebas (TDD), la inyección de dependencia (DI), la inversión de control (IoC) y los contenedores IoC. Algunos colegas míos se quejan de que a veces no pueden aplicar TDD o escribir pruebas unitarias para algunos módulos o aplicaciones, las aplicaciones de son una de ellas. consola ¿Cómo podría probar una aplicación de consola cuando la entrada se pasa mediante pulsaciones de teclas y la salida se presenta en una pantalla? En realidad, esto sucede de vez en cuando, se encuentra tratando de escribir pruebas unitarias para algo sobre lo que parece no tener ningún control. Idea equivocada La verdad es que simplemente te perdiste el punto. No necesita probar la aplicación "Consola", quiere probar la detrás de ella. lógica comercial Cuando está creando una aplicación de consola, está creando una aplicación para que alguien la use, espera pasar algunas entradas y obtener algunas salidas correspondientes, . y eso es lo que realmente necesita probar No desea probar la clase estática , esta es una clase integrada que se incluye en el marco .NET y debe confiar en Microsoft en esto. System.Console Ahora, debe pensar en cómo separar estas dos áreas en componentes o módulos separados para que pueda comenzar a escribir pruebas para la que desea sin interferir con la otra, y esto es lo que le voy a explicar... La idea Primero, pensemos en una estúpida y simple idea de aplicación de consola y usémosla como ejemplo para aplicar. Primero, tienes este sencillo menú. Cuando eliges la opción e ingresas , obtienes el mensaje como en la imagen a continuación. Presionar enter cerraría la aplicación. 1 tu nombre Hola Cuando elige la opción e ingresa , obtiene el mensaje de como en la imagen a continuación. Presionar enter cerraría la aplicación. 2 su nombre despedida Demasiado simple, ¿verdad? Sí estoy de acuerdo con usted. Sin embargo, supongamos que la interfaz de usuario, las cadenas, los caracteres y todo lo que ve en la pantalla es parte de los requisitos. Esto significa que si va a escribir pruebas unitarias, esto también debe cubrirse de manera que un cambio menor en un solo carácter en el código de producción deba desencadenar una prueba unitaria fallida. El plan Este es nuestro plan: Cree la aplicación de consola de una manera tradicional. Vea si podemos escribir pruebas unitarias automatizadas o no. Vuelva a implementar la aplicación Consola de una buena manera. Escribe algunas pruebas unitarias. el mal camino Simplemente, haga todo en un solo lugar. using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace MyConsoleApp { class Program { static void Main(string[] args) { var input = string.Empty; do { Console.WriteLine("Welcome to my console app"); Console.WriteLine("[1] Say Hello?"); Console.WriteLine("[2] Say Goodbye?"); Console.WriteLine(""); Console.Write("Please enter a valid choice: "); input = Console.ReadLine(); if (input == "1" || input == "2") { Console.Write("Please enter your name: "); string name = Console.ReadLine(); if (input == "1") { Console.WriteLine("Hello " + name); } else { Console.WriteLine("Goodbye " + name); } Console.WriteLine(""); Console.Write("Press any key to exit... "); Console.ReadKey(); } else { Console.Clear(); } } while (input != "1" && input != "2"); } } } Lo que podemos notar aquí: Todo está en un solo lugar. Estamos usando directamente la clase estática . System.Console No podemos probar la lógica empresarial sin encontrarnos con . System.Console Tratando de escribir pruebas unitarias ¿En serio? ¿Realmente espera poder escribir una prueba unitaria para ese código? Aquí están los desafíos: Dependiendo de clases estáticas como . System.Console No se pueden definir y aislar dependencias. No se pueden reemplazar las dependencias con Mocks o Stubs. Si puedes hacer algo al respecto, eres un héroe... créeme. el buen camino Ahora, dividamos nuestra solución en módulos más pequeños. Administrador de consola Este es el módulo que se encarga de brindar la funcionalidad que necesitamos de la Consola… cualquier consola. Este módulo constaría de dos partes: Abstracciones. Implementaciones. Por lo tanto tendremos lo siguiente: : esta es la interfaz que define lo que esperamos de cualquier administrador de consola. IConsoleManager : esta es la clase abstracta que implementa y proporciona implementaciones comunes entre todos los administradores de consola. ConsoleManagerBase IConsoleManager : esta es la implementación predeterminada de Console Manager que envuelve y se usa realmente en tiempo de ejecución. ConsoleManager System.Console using System; namespace ConsoleManager { public interface IConsoleManager { void Write(string value); void WriteLine(string value); ConsoleKeyInfo ReadKey(); string ReadLine(); void Clear(); } } using System; namespace ConsoleManager { public abstract class ConsoleManagerBase : IConsoleManager { public abstract void Clear(); public abstract ConsoleKeyInfo ReadKey(); public abstract string ReadLine(); public abstract void Write(string value); public abstract void WriteLine(string value); } } using System; namespace ConsoleManager { public class ConsoleManager : ConsoleManagerBase { public override void Clear() { Console.Clear(); } public override ConsoleKeyInfo ReadKey() { return Console.ReadKey(); } public override string ReadLine() { return Console.ReadLine(); } public override void Write(string value) { Console.Write(value); } public override void WriteLine(string value) { Console.WriteLine(value); } } } Lo que podemos notar aquí: Ahora tenemos . IConsoleManager Podemos usar Mocks and Stubs para reemplazar mientras escribimos pruebas unitarias. IConsoleManager Para la clase base común , no proporcionamos ninguna implementación común para que la usen los niños. ConsoleManagerBase Sé que esto no es lo mejor que se puede hacer, sin embargo, lo hago aquí solo para recordarle que esta opción está ahí y que puede usarla cuando la necesite. Director del programa Este es el módulo que se encarga de proporcionar la funcionalidad principal de la aplicación. Este módulo constaría de dos partes: Abstracciones. Implementaciones. Por lo tanto tendremos lo siguiente: : esta es la interfaz que define lo que esperamos de cualquier administrador de programas. IProgramManager : esta es la clase abstracta que implementa y proporciona implementaciones comunes entre todos los administradores de programas. ProgramManagerBase IProgramManager : esta es la implementación predeterminada del Administrador de programas que se usa en tiempo de ejecución. También depende del . ProgramManager IConsoleManager namespace ProgramManager { public interface IProgramManager { void Run(); } } namespace ProgramManager { public abstract class ProgramManagerBase : IProgramManager { public abstract void Run(); } } using ConsoleManager; namespace ProgramManager { public class ProgramManager : ProgramManagerBase { private readonly IConsoleManager m_ConsoleManager; public ProgramManager(IConsoleManager consoleManager) { m_ConsoleManager = consoleManager; } public override void Run() { string input; do { m_ConsoleManager.WriteLine("Welcome to my console app"); m_ConsoleManager.WriteLine("[1] Say Hello?"); m_ConsoleManager.WriteLine("[2] Say Goodbye?"); m_ConsoleManager.WriteLine(""); m_ConsoleManager.Write("Please enter a valid choice: "); input = m_ConsoleManager.ReadLine(); if (input == "1" || input == "2") { m_ConsoleManager.Write("Please enter your name: "); var name = m_ConsoleManager.ReadLine(); if (input == "1") { m_ConsoleManager.WriteLine("Hello " + name); } else { m_ConsoleManager.WriteLine("Goodbye " + name); } m_ConsoleManager.WriteLine(""); m_ConsoleManager.Write("Press any key to exit... "); m_ConsoleManager.ReadKey(); } else { m_ConsoleManager.Clear(); } } while (input != "1" && input != "2" && input != "Exit"); } } } Lo que podemos notar aquí: Ahora tenemos bien definida nuestra dependencia de en . ProgramManager IConsoleManager Tenemos y podemos usar simulacros y stubs para reemplazar mientras escribimos pruebas unitarias. IProgramManager IProgramManager Para la clase base común , no proporcionamos ninguna implementación común para que la usen los niños. ProgramManagerBase Sé que esto no es lo mejor que se puede hacer, sin embargo, lo hago aquí solo para recordarle que esta opción está ahí y que puede usarla cuando la necesite. La clase podría dividirse en partes más pequeñas. Eso facilitaría el seguimiento y la cobertura con pruebas unitarias. Sin embargo, esto es algo que te dejo a ti. ProgramManager Aplicación de consola Esta es la aplicación principal. Aquí vamos a usar como nuestro contenedor IoC. Es fácil de usar y siempre puede consultar su documentación en línea. inyectar En el proyecto principal de la aplicación de consola, crearíamos el archivo . Este archivo sería el siguiente. NinjectDependencyResolver.cs using Ninject.Modules; using ConsoleManager; using ProgramManager; namespace MyConsoleApp { public class NinjectDependencyResolver : NinjectModule { public override void Load() { Bind ().To (); Bind ().To (); } } } Lo que podemos notar aquí: La clase hereda . NinjectDependencyResolver NinjectModule Estamos reemplazando el método donde estamos configurando nuestros enlaces como se esperaba. void Load() Ahora, en : Program.cs using Ninject; using System.Reflection; using ProgramManager; namespace MyConsoleApp { class Program { private static IProgramManager m_ProgramManager = null; static void Main(string[] args) { var kernel = new StandardKernel(); kernel.Load(Assembly.GetExecutingAssembly()); m_ProgramManager = kernel.Get (); m_ProgramManager.Run(); } } } Lo que podemos notar aquí: Dependemos del . IProgramManager Creamos el contenedor IoC a través de . var kernel = new StandardKernel(); Luego cargamos las dependencias en el contenedor IoC a través . Esto le indica a Ninject que obtenga sus enlaces de todas las clases que heredan dentro del ensamblaje/proyecto actual. kernel.Load(Assembly.GetExecutingAssembly()); NinjectModule Esto significa que los enlaces provendrían de nuestra clase , ya que hereda y se encuentra dentro del ensamblaje/proyecto actual. NinjectDependencyResolver NinjectModule Para obtener una instancia de , estamos usando el contenedor IoC de la siguiente manera . IProgramManager kernel.Get (); Ahora, veamos si este diseño y trabajo que hemos hecho hasta este momento ha solucionado nuestro problema. Momento de la verdad Entonces, la pregunta ahora es, ¿podemos cubrir nuestra aplicación de consola con pruebas unitarias? Para responder a esta pregunta, intentemos escribir algunas pruebas unitarias... Talones o simulacros Si tiene algo de experiencia con pruebas unitarias, debe saber que tenemos Stubs y Mocks para reemplazar nuestras dependencias. Solo por diversión, usaría stubs para nuestro ejemplo aquí. Entonces, definiría como un código auxiliar para de la siguiente manera: ConsoleManagerStub IConsoleManager using System; using System.Collections.Generic; using System.Text; namespace ConsoleManager { public class ConsoleManagerStub : ConsoleManagerBase { private int m_CurrentOutputEntryNumber; private readonly List m_Outputs = new List (); public event Action OutputsUpdated; public event Action OutputsCleared; public Queue UserInputs { get; } = new Queue (); public override void Clear() { m_CurrentOutputEntryNumber++; m_Outputs.Clear(); OnOutputsCleared(); OnOutputsUpdated(m_CurrentOutputEntryNumber); } public override ConsoleKeyInfo ReadKey() { ConsoleKeyInfo result; object input; if (UserInputs.Count > 0) { input = UserInputs.Dequeue(); } else { throw new ArgumentException("No input was presented when an input was expected"); } if (input is ConsoleKeyInfo key) { result = key; } else { throw new ArgumentException("Invalid input was presented when ConsoleKeyInfo was expected"); } return result; } public override string ReadLine() { object input; if (UserInputs.Count > 0) { input = UserInputs.Dequeue(); } else { throw new ArgumentException("No input was presented when an input was expected"); } string result; if (input is string str) { result = str; WriteLine(result); } else { throw new ArgumentException("Invalid input was presented when String was expected"); } return result; } public override void Write(string value) { m_Outputs.Add(value); m_CurrentOutputEntryNumber++; OnOutputsUpdated(m_CurrentOutputEntryNumber); } public override void WriteLine(string value) { m_Outputs.Add(value + "\r\n"); m_CurrentOutputEntryNumber++; OnOutputsUpdated(m_CurrentOutputEntryNumber); } protected void OnOutputsUpdated(int outputEntryNumber) { OutputsUpdated?.Invoke(outputEntryNumber); } protected void OnOutputsCleared() { OutputsCleared?.Invoke(); } public override string ToString() { var result = string.Empty; if (m_Outputs == null || m_Outputs.Count <= 0) return result; var builder = new StringBuilder(); foreach (var output in m_Outputs) { builder.Append(output); } result = builder.ToString(); return result; } } } Y finalmente, las pruebas unitarias quedarían de la siguiente manera: using ConsoleManager; using NUnit.Framework; using System; using System.Collections.Generic; namespace MyConsoleApp.Tests { [TestFixture] public class ProgramManagerTests { private ConsoleManagerStub m_ConsoleManager = null; private ProgramManager.ProgramManager m_ProgramManager = null; [SetUp] public void SetUp() { m_ConsoleManager = new ConsoleManagerStub(); m_ProgramManager = new ProgramManager.ProgramManager(m_ConsoleManager); } [TearDown] public void TearDown() { m_ProgramManager = null; m_ConsoleManager = null; } [TestCase("Ahmed")] [TestCase("")] [TestCase(" ")] public void RunWithInputAs1AndName(string name) { m_ConsoleManager.UserInputs.Enqueue("1"); m_ConsoleManager.UserInputs.Enqueue(name); m_ConsoleManager.UserInputs.Enqueue(new ConsoleKeyInfo()); var expectedOutput = new List { "Welcome to my console app\r\n", "Welcome to my console app\r\n[1] Say Hello?\r\n", "Welcome to my console app\r\n[1] Say Hello?\r\n[2] Say Goodbye?\r\n", "Welcome to my console app\r\n[1] Say Hello?\r\n[2] Say Goodbye?\r\n\r\n", "Welcome to my console app\r\n[1] Say Hello?\r\n[2] Say Goodbye?\r\n\r\nPlease enter a valid choice: ", "Welcome to my console app\r\n[1] Say Hello?\r\n[2] Say Goodbye?\r\n\r\nPlease enter a valid choice: 1\r\n", "Welcome to my console app\r\n[1] Say Hello?\r\n[2] Say Goodbye?\r\n\r\nPlease enter a valid choice: 1\r\nPlease enter your name: ", "Welcome to my console app\r\n[1] Say Hello?\r\n[2] Say Goodbye?\r\n\r\nPlease enter a valid choice: 1\r\nPlease enter your name: " + name + "\r\n", "Welcome to my console app\r\n[1] Say Hello?\r\n[2] Say Goodbye?\r\n\r\nPlease enter a valid choice: 1\r\nPlease enter your name: " + name + "\r\nHello " + name +"\r\n", "Welcome to my console app\r\n[1] Say Hello?\r\n[2] Say Goodbye?\r\n\r\nPlease enter a valid choice: 1\r\nPlease enter your name: " + name + "\r\nHello " + name +"\r\n\r\n", "Welcome to my console app\r\n[1] Say Hello?\r\n[2] Say Goodbye?\r\n\r\nPlease enter a valid choice: 1\r\nPlease enter your name: " + name + "\r\nHello " + name +"\r\n\r\nPress any key to exit... " }; m_ConsoleManager.OutputsUpdated += outputEntryNumber => { Assert.AreEqual( expectedOutput[outputEntryNumber - 1], m_ConsoleManager.ToString()); }; m_ProgramManager.Run(); } [TestCase("Ahmed")] [TestCase("")] [TestCase(" ")] public void RunWithInputAs2AndName(string name) { m_ConsoleManager.UserInputs.Enqueue("2"); m_ConsoleManager.UserInputs.Enqueue(name); m_ConsoleManager.UserInputs.Enqueue(new ConsoleKeyInfo()); var expectedOutput = new List { "Welcome to my console app\r\n", "Welcome to my console app\r\n[1] Say Hello?\r\n", "Welcome to my console app\r\n[1] Say Hello?\r\n[2] Say Goodbye?\r\n", "Welcome to my console app\r\n[1] Say Hello?\r\n[2] Say Goodbye?\r\n\r\n", "Welcome to my console app\r\n[1] Say Hello?\r\n[2] Say Goodbye?\r\n\r\nPlease enter a valid choice: ", "Welcome to my console app\r\n[1] Say Hello?\r\n[2] Say Goodbye?\r\n\r\nPlease enter a valid choice: 2\r\n", "Welcome to my console app\r\n[1] Say Hello?\r\n[2] Say Goodbye?\r\n\r\nPlease enter a valid choice: 2\r\nPlease enter your name: ", "Welcome to my console app\r\n[1] Say Hello?\r\n[2] Say Goodbye?\r\n\r\nPlease enter a valid choice: 2\r\nPlease enter your name: " + name + "\r\n", "Welcome to my console app\r\n[1] Say Hello?\r\n[2] Say Goodbye?\r\n\r\nPlease enter a valid choice: 2\r\nPlease enter your name: " + name + "\r\nGoodbye " + name + "\r\n", "Welcome to my console app\r\n[1] Say Hello?\r\n[2] Say Goodbye?\r\n\r\nPlease enter a valid choice: 2\r\nPlease enter your name: " + name + "\r\nGoodbye " + name + "\r\n\r\n", "Welcome to my console app\r\n[1] Say Hello?\r\n[2] Say Goodbye?\r\n\r\nPlease enter a valid choice: 2\r\nPlease enter your name: " + name + "\r\nGoodbye " + name + "\r\n\r\nPress any key to exit... " }; m_ConsoleManager.OutputsUpdated += outputEntryNumber => { Assert.AreEqual( expectedOutput[outputEntryNumber - 1], m_ConsoleManager.ToString()); }; m_ProgramManager.Run(); } [Test] public void RunShouldKeepTheMainMenuWhenInputIsNeither1Nor2() { m_ConsoleManager.UserInputs.Enqueue("any invalid input 1"); m_ConsoleManager.UserInputs.Enqueue("any invalid input 2"); m_ConsoleManager.UserInputs.Enqueue("Exit"); var expectedOutput = new List { // initial menu "Welcome to my console app\r\n", // outputEntryNumber 1 "Welcome to my console app\r\n[1] Say Hello?\r\n", // outputEntryNumber 2 "Welcome to my console app\r\n[1] Say Hello?\r\n[2] Say Goodbye?\r\n", // outputEntryNumber 3 "Welcome to my console app\r\n[1] Say Hello?\r\n[2] Say Goodbye?\r\n\r\n", // outputEntryNumber 4 "Welcome to my console app\r\n[1] Say Hello?\r\n[2] Say Goodbye?\r\n\r\nPlease enter a valid choice: ", // outputEntryNumber 5 "Welcome to my console app\r\n[1] Say Hello?\r\n[2] Say Goodbye?\r\n\r\nPlease enter a valid choice: any invalid input 1\r\n", // outputEntryNumber 6 // after first trial "", // outputEntryNumber 7 "Welcome to my console app\r\n", // outputEntryNumber 8 "Welcome to my console app\r\n[1] Say Hello?\r\n", // outputEntryNumber 9 "Welcome to my console app\r\n[1] Say Hello?\r\n[2] Say Goodbye?\r\n", // outputEntryNumber 10 "Welcome to my console app\r\n[1] Say Hello?\r\n[2] Say Goodbye?\r\n\r\n", // outputEntryNumber 11 "Welcome to my console app\r\n[1] Say Hello?\r\n[2] Say Goodbye?\r\n\r\nPlease enter a valid choice: ", // outputEntryNumber 12 "Welcome to my console app\r\n[1] Say Hello?\r\n[2] Say Goodbye?\r\n\r\nPlease enter a valid choice: any invalid input 2\r\n", // outputEntryNumber 13 // after second trial "", // outputEntryNumber 14 "Welcome to my console app\r\n", // outputEntryNumber 15 "Welcome to my console app\r\n[1] Say Hello?\r\n", // outputEntryNumber 16 "Welcome to my console app\r\n[1] Say Hello?\r\n[2] Say Goodbye?\r\n", // outputEntryNumber 17 "Welcome to my console app\r\n[1] Say Hello?\r\n[2] Say Goodbye?\r\n\r\n", // outputEntryNumber 18 "Welcome to my console app\r\n[1] Say Hello?\r\n[2] Say Goodbye?\r\n\r\nPlease enter a valid choice: ", // outputEntryNumber 19 "Welcome to my console app\r\n[1] Say Hello?\r\n[2] Say Goodbye?\r\n\r\nPlease enter a valid choice: Exit\r\n" // outputEntryNumber 20 }; m_ConsoleManager.OutputsUpdated += outputEntryNumber => { if (outputEntryNumber - 1 < expectedOutput.Count) { Assert.AreEqual( expectedOutput[outputEntryNumber - 1], m_ConsoleManager.ToString()); } }; m_ProgramManager.Run(); } } } Finalmente Ahora hemos podido cubrir nuestra aplicación de consola con pruebas unitarias. Sin embargo, podría pensar que esto es demasiado para una aplicación simple como la que tenemos aquí. ¿No es esto exagerado? En realidad, depende de lo que quieras cubrir. Por ejemplo, en nuestra aplicación simple, traté cada carácter en la interfaz de usuario como un requisito que debería cubrir las pruebas unitarias. Entonces, si va y cambia un personaje en la implementación principal, una prueba unitaria fallará. Tal vez en tu caso, sería diferente. Sin embargo, siempre sería bueno que supieras cómo hacerlo hasta el más mínimo personaje. Eso es todo, espero que hayas encontrado la lectura de este artículo tan interesante como yo encontré al escribirlo. También publicado aquí