Come posso aggiungere il supporto di gruppo a un cliente deriso in un framework di test dell'unità SignalR 2.x?

Question

Sto utilizzando Moq per creare un framework UnitTest per la mia applicazione SignalR 2.x. Attualmente sto beffardo i miei clienti da:

var mockClients = new Mock<IHubCallerConnectionContext>(); 
Clients = mockClients.Object; 

Al fine di testare, ho bisogno di testare l'invio di messaggi dal Gruppo:

Clients.Group(groupName).sendSomeMessage(message); 

Come si aggiunge il supporto di gruppo al mio cliente deriso su?

Answer 1

Si può fare riferimento al tutorial this dal team SingalR.

Answer 2

Controllare questo: https://github.com/SignalR/SignalR/blob/release/tests/Microsoft.AspNet.SignalR.Tests/Server/Hubs/HubFacts.cs

public void HubsGroupAreMockable() 
     { 
      var hub = new MyTestableHub(); 
      var mockClients = new Mock<IHubCallerConnectionContext<dynamic>>(); 
      var groups = new Mock<IClientContract>(); 

      hub.Clients = mockClients.Object; 
      groups.Setup(m => m.send(It.IsAny<string>())).Verifiable(); 
      mockClients.Setup(m => m.Group("test")).Returns(groups.Object); 
      hub.SendGroup("test", "foo"); 

      groups.VerifyAll(); 
     } 

Answer 3

Se si desidera verificare che un certo gruppo è stato notificato si dovrebbe essere in grado di fare qualcosa di simile (questo è SignalR 2):

public interface IClientContract 
{ 
    void RaiseAlert(string message); 
} 

[Test] 
public void NotifiesOnlySpecifiedGroupWhenGroupIdSent() 
{ 
    // Adapted from code here: https://github.com/SignalR/SignalR/blob/dev/tests/Microsoft.AspNet.SignalR.Tests/Server/Hubs/HubFacts.cs 

    // Arrange 

    // Set up the individual mock clients 
    var group1 = new Mock<IClientContract>(); 
    var group2 = new Mock<IClientContract>(); 
    var group3 = new Mock<IClientContract>(); 

    group1.Setup(m => m.RaiseAlert(It.IsAny<string>())).Verifiable(); 
    group2.Setup(m => m.RaiseAlert(It.IsAny<string>())).Verifiable(); 
    group3.Setup(m => m.RaiseAlert(It.IsAny<string>())).Verifiable(); 

    // set the Connection Context to return the mock clients 
    var mockClients = new Mock<IHubCallerConnectionContext<dynamic>>(); 
    mockClients.Setup(m => m.Group("1")).Returns(group1.Object); 
    mockClients.Setup(m => m.Group("2")).Returns(group2.Object); 
    mockClients.Setup(m => m.Group("3")).Returns(group3.Object); 

    // Assign our mock context to our hub 
    var hub = new NotificationsHub 
    { 
     Clients = mockClients.Object 
    }; 

    // Act 
    hub.RaiseNotificationAlert("2"); 

    // Assert 
    group1.Verify(m => m.RaiseAlert(It.IsAny<string>()), Times.Never); 
    group2.Verify(m => m.RaiseAlert(""), Times.Once); 
    group3.Verify(m => m.RaiseAlert(It.IsAny<string>()), Times.Never); 
} 

Il codice sopra indica che il mio metodo NotificationsHub.RaiseAlert(string groupId) viene attivato solo sul lato client per il passaggio specifico groupId.

Questo è l'hub sottoposto a test:

public class NotificationsHub : Hub 
{ 
    public void RaiseAlert(string message) 
    { 
     Clients.All.RaiseAlert(message); 
    } 

    public void RaiseNotificationAlert(string groupId) 
    { 
     if (groupId== null) 
     { 
      // Notify all clients 
      Clients.All.RaiseAlert(""); 
      return; 
     } 

     // Notify only the client for this userId 
     Clients.Group(groupId).RaiseAlert(""); 

    } 
}