Unit test di applicazioni SignalR

  • Articolo

di Patrick Fletcher

Avviso

Questa documentazione non è per la versione più recente di SignalR. Esaminare ASP.NET Core SignalR.

Questo articolo descrive l'uso delle funzionalità di Unit Testing di SignalR 2.

Versioni software usate in questo argomento

Domande e commenti

Lasciare commenti e suggerimenti su come è piaciuta questa esercitazione e cosa è possibile migliorare nei commenti nella parte inferiore della pagina. Se si hanno domande che non sono direttamente correlate all'esercitazione, è possibile pubblicarle nel forum di ASP.NET SignalR o StackOverflow.com.

Applicazioni SignalR di testing unità

È possibile usare le funzionalità di unit test in SignalR 2 per creare unit test per l'applicazione SignalR. SignalR 2 include l'interfaccia IHubCallerConnectionContext , che può essere usata per creare un oggetto fittizio per simulare i metodi hub per il test.

In questa sezione si aggiungeranno unit test per l'applicazione creata nell'esercitazione Introduzione usando XUnit.net e Moq.

XUnit.net verranno utilizzati per controllare il test; Moq verrà usato per creare un oggetto fittizio per il test. Se lo si desidera, è possibile usare altri framework fittizi; NSubstitute è anche una buona scelta. Questa esercitazione illustra come configurare l'oggetto fittizio in due modi: Innanzitutto, usando un dynamic oggetto (introdotto in .NET Framework 4) e il secondo usando un'interfaccia.

Contenuto

Questa esercitazione contiene le sezioni seguenti.

Unit test con Dynamic

In questa sezione si aggiungerà uno unit test per l'applicazione creata nell'esercitazione Introduzione usando un oggetto dinamico.

  1. Installare l'estensione XUnit Runner per Visual Studio 2013.

  2. Completare l'esercitazione Introduzione oppure scaricare l'applicazione completata da MSDN Code Gallery.

  3. Se si usa la versione di download dell'applicazione Introduzione, aprire Console di Gestione pacchetti e fare clic su Ripristina per aggiungere il pacchetto SignalR al progetto.

    Ripristinare i pacchetti

  4. Aggiungere un progetto alla soluzione per lo unit test. Fare clic con il pulsante destro del mouse sulla soluzione in Esplora soluzioni e scegliere Aggiungi, Nuovo progetto.... Nel nodo C# selezionare il nodo Windows. Selezionare Libreria di classi. Assegnare al nuovo progetto il nome TestLibrary e fare clic su OK.

    Creare una libreria di test

  5. Aggiungere un riferimento nel progetto della libreria di test al progetto SignalRChat. Fare clic con il pulsante destro del mouse sul progetto TestLibrary e scegliere Aggiungi, Riferimento.... Selezionare il nodo Progetti nel nodo Soluzione e selezionare SignalRChat. Fare clic su OK.

    Aggiungere un riferimento al progetto

  6. Aggiungere i pacchetti SignalR, Moq e XUnit al progetto TestLibrary . Nella console di Gestione pacchetti impostare l'elenco a discesa Progetto predefinito su TestLibrary. Eseguire i comandi seguenti nella finestra della console:

    • Install-Package Microsoft.AspNet.SignalR

    • Install-Package Moq

    • Install-Package XUnit

      Installare pacchetti

  7. Creare il file di test. Fare clic con il pulsante destro del mouse sul progetto TestLibrary e scegliere Aggiungi,Classe. Assegnare alla nuova classe il nome Tests.cs.

  8. Sostituire il contenuto di Tests.cs con il codice seguente.

    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);
        }
    }
}

    Nel codice precedente viene creato un client di test usando l'oggetto Mock della libreria Moq , di tipo IHubCallerConnectionContext (in SignalR 2.1, assegnare dynamic per il parametro di tipo). L'interfaccia IHubCallerConnectionContext è l'oggetto proxy con cui si richiamano i metodi nel client. La broadcastMessage funzione viene quindi definita per il client fittizio in modo che possa essere chiamata dalla ChatHub classe . Il motore di test chiama quindi il Send metodo della ChatHub classe , che a sua volta chiama la funzione fittizia broadcastMessage .

  9. Compilare la soluzione premendo F6.

  10. Eseguire lo unit test. In Visual Studio selezionare Test, Windows, Esplora test. Nella finestra Esplora test fare clic con il pulsante destro del mouse su HubsAreMockableViaDynamic e scegliere Esegui test selezionati.

    Screenshot che mostra HubsAreMockableViaDynamic selezionato nella finestra Esplora test.

  11. Verificare che il test sia stato superato controllando il riquadro inferiore nella finestra Esplora test. La finestra mostrerà che il test è stato superato.

    Screenshot che mostra lo unit test usando un oggetto dinamico superato.

Unit test per tipo

In questa sezione si aggiungerà un test per l'applicazione creata nell'esercitazione Introduzione usando un'interfaccia contenente il metodo da testare.

  1. Completare i passaggi da 1 a 7 nell'esercitazione unit test con l'esercitazione dinamica precedente.

  2. Sostituire il contenuto di Tests.cs con il codice seguente.

    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();
       }
    }
}

    Nel codice precedente viene creata un'interfaccia che definisce la firma del broadcastMessage metodo per cui il motore di test creerà un client fittizio. Viene quindi creato un client fittizio usando l'oggetto Mock , di tipo IHubCallerConnectionContext (in SignalR 2.1, assegnare dynamic per il parametro di tipo). L'interfaccia IHubCallerConnectionContext è l'oggetto proxy con cui si richiamano i metodi nel client.

    Il test crea quindi un'istanza di ChatHube quindi crea una versione fittizia del broadcastMessage metodo , che a sua volta viene richiamata chiamando il Send metodo nell'hub.

  3. Compilare la soluzione premendo F6.

  4. Eseguire lo unit test. In Visual Studio selezionare Test, Windows, Esplora test. Nella finestra Esplora test fare clic con il pulsante destro del mouse su HubsAreMockableViaDynamic e scegliere Esegui test selezionati.

    Screenshot che mostra HubsAreMockableViaType selezionato nella finestra Esplora test.

  5. Verificare che il test sia stato superato controllando il riquadro inferiore nella finestra Esplora test. La finestra mostrerà che il test è stato superato.

    Screenshot che mostra lo unit test per tipo superato.