public async Task WhenAddFailsReturnsMessage()
{
var user = TestUtils.GetRandomUser();
var lobbyMessage = new LobbyMessage
{
Id = 1,
MessageDateTime = DateTime.UtcNow,
MessageText = "Test Message",
Sender = user
};
UserServiceMock.Setup(us => us.GetUserFromUsernameAsync(It.IsAny <string>())).ReturnsAsync(user);
MessageServiceMock.Setup(ms => ms.AddMessageAsync(It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync(lobbyMessage);
var result = await Controller.AddMessage(new AddMessageRequest());
var response = TestUtils.GetResponseFromResult <AddMessageResponse>(result);
Assert.IsTrue(response.Success);
Assert.AreEqual(lobbyMessage.Id, response.NewMessage.Id);
Assert.AreEqual(lobbyMessage.MessageText, response.NewMessage.Message);
Assert.AreEqual(lobbyMessage.MessageDateTime, response.NewMessage.Time);
Assert.AreEqual(lobbyMessage.Sender.UserName, response.NewMessage.User);
SubscriberMock.Verify(s => s.PublishAsync(It.IsAny <RedisChannel>(), It.IsAny <RedisValue>(), It.IsAny <CommandFlags>()), Times.Once);
}
public async Task WhenUserNotFoundDoesNotBroadcast()
{
await Service.DisconnectedUserAsync("TestId");
SubscriberMock.Verify(
s => s.PublishAsync(It.Is <RedisChannel>(channel => channel == RedisChannels.UserDisconnect), It.IsAny <RedisValue>(), It.IsAny <CommandFlags>()), Times.Never);
}
public void ManyPublishersOneSubscriber()
{
using (var kernel = new StandardKernel(new MessageBrokerModule()))
{
PublisherMock pub1 = kernel.Get <PublisherMock>();
PublisherMock pub2 = kernel.Get <PublisherMock>();
Assert.That(pub1, Is.Not.Null);
Assert.That(pub2, Is.Not.Null);
SubscriberMock sub = kernel.Get <SubscriberMock>();
Assert.That(sub, Is.Not.Null);
Assert.That(pub1.HasListeners);
Assert.That(pub2.HasListeners);
Assert.That(sub.LastMessage, Is.Null);
pub1.SendMessage("Hello, world!");
Assert.That(sub.LastMessage, Is.EqualTo("Hello, world!"));
sub.LastMessage = null;
Assert.That(sub.LastMessage, Is.Null);
pub2.SendMessage("Hello, world!");
Assert.That(sub.LastMessage, Is.EqualTo("Hello, world!"));
}
}
public async Task ReturnsSuccessAndBroadcastsToAllUsers()
{
var firstUser = TestUsers.First();
var result = await Service.StartNewGameAsync(firstUser.ConnectionId, new StartNewGameRequest());
Assert.IsTrue(result.Success);
SubscriberMock.Verify(s => s.PublishAsync(It.Is <RedisChannel>(channel => channel == RedisChannels.NewGame), It.IsAny <RedisValue>(), It.IsAny <CommandFlags>()), Times.Once);
}
public async Task Connected_Unsubscribe()
{
//Arrange
await ClassUnderTest.Subscribe(cm => { }, "ChannelName");
//Act
ClassUnderTest.Unsubscribe("ChannelName");
//Assert
SubscriberMock.Verify(c => c.UnsubscribeAsync(It.IsAny <RedisChannel>(), It.IsAny <Action <RedisChannel, RedisValue> >(), It.IsAny <CommandFlags>()), Times.Once);
}
public void Unsubscribe()
{
//Arrange
//Act
ClassUnderTest.Unsubscribe("ChannelName");
//Assert
SubscriberMock.Verify(c => c.UnsubscribeAsync(It.IsAny <RedisChannel>(), It.IsAny <Action <RedisChannel, RedisValue> >(), It.IsAny <CommandFlags>()), Times.Never);
}
public async Task WhenCalledSetsNodeAndBroadcastsUser()
{
var user = new LobbyUser {
Name = "TestUser", ConnectionId = Guid.NewGuid().ToString()
};
await Service.NewUserAsync(user);
Assert.AreEqual(LobbyOptions.Value.NodeName, user.Node);
SubscriberMock.Verify(s => s.PublishAsync(It.Is <RedisChannel>(channel => channel == RedisChannels.NewUser), It.IsAny <RedisValue>(), It.IsAny <CommandFlags>()), Times.Once);
}
private SubscriberMock CreateNotifiableSubscriber(string email, string firstName, string lastName, string resolveKey)
{
SubscriberMock subscriberOne = new SubscriberMock();
subscriberOne.Email = email;
subscriberOne.FirstName = firstName;
subscriberOne.LastName = lastName;
subscriberOne.ResolveKey = resolveKey;
subscriberOne.CustomProperties = new Dictionary <string, string>();
return(subscriberOne);
}
public async Task Subscribe()
{
//Arrange
SubscriberMock.Setup(c => c.SubscribeAsync(It.IsAny <RedisChannel>(), It.IsAny <CommandFlags>()))
.ReturnsAsync(default(ChannelMessageQueue))
.Verifiable();
//Act
await ClassUnderTest.Subscribe(cm => {}, "ChannelName");
//Assert
SubscriberMock.Verify();
}
public async Task WhenCalledTwiceDoesNotBroadcastsUser()
{
var user = new LobbyUser {
Name = "TestUser", ConnectionId = Guid.NewGuid().ToString()
};
await Service.NewUserAsync(user);
await Service.NewUserAsync(user);
SubscriberMock.Verify(
s => s.PublishAsync(It.Is <RedisChannel>(channel => channel == RedisChannels.NewUser), It.IsAny <RedisValue>(), It.IsAny <CommandFlags>()), Times.AtMostOnce);
}
public async Task PublishAsync_MultiplexerIsConnected()
{
//Arrange
SetupMultiplexerIsConnected();
SubscriberMock.Setup(c => c.PublishAsync(It.IsAny <RedisChannel>(), It.IsAny <RedisValue>(), It.IsAny <CommandFlags>()))
.ReturnsAsync(0)
.Verifiable();
//Act
var result = await ClassUnderTest.PublishAsync("channelName", "value");
//Assert
result.Should().Be(0);
SubscriberMock.Verify();
}
public async Task WhenUserFoundBroadcastsUserDisconnect()
{
var user = new LobbyUser {
Name = "TestUser", ConnectionId = Guid.NewGuid().ToString()
};
await Service.NewUserAsync(user);
await Service.DisconnectedUserAsync(user.ConnectionId);
var jsonUser = JsonConvert.SerializeObject(user);
SubscriberMock.Verify(
s => s.PublishAsync(
It.Is <RedisChannel>(channel => channel == RedisChannels.UserDisconnect),
It.Is <RedisValue>(value => value == jsonUser),
It.IsAny <CommandFlags>()),
Times.Once);
}
public async Task WhenRemoveSucceedsReturnsSuccess()
{
var lobbyMessage = new LobbyMessage();
UserServiceMock.Setup(us => us.GetUserFromUsernameAsync(It.IsAny <string>())).ReturnsAsync(TestUtils.GetRandomUser());
MessageServiceMock.Setup(ms => ms.FindByIdAsync(It.IsAny <int>())).ReturnsAsync(lobbyMessage);
MessageServiceMock.Setup(ms => ms.UpdateMessageAsync(It.IsAny <LobbyMessage>())).ReturnsAsync(true);
var result = await Controller.RemoveMessage(1);
var response = TestUtils.GetResponseFromResult <DeleteMessageResponse>(result);
Assert.IsTrue(response.Success);
Assert.IsTrue(lobbyMessage.Removed);
Assert.AreEqual(DateTime.UtcNow.Date, lobbyMessage.RemovedDateTime.Date);
Assert.AreEqual(1, response.MessageId);
SubscriberMock.Verify(s => s.PublishAsync(It.IsAny <RedisChannel>(), It.IsAny <RedisValue>(), It.IsAny <CommandFlags>()), Times.Once);
}
public void ClosingChannelUnbindsPublisherEventsFromChannel()
{
using (var kernel = new StandardKernel(new MessageBrokerModule()))
{
PublisherMock pub = kernel.Get <PublisherMock>();
Assert.That(pub, Is.Not.Null);
SubscriberMock sub = kernel.Get <SubscriberMock>();
Assert.That(sub, Is.Not.Null);
Assert.That(sub.LastMessage, Is.Null);
var messageBroker = kernel.Components.Get <IMessageBroker>();
messageBroker.CloseChannel("message://PublisherMock/MessageReceived");
Assert.That(pub.HasListeners, Is.False);
pub.SendMessage("Hello, world!");
Assert.That(sub.LastMessage, Is.Null);
}
}
public void DisabledChannelsDoNotUnbindButEventsAreNotSent()
{
using (var kernel = new StandardKernel(new MessageBrokerModule()))
{
PublisherMock pub = kernel.Get <PublisherMock>();
Assert.That(pub, Is.Not.Null);
SubscriberMock sub = kernel.Get <SubscriberMock>();
Assert.That(sub, Is.Not.Null);
Assert.That(sub.LastMessage, Is.Null);
var messageBroker = kernel.Components.Get <IMessageBroker>();
messageBroker.DisableChannel("message://PublisherMock/MessageReceived");
Assert.That(pub.HasListeners);
pub.SendMessage("Hello, world!");
Assert.That(sub.LastMessage, Is.Null);
}
}
public void WhenCalledBroadcastsHello()
{
Service.Init();
SubscriberMock.Verify(s => s.Publish(It.Is <RedisChannel>(channel => channel == RedisChannels.LobbyHello), It.IsAny <RedisValue>(), It.IsAny <CommandFlags>()), Times.Once);
}