Couvrant entièrement l'application console .NET C # avec des tests unitaires

Meilleure pratique pour atteindre une couverture de 100 % en utilisant le développement piloté par les tests (TDD), l'injection de dépendances (DI), l'inversion de contrôle (IoC) et les conteneurs IoC. Certains de mes collègues se plaignent qu'ils ne sont parfois pas en mesure d'appliquer TDD ou d'écrire des tests unitaires pour certains modules ou applications, les applications en font partie. console Comment pourrais-je tester une application console lorsque l'entrée est transmise par des frappes et que la sortie est présentée sur un écran ?!! En fait, cela arrive de temps en temps, vous vous retrouvez à essayer d'écrire des tests unitaires pour quelque chose sur lequel vous semblez n'avoir aucun contrôle. Idée fausse La vérité est que vous venez de manquer le point. Vous n'avez pas besoin de tester l'application "Console", vous voulez tester la qui la sous-tend. logique métier Lorsque vous créez une application console, vous créez une application que quelqu'un peut utiliser, il s'attend à transmettre certaines entrées et à obtenir des sorties correspondantes, . et c'est ce que vous devez vraiment tester Vous ne voulez pas tester la classe statique , il s'agit d'une classe intégrée qui est incluse dans le framework .NET et vous devez faire confiance à Microsoft à ce sujet. System.Console Maintenant, vous devez réfléchir à la façon de séparer ces deux domaines en composants ou modules distincts afin que vous puissiez commencer à écrire des tests pour celui que vous désirez sans interférer avec l'autre, et c'est ce que je vais vous expliquer… L'idée Tout d'abord, imaginons une idée d'application console simple et stupide et utilisons-la comme exemple pour l'appliquer. Tout d'abord, vous avez ce menu simple. Lorsque vous choisissez l'option et entrez , vous obtenez le message comme dans l'image ci-dessous. Appuyer sur Entrée fermerait l'application. 1 votre nom Hello Lorsque vous choisissez l'option et entrez , vous obtenez le message d' comme dans l'image ci-dessous. Appuyer sur Entrée fermerait l'application. 2 votre nom adieu Trop simple, non ? Oui je suis d'accord avec toi. Cependant, supposons que l'interface utilisateur, les chaînes, les caractères et tout ce que vous voyez à l'écran font partie des exigences. Cela signifie que si vous allez écrire des tests unitaires, cela devrait également être couvert de manière à ce qu'un changement mineur sur un seul caractère dans le code de production déclenche un test unitaire défaillant. Le plan Voici notre projet : Construisez l'application Console d'une mauvaise manière traditionnelle. Voyez si nous pouvons écrire des tests unitaires automatisés ou non. Ré-implémentez l'application Console dans le bon sens. Ecrire des tests unitaires. La mauvaise façon Tout simplement, faites tout au même endroit. 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"); } } } Ce que l'on peut remarquer ici : Tout est au même endroit. Nous utilisons directement la classe statique . System.Console Nous ne pouvons pas tester la logique métier sans tomber sur . System.Console Essayer d'écrire des tests unitaires Vraiment? vous attendez-vous vraiment à pouvoir écrire un test unitaire pour ce code ? Voici les défis : Selon des classes statiques telles que . System.Console Impossible de définir et d'isoler les dépendances. Impossible de remplacer les dépendances par des simulations ou des stubs. Si vous pouvez faire quelque chose à ce sujet, vous êtes un héros… croyez-moi. La bonne façon Maintenant, divisons notre solution en modules plus petits. Gestionnaire de consoles C'est le module qui est chargé de fournir les fonctionnalités dont nous avons besoin depuis la console… n'importe quelle console. Ce module serait composé de deux parties : Abstractions. Implémentations. Nous aurons donc ceci : : Il s'agit de l'interface définissant ce que nous attendons de tout gestionnaire de console. IConsoleManager : il s'agit de la classe abstraite implémentant et fournissant toutes les implémentations communes entre tous les gestionnaires de console. ConsoleManagerBase IConsoleManager : il s'agit de l'implémentation par défaut du gestionnaire de console qui encapsule et est réellement utilisée lors de l'exécution. 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); } } } Ce que l'on peut remarquer ici : Nous avons maintenant . IConsoleManager Nous pouvons utiliser Mocks et Stubs pour remplacer lors de l'écriture de tests unitaires. IConsoleManager Pour la classe de base commune , nous ne fournissons aucune implémentation commune à utiliser par les enfants. ConsoleManagerBase Je sais que ce n'est pas la meilleure chose à faire, cependant, je le fais ici juste pour vous rappeler que cette option est là et que vous pouvez l'utiliser chaque fois que nécessaire. Gestionnaire de programme Il s'agit du module chargé de fournir les principales fonctionnalités de l'application. Ce module serait composé de deux parties : Abstractions. Implémentations. Nous aurons donc ceci : : C'est l'interface définissant ce que nous attendons de tout gestionnaire de programme. IProgramManager : il s'agit de la classe abstraite implémentant et fournissant toutes les implémentations communes entre tous les gestionnaires de programme. ProgramManagerBase IProgramManager : il s'agit de l'implémentation par défaut du gestionnaire de programmes qui est réellement utilisée lors de l'exécution. Cela dépend aussi de . 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"); } } } Ce que l'on peut remarquer ici : Nous avons maintenant notre dépendance de sur bien définie. ProgramManager IConsoleManager Nous avons et nous pouvons utiliser des mocks et des stubs pour remplacer lors de l'écriture de tests unitaires. IProgramManager IProgramManager Pour la classe de base commune , nous ne fournissons aucune implémentation commune à utiliser par les enfants. ProgramManagerBase Je sais que ce n'est pas la meilleure chose à faire, cependant, je le fais ici juste pour vous rappeler que cette option est là et que vous pouvez l'utiliser chaque fois que nécessaire. La classe peut être divisée en parties plus petites. Cela faciliterait le suivi et la couverture des tests unitaires. Cependant, c'est quelque chose que je vous laisse faire. ProgramManager Application de la console C'est l'application principale. Ici, nous allons utiliser comme notre conteneur IoC. Il est simple à utiliser et vous pouvez toujours consulter leur documentation en ligne. Ninjecter Sur le projet principal de l'application console, nous créons le fichier . Ce fichier serait le suivant. NinjectDependencyResolver.cs using Ninject.Modules; using ConsoleManager; using ProgramManager; namespace MyConsoleApp { public class NinjectDependencyResolver : NinjectModule { public override void Load() { Bind ().To (); Bind ().To (); } } } Ce que l'on peut remarquer ici : La classe hérite . NinjectDependencyResolver NinjectModule Nous redéfinissons la méthode où nous définissons nos liaisons comme prévu. void Load() Maintenant, sur le : 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(); } } } Ce que l'on peut remarquer ici : Nous dépendons du . IProgramManager Nous avons créé le conteneur IoC via . var kernel = new StandardKernel(); Ensuite, nous avons chargé les dépendances dans le conteneur IoC via . Cela indique à Ninject d'obtenir ses liaisons de toutes les classes héritant de à l'intérieur de l'assembly/projet actuel. kernel.Load(Assembly.GetExecutingAssembly()); NinjectModule Cela signifie que les liaisons proviendraient de notre classe car elle hérite et se trouve dans l'assembly/projet actuel. NinjectDependencyResolver NinjectModule Pour obtenir une instance de nous utilisons le conteneur IoC comme suit . IProgramManager kernel.Get (); Voyons maintenant si cette conception et ce travail que nous avons effectués jusqu'à présent ont résolu notre problème. Moment de vérité Donc, la question est maintenant, pouvons-nous couvrir notre application console avec des tests unitaires ? Pour répondre à cette question, essayons d'écrire quelques tests unitaires… Stubs ou maquettes Si vous avez une certaine expérience des tests unitaires, sachez que nous avons des stubs et des mocks à utiliser pour remplacer nos dépendances. Juste pour le plaisir, j'utiliserais des stubs pour notre exemple ici. Donc, je définirais comme un stub pour comme suit : 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; } } } Et enfin, les tests unitaires seraient les suivants : 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(); } } } Pour terminer Nous avons maintenant pu couvrir notre application console avec des tests unitaires. Cependant, vous pourriez penser que c'est trop pour une simple application comme celle que nous avons ici. N'est-ce pas exagéré ? En fait, cela dépend de ce que vous voulez couvrir. Par exemple, dans notre application simple, j'ai traité chaque caractère de l'interface utilisateur comme une exigence devant être couverte par des tests unitaires. Donc, si vous allez changer un personnage sur l'implémentation principale, un test unitaire échouera. Peut-être que dans votre cas, ce serait différent. Cependant, ce serait toujours bien si vous savez comment le faire même jusqu'au plus petit caractère. Voilà, j'espère que vous avez trouvé la lecture de cet article aussi intéressante que j'ai trouvé l'écrire. Également publié ici