[InlineData(Email, "PASSWORD", false)] // Password casing
public async Task Authenticate_GivenCredentials_VerifiesPasswordAndEmail(string email, string password, bool shouldWork)
{
GetDatabaseContext getContext = ContextUtilities.CreateInMemoryContext(_output);
// Arrange
using (IDatabaseContext context = getContext())
{
EntityEntry <User> userEntry = context.Users.Add(ContextUtilities.CreateJohnDoe());
userEntry.Entity.Email = Email;
userEntry.Entity.PasswordHash = PasswordHash;
await context.SaveChangesAsync();
}
// Act
var passwordServiceMock = new Mock <IPasswordService>();
passwordServiceMock.Setup(p => p.NeedsRehash(PasswordHash)).Returns(false);
passwordServiceMock.Setup(p => p.VerifyPassword(Password, PasswordHash)).Returns(true);
var authenticationService = new AuthenticationService(passwordServiceMock.Object, getContext, DummyLogger <AuthenticationService>());
(bool isAuthenticated, _) = await authenticationService.AuthenticateAsync(email, password);
// Assert
passwordServiceMock.Verify(p => p.VerifyPassword(password, PasswordHash), Times.AtMostOnce);
if (shouldWork)
{
passwordServiceMock.Verify(p => p.NeedsRehash(PasswordHash), Times.Once);
}
Assert.Equal(shouldWork, isAuthenticated);
}
public async Task SetNewUserData_GivenValidData_UserUpdated()
{
GetDatabaseContext getContext = ContextUtilities.CreateInMemoryContext(_output);
int johnId;
const string NewName = "New Fancy Name";
const string NewMail = "*****@*****.**";
// Arrange
using (IDatabaseContext context = getContext())
{
User john = context.Users.Add(ContextUtilities.CreateJohnDoe()).Entity;
await context.SaveChangesAsync();
johnId = john.Id;
}
// Act
(UserController controller, _, _, _) = CreateController(getContext, johnId);
IActionResult response = await controller.SetNewUserData(new SetUserDataDto { NewEmail = NewMail, NewFullName = NewName });
// Assert
Assert.IsType <OkResult>(response);
using (IDatabaseContext context = getContext())
{
User loadedUser = context.Users.Single();
Assert.Equal(NewName, loadedUser.FullName);
Assert.Equal(NewMail, loadedUser.Email);
}
}
public async Task JoinEvent_GivenPrivateEvent_OrganizerCanJoin()
{
GetDatabaseContext getContext = ContextUtilities.CreateInMemoryContext(_output);
int organizerId;
int eventId;
// Arrange
using (IDatabaseContext context = getContext())
{
Event @event = DummyEvent(ContextUtilities.CreateJohnDoe(), true);
context.Events.Add(@event);
await context.SaveChangesAsync();
organizerId = @event.OrganizerId;
eventId = @event.Id;
}
// Act
(ParticipateEventController participateEventController, _) = CreateController(getContext, organizerId);
IActionResult response = await participateEventController.JoinEvent(new JoinEventDto
{
EventId = eventId
});
// Assert
Assert.IsType <OkResult>(response);
}
public async Task Register_GivenExistingEmail_UserNotRegistered()
{
GetDatabaseContext getContext = ContextUtilities.CreateInMemoryContext(_output);
// Arrange
var data = new RegisterDto {
Email = "*****@*****.**", FullName = "New User", Password = "******"
};
using (IDatabaseContext context = getContext())
{
context.Users.Add(new User
{
Email = data.Email,
FullName = "Some other name",
PasswordHash = "Some hashed password"
});
await context.SaveChangesAsync();
}
// Act
(UserController controller, _, _, _) = CreateController(getContext, null);
IActionResult response = await controller.Register(data);
// Assert
Assert.IsType <BadRequestObjectResult>(response);
var objectResult = (BadRequestObjectResult)response;
Assert.Equal(RequestStringMessages.EmailAlreadyInUse, objectResult.Value);
}
public async Task DeleteEvent_GivenNonExistingEvent_ErrorReturned()
{
GetDatabaseContext getContext = ContextUtilities.CreateInMemoryContext(_output);
int johnDoeId;
int eventId;
// Arrange
using (IDatabaseContext context = getContext())
{
User john = ContextUtilities.CreateJohnDoe();
User richard = ContextUtilities.CreateRichardRoe();
Event @event = DummyEvent(richard, true);
await context.SaveChangesAsync();
johnDoeId = john.Id;
eventId = @event.Id;
}
// Act
(OrganizeEventController controller, _) = CreateController(getContext, johnDoeId);
IActionResult response = await controller.DeleteEvent(eventId);
// Assert
Assert.IsType <BadRequestObjectResult>(response);
var objectResult = (BadRequestObjectResult)response;
Assert.Equal(RequestStringMessages.EventNotFound, objectResult.Value);
}
public async Task GetDetails_GivenPublicEvent_DetailsReturned()
{
GetDatabaseContext getContext = ContextUtilities.CreateInMemoryContext(_output);
int publicEventId;
int johnId;
// Arrange
using (IDatabaseContext context = getContext())
{
EntityEntry <User> john = context.Users.Add(ContextUtilities.CreateJohnDoe());
User richard = ContextUtilities.CreateRichardRoe();
Event publicEvent = DummyEvent(richard);
context.Events.Add(publicEvent);
await context.SaveChangesAsync();
publicEventId = publicEvent.Id;
johnId = john.Entity.Id;
}
// Act
(ParticipateEventController participateEventController, _) = CreateController(getContext, johnId);
IActionResult response = await participateEventController.GetDetails(publicEventId);
// Assert
Assert.IsType <OkObjectResult>(response);
}
public async Task JoinEvent_GivenPrivateEvent_UserCanNotJoin()
{
GetDatabaseContext getContext = ContextUtilities.CreateInMemoryContext(_output);
int johnDoeId;
int eventId;
// Arrange
using (IDatabaseContext context = getContext())
{
EntityEntry <User> john = context.Users.Add(ContextUtilities.CreateJohnDoe());
Event privateEvent = DummyEvent(ContextUtilities.CreateRichardRoe(), true);
context.Events.Add(privateEvent);
await context.SaveChangesAsync();
johnDoeId = john.Entity.Id;
eventId = privateEvent.Id;
}
// Act
(ParticipateEventController participateEventController, _) = CreateController(getContext, johnDoeId);
IActionResult response = await participateEventController.JoinEvent(new JoinEventDto
{
EventId = eventId
});
// Assert
Assert.IsType <BadRequestObjectResult>(response);
var objectResult = (BadRequestObjectResult)response;
Assert.Equal(RequestStringMessages.InvitationRequired, objectResult.Value);
}
private (GetDatabaseContext, SessionService) SetupSessionService()
{
GetDatabaseContext getContext = ContextUtilities.CreateInMemoryContext(_output);
var sessionService = new SessionService(_configuration, getContext, DummyLogger <SessionService>());
return(getContext, sessionService);
}
public async Task DeleteAccount_GivenSimpleUser_UserDeleted()
{
GetDatabaseContext getContext = ContextUtilities.CreateInMemoryContext(_output);
int johnDoeId;
// Arrange
using (IDatabaseContext context = getContext())
{
EntityEntry <User> john = context.Users.Add(ContextUtilities.CreateJohnDoe());
await context.SaveChangesAsync();
johnDoeId = john.Entity.Id;
}
// Act
(UserController controller, _, _, _) = CreateController(getContext, johnDoeId);
IActionResult response = await controller.DeleteAccount();
// Assert
Assert.IsType <OkResult>(response);
using (IDatabaseContext context = getContext())
{
Assert.Empty(context.Users);
}
}
public async Task GetChatMessage_GivenNotParticipatingUser_ErrorReturned()
{
GetDatabaseContext getContext = ContextUtilities.CreateInMemoryContext(_output);
int johnDoeId;
int eventId;
// Arrange
using (IDatabaseContext context = getContext())
{
EntityEntry <User> john = context.Users.Add(ContextUtilities.CreateJohnDoe());
Event privateEvent = DummyEvent(john.Entity);
context.Events.Add(privateEvent);
await context.SaveChangesAsync();
johnDoeId = john.Entity.Id;
eventId = privateEvent.Id;
}
// Act
(EventChatController eventChatController, _) = CreateController(getContext, johnDoeId);
IActionResult response = await eventChatController.GetChatMessages(new GetChatMessagesDto { EventId = eventId });
// Assert
Assert.IsType <BadRequestObjectResult>(response);
var objectResult = (BadRequestObjectResult)response;
Assert.Equal(RequestStringMessages.UserNotPartOfEvent, objectResult.Value);
}
public async Task ConfigureNotifications_GivenNonexistentEvent_ErrorReturned()
{
GetDatabaseContext getContext = ContextUtilities.CreateInMemoryContext(_output);
int johnId;
// Arrange
using (IDatabaseContext context = getContext())
{
EntityEntry <User> john = context.Users.Add(ContextUtilities.CreateJohnDoe());
await context.SaveChangesAsync();
johnId = john.Entity.Id;
}
// Act
(ParticipateEventController participateEventController, _) = CreateController(getContext, johnId);
IActionResult response = await participateEventController.ConfigureNotifications(new NotificationConfigurationDto { EventId = 42, SendReminderEmail = true, SendSummaryEmail = true, SendLastMinuteChangesEmail = true });
// Assert
Assert.IsType <BadRequestObjectResult>(response);
var objectResult = (BadRequestObjectResult)response;
Assert.Equal(RequestStringMessages.UserNotPartOfEvent, objectResult.Value);
}
public async Task SetNewUserData_GivenAlreadyUsedEmail_ErrorReturned()
{
GetDatabaseContext getContext = ContextUtilities.CreateInMemoryContext(_output);
int johnId;
const string NewName = "New Fancy Name";
string usedEmail;
// Arrange
using (IDatabaseContext context = getContext())
{
User john = context.Users.Add(ContextUtilities.CreateJohnDoe()).Entity;
User richard = context.Users.Add(ContextUtilities.CreateRichardRoe()).Entity;
usedEmail = richard.Email;
await context.SaveChangesAsync();
johnId = john.Id;
}
// Act
(UserController controller, _, _, _) = CreateController(getContext, johnId);
IActionResult response = await controller.SetNewUserData(new SetUserDataDto { NewEmail = usedEmail, NewFullName = NewName });
// Assert
Assert.IsType <BadRequestObjectResult>(response);
var objectResult = (BadRequestObjectResult)response;
Assert.Equal(RequestStringMessages.EmailAlreadyInUse, objectResult.Value);
}
public async Task SetNewPassword_GivenWrongCurrentPassword_DoesNotChangePassword()
{
GetDatabaseContext getContext = ContextUtilities.CreateInMemoryContext(_output);
User john;
const string WrongCurrentPassword = "******";
// Arrange
using (IDatabaseContext context = getContext())
{
john = context.Users.Add(ContextUtilities.CreateJohnDoe()).Entity;
await context.SaveChangesAsync();
}
// Act
(UserController controller, _, Mock <IPasswordService> passwordServiceMock, _) = CreateController(getContext, john.Id);
passwordServiceMock.Setup(p => p.VerifyPassword(WrongCurrentPassword, john.PasswordHash)).Returns(false);
IActionResult response = await controller.SetNewPassword(new SetPasswordDto { CurrentPassword = WrongCurrentPassword, NewPassword = "******" });
// Assert
Assert.IsType <BadRequestObjectResult>(response);
var objectResult = (BadRequestObjectResult)response;
Assert.Equal(RequestStringMessages.CurrentPasswordWrong, objectResult.Value);
}
public async Task ResetPassword_GivenUsedPasswordReset_RequestRejected()
{
GetDatabaseContext getContext = ContextUtilities.CreateInMemoryContext(_output);
Guid resetToken;
// Arrange
using (IDatabaseContext context = getContext())
{
User john = ContextUtilities.CreateJohnDoe();
var reset = new PasswordReset {
Requested = DateTime.UtcNow, User = john, Used = true
};
context.PasswordResets.Add(reset);
await context.SaveChangesAsync();
resetToken = reset.Token;
}
// Act
(ResetPasswordController controller, _, _) = CreateController(getContext, null);
IActionResult response = await controller.ResetPassword(new ResetPasswordDto { NewPassword = "******", PasswordResetToken = resetToken });
// Assert
Assert.IsType <BadRequestObjectResult>(response);
var badRequestResponse = (BadRequestObjectResult)response;
Assert.Equal(RequestStringMessages.ResetCodeAlreadyUsedOrExpired, badRequestResponse.Value);
}
public async Task DeleteAccount_GivenUserWithSimpleRelations_UserAndRelationsDeleted()
{
GetDatabaseContext getContext = ContextUtilities.CreateInMemoryContext(_output);
int johnDoeId;
// Arrange
using (IDatabaseContext context = getContext())
{
User john = ContextUtilities.CreateJohnDoe();
context.PasswordResets.Add(new PasswordReset {
Requested = DateTime.UtcNow, User = john
});
context.Sessions.Add(new Session {
Created = DateTime.UtcNow, User = john
});
await context.SaveChangesAsync();
johnDoeId = john.Id;
}
// Act
(UserController controller, _, _, _) = CreateController(getContext, johnDoeId);
IActionResult response = await controller.DeleteAccount();
// Assert
Assert.IsType <OkResult>(response);
using (IDatabaseContext context = getContext())
{
Assert.Empty(context.Users);
Assert.Empty(context.Sessions);
Assert.Empty(context.PasswordResets);
}
}
public async Task SetNewPassword_GivenCorrectCurrentPassword_ChangesPassword()
{
GetDatabaseContext getContext = ContextUtilities.CreateInMemoryContext(_output);
User john;
const string CorrectCurrentPassword = "******";
const string NewPassword = "******";
const string NewPasswordHash = "Néw P@ssw0rd";
// Arrange
using (IDatabaseContext context = getContext())
{
john = context.Users.Add(ContextUtilities.CreateJohnDoe()).Entity;
await context.SaveChangesAsync();
}
// Act
(UserController controller, _, Mock <IPasswordService> passwordServiceMock, _) = CreateController(getContext, john.Id);
passwordServiceMock.Setup(p => p.VerifyPassword(CorrectCurrentPassword, john.PasswordHash)).Returns(true);
passwordServiceMock.Setup(p => p.HashPassword(NewPassword)).Returns(NewPasswordHash);
IActionResult response = await controller.SetNewPassword(new SetPasswordDto { CurrentPassword = CorrectCurrentPassword, NewPassword = NewPassword });
// Assert
Assert.IsType <OkResult>(response);
using (IDatabaseContext context = getContext())
{
User loadedUser = context.Users.Single();
Assert.Equal(NewPasswordHash, loadedUser.PasswordHash);
}
}
public async Task RemoveFromEvent_GivenParticipatingUser_UserLeavesEventAndAppointments()
{
GetDatabaseContext getContext = ContextUtilities.CreateInMemoryContext(_output);
int johnDoeId;
int eventId;
int appointmentId;
// Arrange
using (IDatabaseContext context = getContext())
{
EntityEntry <User> john = context.Users.Add(ContextUtilities.CreateJohnDoe());
Event @event = DummyEvent(ContextUtilities.CreateRichardRoe());
context.EventParticipations.Add(new EventParticipation {
Participant = john.Entity, Event = @event
});
var appointment = new Appointment
{
Event = @event,
StartTime = DateTime.UtcNow + TimeSpan.FromDays(1)
};
context.AppointmentParticipations.Add(new AppointmentParticipation {
Appointment = appointment, Participant = john.Entity, AppointmentParticipationAnswer = AppointmentParticipationAnswer.Accepted
});
await context.SaveChangesAsync();
johnDoeId = john.Entity.Id;
eventId = @event.Id;
appointmentId = appointment.Id;
}
// Act
(ParticipateEventController participateEventController, Mock <AssertingNotificationService> notificationServiceMock) = CreateController(getContext, johnDoeId);
Expression <Func <AssertingNotificationService, Task> > sendLastMinuteChangeExpression = n => n.SendLastMinuteChangeIfRequiredAsync(It.Is <Appointment>(a => a.Id == appointmentId));
notificationServiceMock.Setup(sendLastMinuteChangeExpression).CallBase();
IActionResult response = await participateEventController.RemoveFromEvent(new RemoveFromEventDto
{
EventId = eventId,
UserId = johnDoeId
});
// Assert
Assert.IsType <OkResult>(response);
notificationServiceMock.Verify(sendLastMinuteChangeExpression, Times.Once);
using (IDatabaseContext context = getContext())
{
Assert.Single(context.Events);
Assert.Empty(context.EventParticipations);
Assert.Single(context.Appointments);
Assert.Empty(context.AppointmentParticipations);
}
}
public async Task DeleteAccount_GivenUserWithEvents_UserAndEventsDeleted()
{
GetDatabaseContext getContext = ContextUtilities.CreateInMemoryContext(_output);
int johnDoeId;
int eventId1;
int eventId2;
// Arrange
using (IDatabaseContext context = getContext())
{
User john = ContextUtilities.CreateJohnDoe();
Event event1 = DummyEvent(john);
Event event2 = DummyEvent(john, true);
context.EventParticipations.Add(new EventParticipation {
Event = event1, Participant = john
});
context.EventParticipations.Add(new EventParticipation {
Event = event2, Participant = john
});
context.EventInvitations.Add(new EventInvitation {
Event = event1, Requested = DateTime.UtcNow
});
context.EventInvitations.Add(new EventInvitation {
Event = event2, Requested = DateTime.UtcNow
});
await context.SaveChangesAsync();
johnDoeId = john.Id;
eventId1 = event1.Id;
eventId2 = event2.Id;
}
// Act
(UserController controller, _, _, Mock <AssertingNotificationService> notificationMock) = CreateController(getContext, johnDoeId);
notificationMock.Setup(n => n.NotifyEventDeletedAsync(It.Is <EventNotificationInformation>(e => e.Id == eventId1))).CallBase();
notificationMock.Setup(n => n.NotifyEventDeletedAsync(It.Is <EventNotificationInformation>(e => e.Id == eventId2))).CallBase();
IActionResult response = await controller.DeleteAccount();
// Assert
notificationMock.Verify(n => n.NotifyEventDeletedAsync(It.Is <EventNotificationInformation>(e => e.Id == eventId1)), Times.Once);
notificationMock.Verify(n => n.NotifyEventDeletedAsync(It.Is <EventNotificationInformation>(e => e.Id == eventId2)), Times.Once);
Assert.IsType <OkResult>(response);
using (IDatabaseContext context = getContext())
{
Assert.Empty(context.Users);
Assert.Empty(context.Events);
Assert.Empty(context.EventParticipations);
}
}
public async Task RemoveFromEvent_GivenDeclinedUser_NoUpdateSent()
{
GetDatabaseContext getContext = ContextUtilities.CreateInMemoryContext(_output);
int johnDoeId;
int eventId;
// Arrange
using (IDatabaseContext context = getContext())
{
EntityEntry <User> john = context.Users.Add(ContextUtilities.CreateJohnDoe());
Event @event = DummyEvent(ContextUtilities.CreateRichardRoe());
context.EventParticipations.Add(new EventParticipation {
Participant = john.Entity, Event = @event
});
var appointment = new Appointment
{
Event = @event,
StartTime = DateTime.UtcNow + TimeSpan.FromDays(1)
};
context.AppointmentParticipations.Add(new AppointmentParticipation {
Appointment = appointment, Participant = john.Entity, AppointmentParticipationAnswer = AppointmentParticipationAnswer.Declined
});
context.AppointmentParticipations.Add(new AppointmentParticipation {
Appointment = appointment, Participant = john.Entity, AppointmentParticipationAnswer = null
});
await context.SaveChangesAsync();
johnDoeId = john.Entity.Id;
eventId = @event.Id;
}
// Act
(ParticipateEventController participateEventController, Mock <AssertingNotificationService> _) = CreateController(getContext, johnDoeId);
IActionResult response = await participateEventController.RemoveFromEvent(new RemoveFromEventDto
{
EventId = eventId,
UserId = johnDoeId
});
// Assert
Assert.IsType <OkResult>(response);
using (IDatabaseContext context = getContext())
{
Assert.Single(context.Events);
Assert.Empty(context.EventParticipations);
Assert.Single(context.Appointments);
Assert.Empty(context.AppointmentParticipations);
}
}
public async Task RunAsync_GivenFutureAppointments_SendsReminder()
{
GetDatabaseContext getContext = ContextUtilities.CreateInMemoryContext(_output);
// Arrange
Appointment appointment = await CreateTestDataAsync(getContext, DateTime.UtcNow + TimeSpan.FromHours(ReminderTimeWindowInHours));
// Act
(CronSendReminderAndSummaryService service, Mock <AssertingNotificationService> notificationServiceMock) = CreateService(getContext);
notificationServiceMock.Setup(n => n.SendAndUpdateRemindersAsync(It.Is <Appointment>(a => a.Id == appointment.Id))).CallBase();
await service.RunAsync(CancellationToken.None);
// Assert
notificationServiceMock.Verify(n => n.SendAndUpdateRemindersAsync(It.Is <Appointment>(a => a.Id == appointment.Id)), Times.Once);
}
public async Task ResetPassword_GivenInvalidPasswordReset_RequestRejected()
{
GetDatabaseContext getContext = ContextUtilities.CreateInMemoryContext(_output);
// Act
(ResetPasswordController controller, _, _) = CreateController(getContext, null);
IActionResult response = await controller.ResetPassword(new ResetPasswordDto { NewPassword = "******", PasswordResetToken = Guid.NewGuid() });
// Assert
Assert.IsType <BadRequestObjectResult>(response);
var badRequestResponse = (BadRequestObjectResult)response;
Assert.Equal(RequestStringMessages.ResetCodeInvalid, badRequestResponse.Value);
}
public async Task RunAsync_GivenUnreadMessages_NotificationsSent()
{
GetDatabaseContext getContext = ContextUtilities.CreateInMemoryContext(_output);
DateTime latestSentDate = DateTime.UtcNow - TimeSpan.FromHours(1);
// Arrange
IEnumerable <ChatMessage> CreateMessagesFunc(User john, User richard)
{
yield return(new ChatMessage {
Author = john, Content = "Some early message", SentDate = latestSentDate - TimeSpan.FromSeconds(60)
});
yield return(new ChatMessage {
Author = john, Content = "Some late message", SentDate = latestSentDate
});
yield return(new ChatMessage {
Author = richard, Content = "Some average message", SentDate = latestSentDate - TimeSpan.FromSeconds(30)
});
}
Event @event = await CreateTestDataAsync(getContext, latestSentDate - TimeSpan.FromHours(1), DateTime.MinValue, CreateMessagesFunc);
// Act
(CronSendMissedChatMessagesService service, Mock <AssertingNotificationService> notificationServiceMock) = CreateService(getContext);
Expression <Func <AssertingNotificationService, Task> > mockExpression =
n => n.NotifyUnreadChatMessagesAsync(It.Is <ChatMessagesNotificationInformation>(
a => (a.EventId == @event.Id) && (a.Messages.Count == 3)));
notificationServiceMock.Setup(mockExpression).CallBase();
await service.RunAsync(CancellationToken.None);
// Assert
notificationServiceMock.Verify(mockExpression, Times.Exactly(2));
using (IDatabaseContext context = getContext())
{
List <EventParticipation> participations = await context.EventParticipations.ToListAsync();
Assert.Equal(2, participations.Count);
foreach (EventParticipation eventParticipation in participations)
{
Assert.Equal(latestSentDate, eventParticipation.LastReadMessageSentDate);
}
}
}
public async Task GetOverview_GivenSomeEvents_OnlyShowsPublicEvents()
{
GetDatabaseContext getContext = ContextUtilities.CreateInMemoryContext(_output);
int publicEventId1;
int publicEventId2;
int privateEventId;
int johnId;
// Arrange
using (IDatabaseContext context = getContext())
{
EntityEntry <User> john = context.Users.Add(ContextUtilities.CreateJohnDoe());
User organizer = ContextUtilities.CreateRichardRoe();
Event publicEvent1 = DummyEvent(organizer);
Event publicEvent2 = DummyEvent(organizer);
Event privateEvent = DummyEvent(organizer, true);
context.Events.Add(publicEvent1);
context.Events.Add(publicEvent2);
context.Events.Add(privateEvent);
await context.SaveChangesAsync();
publicEventId1 = publicEvent1.Id;
publicEventId2 = publicEvent2.Id;
privateEventId = privateEvent.Id;
johnId = john.Entity.Id;
}
// Act
(ParticipateEventController participateEventController, _) = CreateController(getContext, johnId);
IActionResult response = await participateEventController.GetOverview();
// Assert
Assert.IsType <OkObjectResult>(response);
var okObjectResult = (OkObjectResult)response;
var eventOverview = okObjectResult.Value as EventOverview;
Assert.NotNull(eventOverview);
Assert.Empty(eventOverview.YourEvents);
Assert.Equal(2, eventOverview.PublicEvents.Count);
Assert.Contains(publicEventId1, eventOverview.PublicEvents.Select(e => e.EventId));
Assert.Contains(publicEventId2, eventOverview.PublicEvents.Select(e => e.EventId));
Assert.DoesNotContain(privateEventId, eventOverview.PublicEvents.Select(e => e.EventId));
}
public async Task RequestPasswordReset_GivenNonExistingUser_RequestRejected()
{
GetDatabaseContext getContext = ContextUtilities.CreateInMemoryContext(_output);
// Act
(ResetPasswordController controller, _, _) = CreateController(getContext, null);
IActionResult response = await controller.RequestPasswordReset(new RequestPasswordResetDto { Email = "*****@*****.**" });
// Assert
Assert.IsType <BadRequestObjectResult>(response);
var badRequestResponse = (BadRequestObjectResult)response;
Assert.Equal(RequestStringMessages.NoProfileWithEmailFound, badRequestResponse.Value);
using (IDatabaseContext context = getContext())
{
Assert.Empty(context.PasswordResets);
}
}
public async Task DeleteEvent_GivenEventUserOnlyParticipates_EventNotDeleted(bool isPrivate)
{
GetDatabaseContext getContext = ContextUtilities.CreateInMemoryContext(_output);
int johnDoeId;
int eventId;
// Arrange
using (IDatabaseContext context = getContext())
{
User john = ContextUtilities.CreateJohnDoe();
User richard = ContextUtilities.CreateRichardRoe();
Event @event = DummyEvent(richard, isPrivate);
context.EventParticipations.Add(new EventParticipation {
Event = @event, Participant = john
});
context.EventParticipations.Add(new EventParticipation {
Event = @event, Participant = richard
});
await context.SaveChangesAsync();
johnDoeId = john.Id;
eventId = @event.Id;
}
// Act
(OrganizeEventController controller, _) = CreateController(getContext, johnDoeId);
IActionResult response = await controller.DeleteEvent(eventId);
// Assert
Assert.IsType <BadRequestObjectResult>(response);
var objectResult = (BadRequestObjectResult)response;
Assert.Equal(RequestStringMessages.OrganizerRequired, objectResult.Value);
using (IDatabaseContext context = getContext())
{
Assert.Single(context.Events);
}
}
public async Task Register_GivenCorrectData_UserRegistered()
{
GetDatabaseContext getContext = ContextUtilities.CreateInMemoryContext(_output);
// Arrange
var data = new RegisterDto {
Email = "*****@*****.**", FullName = "New User", Password = "******"
};
var newSessionGuid = Guid.NewGuid();
const string PasswordHash = "P@ssw0rd";
// Act
(UserController controller, Mock <ISessionService> sessionServiceMock, Mock <IPasswordService> passwordServiceMock, _) = CreateController(getContext, null);
sessionServiceMock.Setup(s => s.CreateSessionAsync(It.IsAny <int>(), true)).ReturnsAsync(newSessionGuid);
passwordServiceMock.Setup(s => s.HashPassword(data.Password)).Returns(PasswordHash);
IActionResult response = await controller.Register(data);
// Assert
sessionServiceMock.Verify(s => s.CreateSessionAsync(It.IsAny <int>(), true), Times.Once);
passwordServiceMock.Verify(s => s.HashPassword(data.Password), Times.Once);
Assert.IsType <OkObjectResult>(response);
var objectResult = (OkObjectResult)response;
var session = objectResult.Value as FrontendSession;
using (IDatabaseContext context = getContext())
{
Assert.Single(context.Users);
User loadedUser = context.Users.First();
Assert.Equal(data.FullName, loadedUser.FullName);
Assert.Equal(data.Email, loadedUser.Email);
Assert.Equal(PasswordHash, loadedUser.PasswordHash);
Assert.NotNull(session);
Assert.Equal(loadedUser.Id, session.UserId);
Assert.Equal(loadedUser.Email, session.Email);
Assert.Equal(loadedUser.FullName, session.FullName);
Assert.Equal(newSessionGuid, session.Token);
}
}
public async Task ResetPassword_GivenValidPasswordReset_NewPasswordIsSet()
{
GetDatabaseContext getContext = ContextUtilities.CreateInMemoryContext(_output);
Guid resetToken;
const string NewPassword = "******";
const string NewPasswordHash = "P@ssw0rd";
// Arrange
using (IDatabaseContext context = getContext())
{
User john = ContextUtilities.CreateJohnDoe();
var reset = new PasswordReset {
Requested = DateTime.UtcNow, User = john
};
context.PasswordResets.Add(reset);
await context.SaveChangesAsync();
resetToken = reset.Token;
}
// Act
(ResetPasswordController controller, Mock <IPasswordService> passwordServiceMock, _) = CreateController(getContext, null);
passwordServiceMock.Setup(p => p.HashPassword(NewPassword)).Returns(NewPasswordHash);
IActionResult response = await controller.ResetPassword(new ResetPasswordDto { NewPassword = NewPassword, PasswordResetToken = resetToken });
// Assert
Assert.IsType <OkResult>(response);
using (IDatabaseContext context = getContext())
{
passwordServiceMock.Verify(p => p.HashPassword(NewPassword), Times.Once);
PasswordReset passwordReset = await context.PasswordResets.Include(p => p.User).SingleOrDefaultAsync();
Assert.NotNull(passwordReset);
Assert.True(passwordReset.Used);
Assert.Equal(NewPasswordHash, passwordReset.User.PasswordHash);
}
}
public async Task Authenticate_GivenPasswordWhichNeedsRehash_RehashesPassword()
{
GetDatabaseContext getContext = ContextUtilities.CreateInMemoryContext(_output);
const string NewPasswordHash = "NewPasswordHash";
// Arrange
using (IDatabaseContext context = getContext())
{
EntityEntry <User> userEntry = context.Users.Add(ContextUtilities.CreateJohnDoe());
userEntry.Entity.Email = Email;
userEntry.Entity.PasswordHash = PasswordHash;
await context.SaveChangesAsync();
}
// Act
var passwordServiceMock = new Mock <IPasswordService>();
passwordServiceMock.Setup(p => p.NeedsRehash(PasswordHash)).Returns(true);
passwordServiceMock.Setup(p => p.VerifyPassword(Password, PasswordHash)).Returns(true);
passwordServiceMock.Setup(p => p.HashPassword(Password)).Returns(NewPasswordHash);
var authenticationService = new AuthenticationService(passwordServiceMock.Object, getContext, DummyLogger <AuthenticationService>());
(bool isAuthenticated, _) = await authenticationService.AuthenticateAsync(Email, Password);
// Assert
passwordServiceMock.Verify(p => p.NeedsRehash(PasswordHash), Times.Once);
passwordServiceMock.Verify(p => p.HashPassword(Password), Times.Once);
Assert.True(isAuthenticated);
using (IDatabaseContext context = getContext())
{
User user = context.Users.Single();
Assert.Equal(NewPasswordHash, user.PasswordHash);
}
}
public async Task JoinEvent_GivenNotParticipatingUser_UserCanJoin()
{
GetDatabaseContext getContext = ContextUtilities.CreateInMemoryContext(_output);
int johnDoeId;
int eventId;
// Arrange
using (IDatabaseContext context = getContext())
{
EntityEntry <User> john = context.Users.Add(ContextUtilities.CreateJohnDoe());
Event @event = DummyEvent(ContextUtilities.CreateRichardRoe());
context.Events.Add(@event);
await context.SaveChangesAsync();
johnDoeId = john.Entity.Id;
eventId = @event.Id;
}
// Act
(ParticipateEventController participateEventController, _) = CreateController(getContext, johnDoeId);
IActionResult response = await participateEventController.JoinEvent(new JoinEventDto
{
EventId = eventId
});
// Assert
Assert.IsType <OkResult>(response);
using (IDatabaseContext context = getContext())
{
Event loadedEvent = await context.Events.Include(e => e.EventParticipations).FirstOrDefaultAsync(e => e.Id == eventId);
Assert.NotNull(loadedEvent);
Assert.Contains(johnDoeId, loadedEvent.EventParticipations.Select(e => e.ParticipantId));
}
}
public async Task ConfigureNotifications_GivenParticipatingEvent_NotificationsConfigured()
{
GetDatabaseContext getContext = ContextUtilities.CreateInMemoryContext(_output);
int eventId;
int johnId;
// Arrange
using (IDatabaseContext context = getContext())
{
EntityEntry <User> john = context.Users.Add(ContextUtilities.CreateJohnDoe());
User organizer = ContextUtilities.CreateRichardRoe();
Event @event = DummyEvent(organizer);
context.Events.Add(@event);
context.EventParticipations.Add(new EventParticipation {
Event = @event, Participant = john.Entity, SendLastMinuteChangesEmail = false, SendReminderEmail = false, SendSummaryEmail = false
});
await context.SaveChangesAsync();
eventId = @event.Id;
johnId = john.Entity.Id;
}
// Act
(ParticipateEventController participateEventController, _) = CreateController(getContext, johnId);
IActionResult response = await participateEventController.ConfigureNotifications(new NotificationConfigurationDto { EventId = eventId, SendReminderEmail = true, SendSummaryEmail = true, SendLastMinuteChangesEmail = true });
// Assert
Assert.IsType <OkResult>(response);
using (IDatabaseContext context = getContext())
{
EventParticipation eventParticipation = context.EventParticipations.Single();
Assert.True(eventParticipation.SendSummaryEmail);
Assert.True(eventParticipation.SendLastMinuteChangesEmail);
Assert.True(eventParticipation.SendReminderEmail);
}
}