Tests unitaires des applications SignalR

  • Article

par Patrick Fletcher

Avertissement

Cette documentation ne concerne pas la dernière version de SignalR. Consultez ASP.NET Core SignalR.

Cet article décrit l’utilisation des fonctionnalités de test unitaire de SignalR 2.

Versions logicielles utilisées dans cette rubrique

Questions et commentaires

Laissez vos commentaires sur la façon dont vous avez aimé ce tutoriel et sur ce que nous pourrions améliorer dans les commentaires en bas de la page. Si vous avez des questions qui ne sont pas directement liées au tutoriel, vous pouvez les publier sur le forum ASP.NET SignalR ou StackOverflow.com.

Tests unitaires des applications SignalR

Vous pouvez utiliser les fonctionnalités de test unitaire dans SignalR 2 pour créer des tests unitaires pour votre application SignalR. SignalR 2 inclut l’interface IHubCallerConnectionContext , qui peut être utilisée pour créer un objet fictif afin de simuler les méthodes de test de votre hub.

Dans cette section, vous allez ajouter des tests unitaires pour l’application créée dans le tutoriel Prise en main à l’aide de XUnit.net et Moq.

XUnit.net sera utilisé pour contrôler le test ; Moq sera utilisé pour créer un objet fictif à des fins de test. D’autres frameworks moqueurs peuvent être utilisés si vous le souhaitez ; NSubstitute est également un bon choix. Ce tutoriel montre comment configurer l’objet fictif de deux manières : d’abord, à l’aide d’un dynamic objet (introduit dans .NET Framework 4), et deuxièmement, à l’aide d’une interface.

Contenu

Ce didacticiel contient les sections suivantes.

Test unitaire avec Dynamic

Dans cette section, vous allez ajouter un test unitaire pour l’application créée dans le tutoriel Prise en main à l’aide d’un objet dynamique.

  1. Installez l’extension XUnit Runner pour Visual Studio 2013.

  2. Suivez le didacticiel Prise en main ou téléchargez l’application terminée à partir de MSDN Code Gallery.

  3. Si vous utilisez la version de téléchargement de l’application Prise en main, ouvrez la console du Gestionnaire de package, puis cliquez sur Restaurer pour ajouter le package SignalR au projet.

    Restaurer des packages

  4. Ajoutez un projet à la solution pour le test unitaire. Cliquez avec le bouton droit sur votre solution dans Explorateur de solutions, puis sélectionnez Ajouter, Nouveau projet.... Sous le nœud C#, sélectionnez le nœud Windows. Sélectionnez Bibliothèque de classes. Nommez le nouveau projet TestLibrary , puis cliquez sur OK.

    Créer une bibliothèque de tests

  5. Ajoutez une référence dans le projet de bibliothèque de test au projet SignalRChat. Cliquez avec le bouton droit sur le projet TestLibrary et sélectionnez Ajouter, Référence.... Sélectionnez le nœud Projets sous le nœud Solution, puis case activée SignalRChat. Cliquez sur OK.

    Ajouter une référence de projet

  6. Ajoutez les packages SignalR, Moq et XUnit au projet TestLibrary . Dans la console du Gestionnaire de package, définissez la liste déroulante Projet par défaut sur TestLibrary. Exécutez les commandes suivantes dans la fenêtre de console :

    • Install-Package Microsoft.AspNet.SignalR

    • Install-Package Moq

    • Install-Package XUnit

      Installer des packages

  7. Créez le fichier de test. Cliquez avec le bouton droit sur le projet TestLibrary , puis cliquez sur Ajouter..., Classe. Nommez la nouvelle classe Tests.cs.

  8. Remplacez le contenu de Tests.cs par le code suivant.

    using System;
using Xunit;
using SignalRChat;
using Microsoft.AspNet.SignalR.Hubs;
using Moq;
using System.Dynamic;

