Jak dodać obsługę grupy do wyśmiewanego klienta w strukturze testowania jednostkowego SignalR 2.x?

Question

Używam Moq, aby zbudować framework UnitTest dla mojej aplikacji SignalR 2.x. Jestem obecnie wzornikiem moich klientów poprzez:

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

W celu przetestowania, muszę przetestować wysyłanie wiadomości przez Grupę:

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

Jak dodać wsparcie grupowe do mojego wyśmiewali się Klientem?

Answer 1

Możesz odnieść się do samouczka this zespołu SingalR.

Answer 2

Sprawdź to: 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

Jeśli chcesz sprawdzić, że pewna grupa została zgłoszona powinieneś być w stanie zrobić coś takiego (to 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); 
} 

Powyższy kod sprawdza, czy moja metoda NotificationsHub.RaiseAlert(string groupId) jest wywoływana tylko po stronie klienta dla określonego przejścia groupId.

To jest testowane centrum:

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

    } 
}