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);
}
private List <string> RecordOperationOrder()
{
var operations = new List <string>();
PackageStateProcessorMock
.Setup(x => x.SetStatusAsync(It.IsAny <IValidatingEntity <Package> >(), It.IsAny <PackageValidationSet>(), It.IsAny <PackageStatus>()))
.Returns(Task.CompletedTask)
.Callback(() => operations.Add(nameof(IStatusProcessor <Package> .SetStatusAsync)));
ValidationStorageServiceMock
.Setup(x => x.UpdateValidationSetAsync(It.IsAny <PackageValidationSet>()))
.Returns(Task.CompletedTask)
.Callback(() => operations.Add(nameof(IValidationStorageService.UpdateValidationSetAsync)));
MessageServiceMock
.Setup(x => x.SendPublishedMessageAsync(It.IsAny <Package>()))
.Returns(Task.CompletedTask)
.Callback(() => operations.Add(nameof(IMessageService <Package> .SendPublishedMessageAsync)));
MessageServiceMock
.Setup(x => x.SendValidationFailedMessageAsync(It.IsAny <Package>(), It.IsAny <PackageValidationSet>()))
.Returns(Task.CompletedTask)
.Callback(() => operations.Add(nameof(IMessageService <Package> .SendValidationFailedMessageAsync)));
TelemetryServiceMock
.Setup(x => x.TrackTotalValidationDuration(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <Guid>(), It.IsAny <TimeSpan>(), It.IsAny <bool>()))
.Callback(() => operations.Add(nameof(ITelemetryService.TrackTotalValidationDuration)));
PackageFileServiceMock
.Setup(x => x.DeletePackageForValidationSetAsync(It.IsAny <PackageValidationSet>()))
.Returns(Task.CompletedTask)
.Callback(() => operations.Add(nameof(IValidationFileService.DeletePackageForValidationSetAsync)));
return(operations);
}
public async Task WhenMessageNotFoundReturnsNotFound()
{
UserServiceMock.Setup(us => us.GetUserFromUsernameAsync(It.IsAny <string>())).ReturnsAsync(TestUtils.GetRandomUser());
MessageServiceMock.Setup(ms => ms.FindByIdAsync(It.IsAny <int>())).ReturnsAsync((LobbyMessage)null);
var result = await Controller.RemoveMessage(1);
Assert.IsInstanceOfType(result, typeof(NotFoundResult));
}
public async Task WhenAddFailsReturnsFailure()
{
UserServiceMock.Setup(us => us.GetUserFromUsernameAsync(It.IsAny <string>())).ReturnsAsync(TestUtils.GetRandomUser());
MessageServiceMock.Setup(ms => ms.AddMessageAsync(It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync((LobbyMessage)null);
var result = await Controller.AddMessage(new AddMessageRequest());
var response = TestUtils.GetResponseFromResult <ApiResponse>(result);
Assert.IsFalse(response.Success);
}
public async Task WhenRemoveFailsReturnsFailure()
{
UserServiceMock.Setup(us => us.GetUserFromUsernameAsync(It.IsAny <string>())).ReturnsAsync(TestUtils.GetRandomUser());
MessageServiceMock.Setup(ms => ms.FindByIdAsync(It.IsAny <int>())).ReturnsAsync(new LobbyMessage());
MessageServiceMock.Setup(ms => ms.UpdateMessageAsync(It.IsAny <LobbyMessage>())).ReturnsAsync(false);
var result = await Controller.RemoveMessage(1);
var response = TestUtils.GetResponseFromResult <ApiResponse>(result);
Assert.IsFalse(response.Success);
}
public async Task WhenCalledReturnsMessagesResponse()
{
MessageServiceMock.Setup(ns => ns.GetLatestLobbyMessagesAsync()).ReturnsAsync(new List <LobbyMessage> {
new LobbyMessage {
Sender = new GametekiUser()
}
});
var result = await Controller.GetMessages();
var response = TestUtils.GetResponseFromResult <GetMessagesResponse>(result);
Assert.IsTrue(response.Success);
Assert.AreEqual(1, response.Messages.Count);
}
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 async Task PackageStillBecomesAvailableIfPublishedMessageFails()
{
var exception = new Exception("Something baaad happened");
MessageServiceMock
.Setup(ms => ms.SendPublishedMessageAsync(It.IsAny <Package>()))
.Throws(exception);
Package.PackageStatusKey = PackageStatus.Validating;
var processor = CreateProcessor();
var thrownException = await Record.ExceptionAsync(
async() => await processor.ProcessValidationOutcomeAsync(ValidationSet, PackageValidatingEntity, ProcessorStats));
Assert.NotNull(thrownException);
PackageStateProcessorMock.Verify(
x => x.SetStatusAsync(PackageValidatingEntity, ValidationSet, PackageStatus.Available),
Times.Once);
PackageFileServiceMock.Verify(
x => x.DeletePackageForValidationSetAsync(It.IsAny <PackageValidationSet>()),
Times.Never);
}