namespace TestLibrary
{
    public class Tests
    {
        [Fact]
        public void HubsAreMockableViaDynamic()
        {
            bool sendCalled = false;
            var hub = new ChatHub();
            var mockClients = new Mock<IHubCallerConnectionContext<dynamic>>();
            hub.Clients = mockClients.Object;
            dynamic all = new ExpandoObject();
            all.broadcastMessage = new Action<string, string>((name, message) => {
                sendCalled = true;
            });
            mockClients.Setup(m => m.All).Returns((ExpandoObject)all);
            hub.Send("TestUser", "TestMessage");
            Assert.True(sendCalled);
        }
    }
}

    Dans le code ci-dessus, un client de test est créé à l’aide de l’objet Mock de la bibliothèque Moq , de type IHubCallerConnectionContext (dans SignalR 2.1, affectez dynamic pour le paramètre de type).) L’interface IHubCallerConnectionContext est l’objet proxy avec lequel vous appelez des méthodes sur le client. La broadcastMessage fonction est ensuite définie pour le client fictif afin qu’il puisse être appelé par la ChatHub classe . Le moteur de test appelle ensuite la Send méthode de la ChatHub classe, qui à son tour appelle la fonction moquée broadcastMessage .

  9. Générez la solution en appuyant sur F6.

  10. Exécutez le test unitaire. Dans Visual Studio, sélectionnez Test, Windows, Test Explorer. Dans la fenêtre Test Explorer, cliquez avec le bouton droit sur HubsAreMockableViaDynamic et sélectionnez Exécuter les tests sélectionnés.

    Capture d’écran montrant HubsAreMockableViaDynamic sélectionné dans la fenêtre Test Explorer.

  11. Vérifiez que le test a réussi en vérifiant le volet inférieur dans la fenêtre Test Explorer. La fenêtre indique que le test a réussi.

    Capture d’écran montrant que le test unitaire à l’aide d’un objet dynamique a réussi.

Tests unitaires par type

Dans cette section, vous allez ajouter un test pour l’application créée dans le tutoriel Prise en main à l’aide d’une interface qui contient la méthode à tester.

  1. Effectuez les étapes 1 à 7 du didacticiel Test unitaire avec Dynamic ci-dessus.

  2. Remplacez le contenu de Tests.cs par le code suivant.

    using Xunit;
using SignalRChat;
using Microsoft.AspNet.SignalR.Hubs;
using Moq;

namespace TestLibrary
{
    public class Tests
    {
       
       public interface IClientContract
       {
           void broadcastMessage(string name, string message);
       }
       [Fact]
       public void HubsAreMockableViaType()
       {
           var hub = new ChatHub();
           var mockClients = new Mock<IHubCallerConnectionContext<dynamic>>();
           var all = new Mock<IClientContract>();
           hub.Clients = mockClients.Object;
           all.Setup(m => m.broadcastMessage(It.IsAny<string>(), 
                It.IsAny<string>())).Verifiable();
           mockClients.Setup(m => m.All).Returns(all.Object);
           hub.Send("TestUser", "TestMessage");
           all.VerifyAll();
       }
    }
}

    Dans le code ci-dessus, une interface est créée définissant la signature de la broadcastMessage méthode pour laquelle le moteur de test va créer un client fictif. Un client fictif est ensuite créé à l’aide de l’objet Mock , de type IHubCallerConnectionContext (dans SignalR 2.1, affectez dynamic pour le paramètre type).) L’interface IHubCallerConnectionContext est l’objet proxy avec lequel vous appelez des méthodes sur le client.

    Le test crée ensuite une instance de ChatHub, puis crée une version fictive de la broadcastMessage méthode, qui à son tour est appelée en appelant la Send méthode sur le hub.

  3. Générez la solution en appuyant sur F6.

  4. Exécutez le test unitaire. Dans Visual Studio, sélectionnez Test, Windows, Test Explorer. Dans la fenêtre Test Explorer, cliquez avec le bouton droit sur HubsAreMockableViaDynamic et sélectionnez Exécuter les tests sélectionnés.

    Capture d’écran montrant HubsAreMockableViaType sélectionné dans la fenêtre Test Explorer.

  5. Vérifiez que le test a réussi en vérifiant le volet inférieur dans la fenêtre Test Explorer. La fenêtre indique que le test a réussi.

    Capture d’écran montrant que le test unitaire par type a réussi.