public async Task Then_Sends_Message_With_Correct_Values(
ReservationDeletedEvent deletedEvent,
Dictionary <string, string> tokens,
[ArrangeUsers] List <UserDetails> users,
[Frozen] Mock <INotificationTokenBuilder> mockTokenBuilder,
[Frozen] Mock <IAccountsService> mockAccountsService,
[Frozen] Mock <INotificationsService> mockNotificationsService,
NotifyEmployerOfReservationEventAction action)
{
mockAccountsService
.Setup(service => service.GetAccountUsers(deletedEvent.AccountId))
.ReturnsAsync(users);
mockTokenBuilder
.Setup(builder => builder.BuildTokens(It.IsAny <INotificationEvent>()))
.ReturnsAsync(tokens);
await action.Execute <ReservationDeletedNotificationEvent>(deletedEvent);
mockNotificationsService.Verify(service =>
service.SendNewReservationMessage(It.Is <NotificationMessage>(message =>
message.RecipientsAddress == users[0].Email &&
message.TemplateId == TemplateIds.ReservationDeleted &&
message.Tokens == tokens))
, Times.Once);
}
public void Then_Maps_Matching_Fields(ReservationDeletedEvent source)
{
ReservationDeletedNotificationEvent result = source;
result.Should().BeEquivalentTo(source, options =>
options.ExcludingMissingMembers());
}
public async Task <Unit> Handle(DeleteReservationCommand command, CancellationToken cancellationToken)
{
var validationResult = await _validator.ValidateAsync(command);
if (!validationResult.IsValid())
{
throw new ArgumentException(
"The following parameters have failed validation",
validationResult.ValidationDictionary.Select(c => c.Key).Aggregate((item1, item2) => item1 + ", " + item2));
}
var reservationToDelete = await _reservationService.GetReservation(command.ReservationId);
var deletedEvent = new ReservationDeletedEvent(
command.ReservationId,
reservationToDelete.AccountId,
reservationToDelete.AccountLegalEntityId,
reservationToDelete.AccountLegalEntityName,
reservationToDelete.StartDate.GetValueOrDefault(),
reservationToDelete.ExpiryDate.GetValueOrDefault(),
reservationToDelete.CreatedDate,
reservationToDelete.Course?.CourseId,
reservationToDelete.Course?.Title,
reservationToDelete.Course?.Level,
reservationToDelete.ProviderId,
command.EmployerDeleted);
await _reservationService.DeleteReservation(command.ReservationId);
_context.AddEvent(deletedEvent);
return(Unit.Value);
}
public async Task Then_Gets_All_Users_For_Account(
ReservationDeletedEvent deletedEvent,
[Frozen] Mock <IAccountsService> mockAccountsService,
NotifyEmployerOfReservationEventAction action)
{
await action.Execute <ReservationDeletedNotificationEvent>(deletedEvent);
mockAccountsService.Verify(service => service.GetAccountUsers(deletedEvent.AccountId),
Times.Once);
}
public async Task And_Has_ProviderId_But_Deleted_By_Employer_Then_No_Further_Processing(
ReservationDeletedEvent deletedEvent,
[Frozen] Mock <IAccountsService> mockAccountsService,
NotifyEmployerOfReservationEventAction action)
{
deletedEvent.EmployerDeleted = true;
await action.Execute <ReservationDeletedNotificationEvent>(deletedEvent);
mockAccountsService.Verify(service => service.GetAccountUsers(It.IsAny <long>()),
Times.Never);
}
public async Task And_Not_Levy_Then_No_Further_Processing(
ReservationDeletedEvent deletedEvent,
[Frozen] Mock <IAccountsService> mockAccountsService,
NotifyEmployerOfReservationEventAction action)
{
deletedEvent.CourseId = null;
deletedEvent.StartDate = DateTime.MinValue;
await action.Execute <ReservationDeletedNotificationEvent>(deletedEvent);
mockAccountsService.Verify(service => service.GetAccountUsers(It.IsAny <long>()),
Times.Never);
}
public async Task Then_Sends_Message_For_Each_User(
ReservationDeletedEvent deletedEvent,
[ArrangeUsers] List <UserDetails> users,
[Frozen] Mock <IAccountsService> mockAccountsService,
[Frozen] Mock <INotificationsService> mockNotificationsService,
NotifyEmployerOfReservationEventAction action)
{
mockAccountsService
.Setup(service => service.GetAccountUsers(deletedEvent.AccountId))
.ReturnsAsync(users);
await action.Execute <ReservationDeletedNotificationEvent>(deletedEvent);
users.ForEach(user =>
mockNotificationsService.Verify(service =>
service.SendNewReservationMessage(It.Is <NotificationMessage>(message =>
message.RecipientsAddress == user.Email)), Times.Once));
}
public static async Task Run(
[NServiceBusTrigger(EndPoint = QueueNames.ReservationDeleted)] ReservationDeletedEvent message,
[Inject] ILogger <ReservationDeletedEvent> log,
[Inject] IReservationDeletedHandler handler)
{
log.LogInformation($"Reservation Deleted function executing at: [{DateTime.UtcNow}] UTC, event with ID: [{message.Id}].");
if (message.Id != null && message.Id != Guid.Empty)
{
await handler.Handle(message);
log.LogInformation($"Reservation Deleted function finished at: [{DateTime.UtcNow}] UTC, event with ID: [{message.Id}] has been handled.");
}
else
{
log.LogInformation($"No reservation deleted, no reservation ReservationId provided");
}
}
public async Task And_User_Not_Subscribed_Then_Skips(
ReservationDeletedEvent deletedEvent,
[ArrangeUsers] List <UserDetails> users,
[Frozen] Mock <IAccountsService> mockAccountsService,
[Frozen] Mock <INotificationsService> mockNotificationsService,
NotifyEmployerOfReservationEventAction action)
{
users[0].CanReceiveNotifications = false;
mockAccountsService
.Setup(service => service.GetAccountUsers(deletedEvent.AccountId))
.ReturnsAsync(users);
await action.Execute <ReservationDeletedNotificationEvent>(deletedEvent);
mockNotificationsService.Verify(service =>
service.SendNewReservationMessage(It.Is <NotificationMessage>(message =>
message.RecipientsAddress == users[0].Email)), Times.Never);
users.Where(user => user.CanReceiveNotifications).ToList().ForEach(user =>
mockNotificationsService.Verify(service =>
service.SendNewReservationMessage(It.Is <NotificationMessage>(message =>
message.RecipientsAddress == user.Email)), Times.Once));
}
public async Task Then_Notification_Action_Executed_And_Index_Updated(ReservationDeletedEvent deletedEvent)
{
//Arrange
var reservationService = new Mock <IReservationService>();
var notifyAction = new Mock <INotifyEmployerOfReservationEventAction>();
var handler = new ReservationDeletedHandler(reservationService.Object, notifyAction.Object);
//Act
await HandleReservationDeletedEvent.Run(
deletedEvent,
Mock.Of <ILogger <ReservationDeletedEvent> >(),
handler);
//Assert
notifyAction.Verify(s => s.Execute(It.Is <ReservationDeletedNotificationEvent>(ev =>
ev.Id == deletedEvent.Id)), Times.Once);
reservationService.Verify(x => x.UpdateReservationStatus(
deletedEvent.Id,
ReservationStatus.Deleted,
null,
null,
null));
}
public async Task Handle(ReservationDeletedEvent deletedEvent)
{
await _action.Execute <ReservationDeletedNotificationEvent>(deletedEvent);
await _reservationService.UpdateReservationStatus(deletedEvent.Id, ReservationStatus.Deleted);
}
