Donnons un peu d'amour aux tests unitaires aux fonctionnalités C # 8 et C # 9

Selon StackOverflow C # est l'un des langages de programmation les plus appréciés. Et je le comprends parfaitement: il est puissant, facile à apprendre et s’améliore et se développe constamment. C'est une langue vivante. 🙂

Ces dernières années, de nouvelles fonctionnalités ont été ajoutées aux langages, et les nouvelles versions continuent à apparaître — C # 7, C # 8, C # 9.

Comme vous le savez, Progress Telerik est fier que nos produits sont toujours synchronisés avec les dernières nouveautés du monde .NET, et C # 9 et JustMock ne font pas exception.

La plupart des nouvelles fonctionnalités sont faciles à utiliser dans les tests unitaires et les moqueries, mais il y en a quelques-unes intéressantes choses que je voudrais vous montrer afin que vous puissiez facilement utiliser les fonctionnalités C # dans les tests unitaires:

• Fonctions locales statiques (C # 8)
• Méthodes async
• Records
• Init
• Pattern Matching [19659010] Pour les illustrer, nous utiliserons une classe Foo .

   public   class   Foo   
     {  
      public   Foo ()    
      {   [19659002]    this  .Bar = 10;    
      this  .DateTime =  ] nouveau   DateTime (2021, 1, 1);    
     }    
     
      public   int   Bar { get ; init; }    
      public   DateTime DateTime { get ; init; }    
     
      public   bool   IsInRange ( int   i) =>    
      i  is   (> = 1 and  = 100 and <= 200);    
    }   
     
     public   record Person   
     {  
      public   string   LastName { get ; }    
      public   string   FirstName { get ; }    
     
      public   Person ( string   first,  string   last) => (FirstName, LastName) = (first, last);    
    }   
     
     enregistrement public   Enseignant: Personne   
     {  
      public   string   Subject { get ; }    
     
      public   Teacher ( string   first,  string   last,  string   sub)    
     :  base  (first, last) => Subject = sub;    
    } 
  

  Remarque: Pour exécuter les exemples, vous devez télécharger et installer JM depuis ici . 19659105] 1. Commençons par simuler les fonctions statiques à l’aide de Mock.Local

    
   
     [TestMethod]   
     public   void   TestStaticLocal ()   
     {  
      // Organiser    
      var sut =  nouveau   Foo ();    
        
      // Voici comment se moquer de la fonction statique    
      Mock.Local.Function.Arrange < int > (sut,  "MethodWithStaticLocal"  "Add" Arg.Expr.AnyInt, Arg.Expr.AnyInt) .Returns (1);    
        
      // Loi   [1 9459017] 
      var result = sut.MethodWithStaticLocal ();    
        
      // Assert    
      Mock.Assert (sut);    
      Assert.AreNotEqual (12, result);    
    } 
  

  2. Flux asynchrones

  À partir de C # 8.0, vous pouvez créer et consommer des flux de manière asynchrone. Une méthode qui renvoie un flux asynchrone a trois spécificités:

  • Elle est déclarée avec le modificateur async
  • Elle renvoie un IAsyncEnumerable
  • La méthode contient des instructions yield return pour renvoyer des éléments successifs le flux asynchrone

  Dans l'exemple ci-dessous, vous pouvez voir un exemple d'une telle méthode avec un exemple de la façon dont vous pourriez vous en moquer:

    
   
     [TestMethod]   
     public   async Task TestAsyncEnumFromArray ()   
     {  
      // Organiser    
      var attendu =  new   int  [] {10, 20, 30};    
     
      Mock.Arrange (() => Foo.GetAsyncCollection ())    
      .Returns (expected.GetEnumerator ( ) .ToAsyncEnumerable < int > ());    
     
      // Act    
      var result = Foo.GetAsyncCollection ();    
     
      // Assert    
      Mock.Assert  ();    
      int   index = 0;    
      wait  foreach   (var number  in   result)    
      {   
      Assert.AreEqual (attendu [index++]nombre);    
  
  
  
                                    
  
                                  
  
  
     [19659019]}    
    } 
  

  3. Init Only Setters

  Init only Setters fournit une syntaxe cohérente pour initialiser les membres d'un objet. Les initialiseurs de propriété indiquent clairement quelle valeur définit quelle propriété. L'inconvénient est que ces propriétés doivent être réglables. À partir de C # 9.0, vous pouvez créer des accesseurs init au lieu de set accesseurs pour les propriétés et les indexeurs.

  Comment vous moquez-vous quand vous écrivez un test? Utilisation de la méthode Mock.NonPublic.ArrangeSet de JustMock .

    
   
     [TestMethod]   
     public   void   TestInit ()   
     {  
      // Organiser    
      var fooMock = Mock.Create  ();    
      bool   properyInitCalled =  false [19659022];    
     
      Mock.NonPublic.ArrangeSet (fooMock,  "Bar" 10)    
      .IgnoreInstance ()    
      .DoInstead (() => properyInitCalled =  true );    
     
      // Loi    
      var foo =  new   Foo ();    
     
      // Assert    
      Assert.IsTrue (properyInitCalled);    
    } 
  

  or

    
   
     [TestMethod]   
     public   void   TestInit2 ()   
     {  
      // Organiser    
      var fooMock = Mock.Create  (Constructor.NotMocked);    
      dynamic fooMockWrapper = Mock.NonPublic.Wrap ( fooMock);    
     
      Mock.NonPublic.Arrange (fooMockWrapper.Bar = 10)    
      .IgnoreInstance ()    
      .MustBeCalled ();    
        
      // Loi    
      var foo =  new   Foo ();    
     
      // Assert    
      Mock.NonPublic.Assert (fooMockWrapper.Bar = 10, Occurs.Once ());    
    } 
  

  4. Correspondance de motifs

  La correspondance de modèles est un autre excellent ajout au langage C #. Je n’expliquerai pas maintenant ce que c’est: ici vous pouvez en savoir plus à ce sujet. Mais je dirai que c'est vraiment quelque chose qui donne aux développeurs C # plus de créativité et de flexibilité!

  Comme le dit la documentation, en gros, vous regardez une structure donnée et, en fonction de son apparence, vous l'identifiez et vous pouvez alors l'utiliser immédiatement. Si vous obtenez un sac de fruits, vous regardez en bas et voyez immédiatement la différence entre les pommes et les poires.

  Pour vous montrer comment une telle fonctionnalité peut être moquée avec la méthode InRange, voici notre exemple de correspondance de motifs, puis le test ci-dessous:

   public   bool   IsInRange ( int   i) =>   
      i  is   (> = 1 et  = 100 et <= 200);    
     
     ...   
     
     [TestMethod]   
     public   void   Mock_PatternMatchingTest ()   
     {  
      // Organiser    
      var foo = Mock.Create  (Behavior.CallOriginal);    
      Mock.Arrange (() => foo.IsInRange (Arg.AnyInt) )). Renvoie ( true );    
     
      // Act    
      var result20 = foo.IsInRange (20);    
      var result150 = foo.IsInRange (150);    
     
      // As sert    
      Assert.AreEqual ( true result20);    
      Assert.AreEqual ( true result150);    
    } 
  

  Je sais ce code de lecture n'est pas la même chose que de l'exécuter, donc pour l'utiliser et jouer avec les échantillons, suivez les étapes ci-dessous:

  • Télécharger JustMock gratuitement
  • Installez-le
  • Téléchargez le projet à partir de ] ici
  • Jouez! 🙂

  Pour plus d'astuces et de voyages sur la façon d'utiliser l'API de JustMock pour écrire rapidement des tests, lisez notre Aide-mémoire .

  Essayez-le

  Si vous êtes intrigué are 🤞), je serais plus qu'heureux d'entendre vos commentaires honnêtes dans les commentaires.

  Que vous:

  • Vous êtes nouveau sur Telerik JustMock – apprenez-en plus à ce sujet via la page produit . Il est livré avec un essai gratuit de 30 jours vous donnant le temps d'explorer les capacités de JustMock.
  • Vous voulez profiter des conseils de Mihail Vladov sur la rédaction de tests utilisateur – téléchargez dès maintenant le Unit Testing eBook .

  Indépendamment des «cas» ci-dessus, n'hésitez pas à:

  Essayez le dernier JustMock maintenant

  Vous ne le regretterez pas.