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);
}
[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 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 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 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 CreateSession_GivenIsActiveFalse_SessionIsNotActivated()
{
(GetDatabaseContext getContext, SessionService sessionService) = SetupSessionService();
int johnDoeId;
// Arrange
using (IDatabaseContext context = getContext())
{
EntityEntry <User> userEntry = context.Users.Add(ContextUtilities.CreateJohnDoe());
await context.SaveChangesAsync();
johnDoeId = userEntry.Entity.Id;
}
// Act
Guid sessionId = await sessionService.CreateSessionAsync(johnDoeId, false);
// Assert
using (IDatabaseContext context = getContext())
{
Session createdSession = await context.Sessions.FindAsync(sessionId);
Assert.NotNull(createdSession);
Assert.InRange(createdSession.Created, DateTime.UtcNow - TimeSpan.FromMinutes(1), DateTime.UtcNow);
Assert.Null(createdSession.ValidUntil);
}
}
public async Task InvalidateSession_GivenInvalidSession_SessionUnchanged()
{
(GetDatabaseContext getContext, SessionService sessionService) = SetupSessionService();
Session invalidUserSession;
// Arrange
using (IDatabaseContext context = getContext())
{
EntityEntry <User> userEntry = context.Users.Add(ContextUtilities.CreateJohnDoe());
invalidUserSession = new Session
{
Created = DateTime.UtcNow - TimeSpan.FromHours(10),
ValidUntil = DateTime.UtcNow - TimeSpan.FromHours(5),
User = userEntry.Entity
};
context.Sessions.Add(invalidUserSession);
await context.SaveChangesAsync();
}
// Act
await sessionService.InvalidateSessionAsync(invalidUserSession.Token);
// Assert
using (IDatabaseContext context = getContext())
{
Session newlyLoadedSession = await context.Sessions.FindAsync(invalidUserSession.Token);
Assert.NotNull(newlyLoadedSession);
Assert.Equal(invalidUserSession.ValidUntil, newlyLoadedSession.ValidUntil);
}
}
public async Task GetSession_GivenExpiredUnusedSession_SessionUnchanged()
{
_configuration.TimeSpans.UpdateValidUntilTimeSpan = TimeSpan.Zero;
(GetDatabaseContext getContext, SessionService sessionService) = SetupSessionService();
Session invalidUserSession;
// Arrange
using (IDatabaseContext context = getContext())
{
EntityEntry <User> userEntry = context.Users.Add(ContextUtilities.CreateJohnDoe());
invalidUserSession = new Session
{
Created = DateTime.UtcNow - _configuration.TimeSpans.UnusedSessionExpirationTimeout,
ValidUntil = null,
User = userEntry.Entity
};
context.Sessions.Add(invalidUserSession);
await context.SaveChangesAsync();
}
// Act
Session loadedSession = await sessionService.GetAndExtendSessionAsync(invalidUserSession.Token);
// Assert
using (IDatabaseContext context = getContext())
{
Assert.Null(loadedSession);
Session newlyLoadedSession = await context.Sessions.FindAsync(invalidUserSession.Token);
Assert.NotNull(newlyLoadedSession);
Assert.Null(newlyLoadedSession.ValidUntil);
}
}
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);
}
private static async Task <Event> CreateTestDataAsync(GetDatabaseContext getContext, DateTime lastReadJohn, DateTime lastReadRichard, Func <User, User, IEnumerable <ChatMessage> > createMessagesFunc)
{
using (IDatabaseContext context = getContext())
{
User john = ContextUtilities.CreateJohnDoe();
User richard = ContextUtilities.CreateRichardRoe();
var @event = new Event
{
Title = "Chatty event",
Description = "An event with an active chat",
MeetingPlace = "Somewhere",
Organizer = john,
ReminderTimeWindowInHours = 42,
SummaryTimeWindowInHours = 24,
EventParticipations = new List <EventParticipation>
{
new EventParticipation {
Participant = john, LastReadMessageSentDate = lastReadJohn
},
new EventParticipation {
Participant = richard, LastReadMessageSentDate = lastReadRichard
}
},
ChatMessages = createMessagesFunc(john, richard).ToList()
};
context.Events.Add(@event);
await context.SaveChangesAsync();
return(@event);
}
}
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 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 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 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);
}
public async Task GetSession_GivenValidSessionWhichWasRecentlyUpdated_SessionUnchanged()
{
_configuration.TimeSpans.UpdateValidUntilTimeSpan = TimeSpan.FromHours(1);
(GetDatabaseContext getContext, SessionService sessionService) = SetupSessionService();
Guid sessionToken;
DateTime originalSessionValidUntil = DateTime.UtcNow + _configuration.TimeSpans.InactiveSessionTimeout;
// Arrange
using (IDatabaseContext context = getContext())
{
EntityEntry <User> userEntry = context.Users.Add(ContextUtilities.CreateJohnDoe());
var validUserSession = new Session
{
Created = DateTime.UtcNow,
ValidUntil = originalSessionValidUntil,
User = userEntry.Entity
};
context.Sessions.Add(validUserSession);
await context.SaveChangesAsync();
sessionToken = validUserSession.Token;
}
// Act
await Task.Delay(1);
Session loadedSession = await sessionService.GetAndExtendSessionAsync(sessionToken);
// Assert
Assert.NotNull(loadedSession);
Assert.Equal(originalSessionValidUntil, loadedSession.ValidUntil);
}
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 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 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 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 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 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);
}
}
private static async Task <Appointment> CreateTestDataAsync(GetDatabaseContext getContext, DateTime startTime)
{
using (IDatabaseContext context = getContext())
{
User john = ContextUtilities.CreateJohnDoe();
User richard = ContextUtilities.CreateRichardRoe();
var @event = new Event
{
Title = "Upcoming event",
Description = "An event with upcoming appointments",
MeetingPlace = "Somewhere",
Organizer = john,
ReminderTimeWindowInHours = ReminderTimeWindowInHours,
SummaryTimeWindowInHours = SummaryTimeWindowInHours,
EventParticipations = new List <EventParticipation>
{
new EventParticipation {
Participant = john
},
new EventParticipation {
Participant = richard
}
}
};
var appointment = new Appointment
{
Event = @event,
AppointmentParticipations = new List <AppointmentParticipation>
{
new AppointmentParticipation {
Participant = john
},
new AppointmentParticipation {
Participant = richard
}
},
StartTime = startTime
};
context.Appointments.Add(appointment);
await context.SaveChangesAsync();
return(appointment);
}
}
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 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 GetSession_GivenValidSession_ExtendsSession()
{
_configuration.TimeSpans.UpdateValidUntilTimeSpan = TimeSpan.Zero;
(GetDatabaseContext getContext, SessionService sessionService) = SetupSessionService();
Guid sessionToken;
// Arrange
using (IDatabaseContext context = getContext())
{
EntityEntry <User> userEntry = context.Users.Add(ContextUtilities.CreateJohnDoe());
var validUserSession = new Session
{
Created = DateTime.UtcNow,
ValidUntil = null,
User = userEntry.Entity
};
context.Sessions.Add(validUserSession);
await context.SaveChangesAsync();
sessionToken = validUserSession.Token;
}
// Act
Session loadedSession = await sessionService.GetAndExtendSessionAsync(sessionToken);
// Assert
Assert.NotNull(loadedSession);
Assert.True(loadedSession.ValidUntil >= DateTime.UtcNow);
DateTime firstValidUntil = loadedSession.ValidUntil.Value;
await Task.Delay(1);
loadedSession = await sessionService.GetAndExtendSessionAsync(loadedSession.Token);
Assert.NotNull(loadedSession);
Assert.True(firstValidUntil < loadedSession.ValidUntil);
}
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);
}
}