public static async Task Returns_previously_saved_reservations()
{
var activeDates = new[] { 15.February(2021), 16.February(2021), 18.February(2021) };
var reservations = new[]
{
new Reservation("User1", 15.February(2021)),
new Reservation("User2", 15.February(2021)),
new Reservation("User3", 15.February(2021)),
};
var controller = new ReservationsController(
CreateConfigurationRepository.WithDefaultConfiguration(),
CreateDateCalculator.WithActiveDates(activeDates),
CreateReservationRepository.WithReservations(activeDates, reservations),
CreateUserRepository.WithUsers(DefaultUsers));
var result = await controller.GetAsync();
var resultValue = GetResultValue <ReservationsResponse>(result);
var data = GetDailyData(resultValue.Reservations, 15.February(2021));
Assert.Equal(new[] { "User1", "User2", "User3" }, data.UserIds);
}
public static async Task Uses_newly_updated_requests_from_previous_days()
{
var mockAllocationCreator = new Mock <IAllocationCreator>(MockBehavior.Strict);
foreach (var date in AllocationDates)
{
var expectedCumulativeRequests = InitialRequests.Where(r => r.Date < ShortLeadTimeDates.First())
.Concat(NewlyAllocatedRequests.Where(r => r.Date < date))
.Concat(InitialRequests.Where(r => r.Date >= date))
.ToArray();
mockAllocationCreator
.Setup(a => a.Create(
date,
It.Is <IReadOnlyCollection <Request> >(r =>
r.Count == expectedCumulativeRequests.Length && expectedCumulativeRequests.All(r.Contains)),
It.IsAny <IReadOnlyCollection <Reservation> >(),
It.IsAny <IReadOnlyCollection <User> >(),
It.IsAny <Configuration>(),
It.IsAny <LeadTimeType>()))
.Returns(NewlyAllocatedRequests.Where(r => r.Date == date).ToArray());
}
var requestUpdater = new RequestUpdater(
mockAllocationCreator.Object,
Mock.Of <IConfigurationRepository>(),
CreateMockDateCalculator().Object,
CreateMockRequestRepository().Object,
Mock.Of <IReservationRepository>(),
CreateUserRepository.WithUsers(DefaultUsers));
await requestUpdater.Update();
mockAllocationCreator.VerifyAll();
}
public static async Task Returns_newly_updated_requests()
{
var mockAllocationCreator = new Mock <IAllocationCreator>(MockBehavior.Strict);
foreach (var date in AllocationDates)
{
mockAllocationCreator
.Setup(a => a.Create(
date,
It.IsAny <IReadOnlyCollection <Request> >(),
It.IsAny <IReadOnlyCollection <Reservation> >(),
It.IsAny <IReadOnlyCollection <User> >(),
It.IsAny <Configuration>(),
It.IsAny <LeadTimeType>()))
.Returns(NewlyAllocatedRequests.Where(r => r.Date == date).ToArray());
}
var requestUpdater = new RequestUpdater(
mockAllocationCreator.Object,
Mock.Of <IConfigurationRepository>(),
CreateMockDateCalculator().Object,
CreateMockRequestRepository().Object,
Mock.Of <IReservationRepository>(),
CreateUserRepository.WithUsers(DefaultUsers));
var result = await requestUpdater.Update();
Assert.NotNull(result);
Assert.Equal(NewlyAllocatedRequests.Count, result.Count);
Assert.All(NewlyAllocatedRequests, r => Assert.Contains(r, result));
}
public static async Task Filters_registration_numbers_using_search_string()
{
var users = new[]
{
CreateUser.With(
userId: "User1",
firstName: "Mariam",
lastName: "Brayn",
alternativeRegistrationNumber: "A12XYZ"),
CreateUser.With(
userId: "User2",
firstName: "Meris",
lastName: "Wigsell",
registrationNumber: "Z999ABC")
};
var controller = new RegistrationNumbersController(CreateUserRepository.WithUsers(users));
var result = await controller.GetAsync("A12XYZ");
var resultValue = GetResultValue <RegistrationNumbersResponse>(result);
Assert.NotNull(resultValue.RegistrationNumbers);
var actualRegistrationNumbers = resultValue.RegistrationNumbers.ToArray();
Assert.Single(actualRegistrationNumbers);
CheckResult(actualRegistrationNumbers[0], "A12XYZ", "Mariam Brayn");
}
public static async Task Normalizes_registration_numbers(string savedRegistrationNumber, string searchTerm, string expectedResult)
{
var users = new[]
{
CreateUser.With(
userId: "User1",
firstName: "Mariam",
lastName: "Brayn",
registrationNumber: savedRegistrationNumber)
};
var controller = new RegistrationNumbersController(CreateUserRepository.WithUsers(users));
var result = await controller.GetAsync(searchTerm);
var resultValue = GetResultValue <RegistrationNumbersResponse>(result);
Assert.NotNull(resultValue.RegistrationNumbers);
var actualRegistrationNumbers = resultValue.RegistrationNumbers.ToArray();
Assert.Single(actualRegistrationNumbers);
CheckResult(actualRegistrationNumbers[0], expectedResult, "Mariam Brayn");
}
public static async Task Returns_sorted_list_of_users()
{
var users = new[]
{
CreateUser.With(userId: "User1", firstName: "Silvester", lastName: "Probet"),
CreateUser.With(userId: "User2", firstName: "Kendricks", lastName: "Hawke"),
CreateUser.With(userId: "User3", firstName: "Rupert", lastName: "Trollope"),
};
var controller = new UsersListController(CreateUserRepository.WithUsers(users));
var result = await controller.GetAsync();
var resultValue = GetResultValue <UsersListResponse>(result);
Assert.NotNull(resultValue.Users);
var actualUsers = resultValue.Users.ToArray();
Assert.Equal(3, actualUsers.Length);
Assert.Equal("User2", actualUsers[0].UserId);
Assert.Equal("Kendricks Hawke", actualUsers[0].Name);
Assert.Equal("User1", actualUsers[1].UserId);
Assert.Equal("Silvester Probet", actualUsers[1].Name);
Assert.Equal("User3", actualUsers[2].UserId);
Assert.Equal("Rupert Trollope", actualUsers[2].Name);
}
public static async Task Returns_sorted_list_of_users()
{
var activeDates = new[] { 15.February(2021) };
var controller = new ReservationsController(
CreateConfigurationRepository.WithDefaultConfiguration(),
CreateDateCalculator.WithActiveDates(activeDates),
CreateReservationRepository.WithReservations(activeDates, new List <Reservation>()),
CreateUserRepository.WithUsers(DefaultUsers));
var result = await controller.GetAsync();
var resultValue = GetResultValue <ReservationsResponse>(result);
Assert.NotNull(resultValue.Users);
var actualUsers = resultValue.Users.ToArray();
Assert.Equal(3, actualUsers.Length);
Assert.Equal("User2", actualUsers[0].UserId);
Assert.Equal("Kendricks Hawke", actualUsers[0].Name);
Assert.Equal("User1", actualUsers[1].UserId);
Assert.Equal("Silvester Probet", actualUsers[1].Name);
Assert.Equal("User3", actualUsers[2].UserId);
Assert.Equal("Rupert Trollope", actualUsers[2].Name);
}
public static async Task Adds_recalculation_trigger_when_saving_requests()
{
var activeDates = new[] { 2.February(2021) };
var mockRequestRepository =
CreateRequestRepository.MockWithRequests(UserId, activeDates, new List <Request>());
mockRequestRepository
.Setup(r => r.SaveRequests(It.IsAny <IReadOnlyCollection <Request> >(), It.IsAny <IReadOnlyCollection <User> >()))
.Returns(Task.CompletedTask);
var mockTriggerRepository = new Mock <ITriggerRepository>();
var patchRequest = new RequestsPatchRequest(new List <RequestsPatchRequestDailyData>());
var controller = new RequestsController(
CreateDateCalculator.WithActiveDates(activeDates),
mockRequestRepository.Object,
mockTriggerRepository.Object,
CreateUserRepository.WithUsers(DefaultUsers))
{
ControllerContext = CreateControllerContext.WithUsername(UserId)
};
await controller.PatchAsync(patchRequest);
mockTriggerRepository.Verify(r => r.AddTrigger(), Times.Once);
}
public static async Task Ignores_other_request_statuses(RequestStatus requestStatus)
{
var nextWorkingDate = 23.December(2020);
var mockDateCalculator = new Mock <IDateCalculator>(MockBehavior.Strict);
mockDateCalculator.Setup(c => c.GetNextWorkingDate()).Returns(nextWorkingDate);
var requests = new[]
{
new Request("user1", nextWorkingDate, requestStatus),
new Request("user2", nextWorkingDate, requestStatus)
};
var mockRequestRepository = new Mock <IRequestRepository>(MockBehavior.Strict);
mockRequestRepository
.Setup(r => r.GetRequests(nextWorkingDate, nextWorkingDate))
.ReturnsAsync(requests);
mockRequestRepository
.Setup(r => r.SaveRequests(It.IsAny <IReadOnlyCollection <Request> >(), It.IsAny <IReadOnlyCollection <User> >()))
.Returns(Task.CompletedTask);
var softInterruptionUpdater = new SoftInterruptionUpdater(
mockDateCalculator.Object,
mockRequestRepository.Object,
CreateUserRepository.WithUsers(DefaultUsers));
await softInterruptionUpdater.Run();
mockRequestRepository.Verify(r => r.GetRequests(nextWorkingDate, nextWorkingDate), Times.Once);
mockRequestRepository.Verify(
r => r.SaveRequests(It.Is <IReadOnlyCollection <Request> >(actual => actual.Count == 0), DefaultUsers),
Times.Once);
}
public static async Task Returns_updated_requests_after_saving()
{
var activeDates = new[] { 2.February(2021), 3.February(2021) };
var returnedRequests = new[] { new Request(UserId, 2.February(2021), RequestStatus.Pending) };
var mockRequestRepository =
CreateRequestRepository.MockWithRequests(UserId, activeDates, returnedRequests);
mockRequestRepository
.Setup(r => r.SaveRequests(It.IsAny <IReadOnlyCollection <Request> >(), It.IsAny <IReadOnlyCollection <User> >()))
.Returns(Task.CompletedTask);
var patchRequest =
new RequestsPatchRequest(new[] { new RequestsPatchRequestDailyData(2.February(2021), true) });
var controller = new RequestsController(
CreateDateCalculator.WithActiveDates(activeDates),
mockRequestRepository.Object,
Mock.Of <ITriggerRepository>(),
CreateUserRepository.WithUsers(DefaultUsers))
{
ControllerContext = CreateControllerContext.WithUsername(UserId)
};
var result = await controller.PatchAsync(patchRequest);
var resultValue = GetResultValue <RequestsResponse>(result);
var day1data = GetDailyData(resultValue.Requests, 2.February(2021));
var day2data = GetDailyData(resultValue.Requests, 3.February(2021));
Assert.True(day1data.Requested);
Assert.False(day2data.Requested);
}
public static async Task Does_not_update_requests_outside_active_date_range()
{
var activeDates = new[] { 2.February(2021), 3.February(2021) };
var mockRequestRepository =
CreateRequestRepository.MockWithRequests(UserId, activeDates, new List <Request>());
mockRequestRepository
.Setup(r => r.SaveRequests(It.IsAny <IReadOnlyCollection <Request> >(), It.IsAny <IReadOnlyCollection <User> >()))
.Returns(Task.CompletedTask);
var patchRequest = new RequestsPatchRequest(new[]
{
new RequestsPatchRequestDailyData(1.February(2021), true),
new RequestsPatchRequestDailyData(4.February(2021), true)
});
var controller = new RequestsController(
CreateDateCalculator.WithActiveDates(activeDates),
mockRequestRepository.Object,
Mock.Of <ITriggerRepository>(),
CreateUserRepository.WithUsers(DefaultUsers))
{
ControllerContext = CreateControllerContext.WithUsername(UserId)
};
await controller.PatchAsync(patchRequest);
CheckSavedRequests(mockRequestRepository, new List <Request>(), DefaultUsers);
}
public static async Task Returns_stay_interrupted_status_when_no_user_requests_exist()
{
var activeDates = new[] { 12.July(2021) };
var dateCalculator = CreateDateCalculator.WithActiveDates(activeDates);
var requests = new[]
{
new Request("user2", 12.July(2021), RequestStatus.SoftInterrupted),
};
var users = new[]
{
CreateUser.With(userId: "user1", firstName: "Cathie", lastName: "Phoenix"),
};
var controller = new DailyDetailsController(
dateCalculator,
CreateRequestRepository.WithRequests(activeDates, requests),
Mock.Of <ITriggerRepository>(),
CreateUserRepository.WithUsers(users))
{
ControllerContext = CreateControllerContext.WithUsername("user1")
};
var result = await controller.GetAsync();
var resultValue = GetResultValue <DailyDetailsResponse>(result);
var actual = GetDailyData(resultValue.Details, 12.July(2021)).StayInterruptedStatus;
Assert.False(actual.IsAllowed);
Assert.False(actual.IsSet);
}
public static async Task Does_not_save_reservations_outside_active_date_range()
{
var activeDates = new[] { 2.February(2021), 3.February(2021) };
var mockReservationRepository =
CreateReservationRepository.MockWithReservations(activeDates, new List <Reservation>());
mockReservationRepository
.Setup(r => r.SaveReservations(
It.IsAny <IReadOnlyCollection <Reservation> >(),
It.IsAny <IReadOnlyCollection <User> >()))
.Returns(Task.CompletedTask);
var patchRequest = new ReservationsPatchRequest(new[]
{
new ReservationsPatchRequestDailyData(1.February(2021), new List <string> {
"User1", "User2"
}),
new ReservationsPatchRequestDailyData(4.February(2021), new List <string> {
"User1", "User2"
}),
});
var controller = new ReservationsController(
CreateConfigurationRepository.WithDefaultConfiguration(),
CreateDateCalculator.WithActiveDates(activeDates),
mockReservationRepository.Object,
CreateUserRepository.WithUsers(DefaultUsers));
await controller.PatchAsync(patchRequest);
CheckSavedReservations(mockReservationRepository, new List <Reservation>());
}
public static async Task Updates_requests_for_long_lead_time_and_short_lead_time()
{
var mockAllocationCreator = new Mock <IAllocationCreator>(MockBehavior.Strict);
foreach (var date in AllocationDates)
{
var expectedLeadTimeType = LongLeadTimeDates.Contains(date) ? LeadTimeType.Long : LeadTimeType.Short;
mockAllocationCreator
.Setup(a => a.Create(
date,
It.IsAny <IReadOnlyCollection <Request> >(),
It.IsAny <IReadOnlyCollection <Reservation> >(),
It.IsAny <IReadOnlyList <User> >(),
It.IsAny <Configuration>(),
expectedLeadTimeType))
.Returns(NewlyAllocatedRequests.Where(r => r.Date == date).ToArray());
}
var mockRequestRepository = CreateMockRequestRepository();
var requestUpdater = new RequestUpdater(
mockAllocationCreator.Object,
Mock.Of <IConfigurationRepository>(),
CreateMockDateCalculator().Object,
mockRequestRepository.Object,
Mock.Of <IReservationRepository>(),
CreateUserRepository.WithUsers(DefaultUsers));
await requestUpdater.Update();
mockRequestRepository.VerifyAll();
}
public static async Task Returns_updated_daily_details_when_updating_interruption_status(
RequestStatus initialRequestStatus,
RequestStatus updatedRequestStatus,
bool value)
{
var activeDates = new[] { 28.June(2021), 29.June(2021) };
var dateCalculator = CreateDateCalculator.WithActiveDates(activeDates);
var initialRequest = new Request("user1", 28.June(2021), initialRequestStatus);
var updatedRequests = new[]
{
new Request("user1", 28.June(2021), updatedRequestStatus),
new Request("user1", 29.June(2021), RequestStatus.Interrupted),
};
var mockRequestRepository =
CreateRequestRepository.MockWithRequests("user1", activeDates, new[] { initialRequest });
mockRequestRepository
.Setup(r => r.GetRequests("user1", 28.June(2021), 28.June(2021)))
.ReturnsAsync(new[] { initialRequest });
mockRequestRepository
.Setup(r => r.SaveRequests(It.IsAny <IReadOnlyCollection <Request> >(), It.IsAny <IReadOnlyCollection <User> >()))
.Returns(Task.CompletedTask);
mockRequestRepository
.Setup(r => r.GetRequests(28.June(2021), 29.June(2021)))
.ReturnsAsync(updatedRequests);
var users = new[]
{
CreateUser.With(userId: "user1", firstName: "Cathie", lastName: "Phoenix"),
};
var controller = new DailyDetailsController(
dateCalculator,
mockRequestRepository.Object,
Mock.Of <ITriggerRepository>(),
CreateUserRepository.WithUsers(users))
{
ControllerContext = CreateControllerContext.WithUsername("user1")
};
var result = await controller.PatchAsync(
new StayInterruptedPatchRequest(28.June(2021), value));
var resultValue = GetResultValue <DailyDetailsResponse>(result);
var actual = GetDailyData(resultValue.Details, 28.June(2021)).StayInterruptedStatus;
Assert.True(actual.IsAllowed);
Assert.Equal(value, actual.IsSet);
}
public static async Task Updates_interruption_status(
RequestStatus initialRequestStatus,
bool acceptInterruption,
RequestStatus expectedRequestStatus)
{
var activeDates = new[] { 12.July(2021) };
var dateCalculator = CreateDateCalculator.WithActiveDates(activeDates);
var requestDate = activeDates.Single();
var existingRequests = new[] { new Request("user1", requestDate, initialRequestStatus) };
var mockRequestRepository = CreateRequestRepository.MockWithRequests("user1", activeDates, existingRequests);
mockRequestRepository
.Setup(r => r.SaveRequests(It.IsAny <IReadOnlyCollection <Request> >(), It.IsAny <IReadOnlyCollection <User> >()))
.Returns(Task.CompletedTask);
mockRequestRepository
.Setup(r => r.GetRequests(It.IsAny <LocalDate>(), It.IsAny <LocalDate>()))
.ReturnsAsync(new List <Request>());
var users = new[]
{
CreateUser.With(userId: "user1", firstName: "Cathie", lastName: "Phoenix"),
};
var controller = new DailyDetailsController(
dateCalculator,
mockRequestRepository.Object,
Mock.Of <ITriggerRepository>(),
CreateUserRepository.WithUsers(users))
{
ControllerContext = CreateControllerContext.WithUsername("user1")
};
await controller.PatchAsync(
new StayInterruptedPatchRequest(requestDate, acceptInterruption));
var expectedRequests = new[] { new Request("user1", requestDate, expectedRequestStatus) };
mockRequestRepository.Verify(r => r.SaveRequests(
It.Is <IReadOnlyCollection <Request> >(actual => CheckRequests(expectedRequests, actual.ToList())),
users),
Times.Once);
}
public static async Task Highlights_active_user()
{
var activeDates = new[] { 16.July(2021), 17.July(2021), 18.July(2021) };
var dateCalculator = CreateDateCalculator.WithActiveDates(activeDates);
var users = new[]
{
CreateUser.With(userId: "user1", firstName: "Cathie", lastName: "Phoenix"),
CreateUser.With(userId: "user2", firstName: "Hynda", lastName: "Lindback"),
};
var requests = new[]
{
new Request("user1", 16.July(2021), RequestStatus.Allocated),
new Request("user2", 16.July(2021), RequestStatus.SoftInterrupted),
new Request("user1", 17.July(2021), RequestStatus.Interrupted),
new Request("user2", 17.July(2021), RequestStatus.Allocated),
new Request("user2", 18.July(2021), RequestStatus.Pending),
};
var controller = new DailyDetailsController(
dateCalculator,
CreateRequestRepository.WithRequests(activeDates, requests),
Mock.Of <ITriggerRepository>(),
CreateUserRepository.WithUsers(users))
{
ControllerContext = CreateControllerContext.WithUsername("user2")
};
var result = await controller.GetAsync();
var resultValue = GetResultValue <DailyDetailsResponse>(result);
var day1Data = GetDailyData(resultValue.Details, 16.July(2021));
var day2Data = GetDailyData(resultValue.Details, 17.July(2021));
var day3Data = GetDailyData(resultValue.Details, 18.July(2021));
Assert.False(day1Data.AllocatedUsers.Single().IsHighlighted);
Assert.True(day1Data.InterruptedUsers.Single().IsHighlighted);
Assert.True(day2Data.AllocatedUsers.Single().IsHighlighted);
Assert.False(day2Data.InterruptedUsers.Single().IsHighlighted);
Assert.True(day3Data.PendingUsers.Single().IsHighlighted);
}
public static async Task Groups_allocated_and_interrupted_users_sorted_by_last_name()
{
var activeDates = new[] { 12.July(2021) };
var dateCalculator = CreateDateCalculator.WithActiveDates(activeDates);
var users = new[]
{
CreateUser.With(userId: "user1", firstName: "Cathie", lastName: "Phoenix"),
CreateUser.With(userId: "user2", firstName: "Hynda", lastName: "Lindback"),
CreateUser.With(userId: "user3", firstName: "Shannen", lastName: "Muddicliffe"),
CreateUser.With(userId: "user4", firstName: "Marco", lastName: "Call"),
CreateUser.With(userId: "user5", firstName: "Eugenio", lastName: "Veazey"),
CreateUser.With(userId: "user6", firstName: "Evangelin", lastName: "Calway"),
};
var requests = new[]
{
new Request("user1", 12.July(2021), RequestStatus.Allocated),
new Request("user2", 12.July(2021), RequestStatus.Allocated),
new Request("user3", 12.July(2021), RequestStatus.Interrupted),
new Request("user4", 12.July(2021), RequestStatus.SoftInterrupted),
new Request("user5", 12.July(2021), RequestStatus.Pending),
new Request("user6", 12.July(2021), RequestStatus.Pending),
};
var controller = new DailyDetailsController(
dateCalculator,
CreateRequestRepository.WithRequests(activeDates, requests),
Mock.Of <ITriggerRepository>(),
CreateUserRepository.WithUsers(users))
{
ControllerContext = CreateControllerContext.WithUsername("user1")
};
var result = await controller.GetAsync();
var resultValue = GetResultValue <DailyDetailsResponse>(result);
var data = GetDailyData(resultValue.Details, 12.July(2021));
Assert.Equal(new[] { "Hynda Lindback", "Cathie Phoenix" }, data.AllocatedUsers.Select(u => u.Name));
Assert.Equal(new[] { "Marco Call", "Shannen Muddicliffe" }, data.InterruptedUsers.Select(u => u.Name));
Assert.Equal(new[] { "Evangelin Calway", "Eugenio Veazey" }, data.PendingUsers.Select(u => u.Name));
}
public static async Task Returns_short_lead_time_spaces_count()
{
var configuration = CreateConfiguration.With(shortLeadTimeSpaces: 2);
var activeDates = new[] { 15.February(2021) };
var controller = new ReservationsController(
CreateConfigurationRepository.WithConfiguration(configuration),
CreateDateCalculator.WithActiveDates(activeDates),
CreateReservationRepository.WithReservations(activeDates, new List <Reservation>()),
CreateUserRepository.WithUsers(new List <User>()));
var result = await controller.GetAsync();
var resultValue = GetResultValue <ReservationsResponse>(result);
Assert.Equal(2, resultValue.ShortLeadTimeSpaces);
}
public static async Task Updates_unallocated_requests_to_soft_interrupted()
{
var nextWorkingDate = 23.December(2020);
var mockDateCalculator = new Mock <IDateCalculator>(MockBehavior.Strict);
mockDateCalculator.Setup(c => c.GetNextWorkingDate()).Returns(nextWorkingDate);
var requests = new[]
{
new Request("user1", nextWorkingDate, RequestStatus.Interrupted),
new Request("user2", nextWorkingDate, RequestStatus.Interrupted)
};
var mockRequestRepository = new Mock <IRequestRepository>(MockBehavior.Strict);
mockRequestRepository
.Setup(r => r.GetRequests(nextWorkingDate, nextWorkingDate))
.ReturnsAsync(requests);
mockRequestRepository
.Setup(r => r.SaveRequests(It.IsAny <IReadOnlyCollection <Request> >(), It.IsAny <IReadOnlyCollection <User> >()))
.Returns(Task.CompletedTask);
var softInterruptionUpdater = new SoftInterruptionUpdater(
mockDateCalculator.Object,
mockRequestRepository.Object,
CreateUserRepository.WithUsers(DefaultUsers));
await softInterruptionUpdater.Run();
var expectedRequests = new[]
{
new Request("user1", nextWorkingDate, RequestStatus.SoftInterrupted),
new Request("user2", nextWorkingDate, RequestStatus.SoftInterrupted)
};
mockRequestRepository.Verify(r => r.GetRequests(nextWorkingDate, nextWorkingDate), Times.Once);
mockRequestRepository.Verify(r => r.SaveRequests(
It.Is <IReadOnlyCollection <Request> >(actual => CheckRequests(expectedRequests, actual.ToList())),
DefaultUsers),
Times.Once);
}
public static async Task Returns_updated_reservations_after_saving()
{
var activeDates = new[] { 2.February(2021), 3.February(2021) };
var returnedReservations = new[]
{
new Reservation("User1", 2.February(2021)),
new Reservation("User2", 2.February(2021)),
new Reservation("User2", 3.February(2021)),
new Reservation("User3", 3.February(2021)),
};
var mockReservationRepository =
CreateReservationRepository.MockWithReservations(activeDates, returnedReservations);
mockReservationRepository
.Setup(r => r.SaveReservations(
It.IsAny <IReadOnlyCollection <Reservation> >(),
It.IsAny <IReadOnlyCollection <User> >()))
.Returns(Task.CompletedTask);
var patchRequest = new ReservationsPatchRequest(new[]
{
new ReservationsPatchRequestDailyData(2.February(2021), new[] { "User1", "User2" })
});
var controller = new ReservationsController(
CreateConfigurationRepository.WithDefaultConfiguration(),
CreateDateCalculator.WithActiveDates(activeDates),
mockReservationRepository.Object,
CreateUserRepository.WithUsers(DefaultUsers));
var result = await controller.PatchAsync(patchRequest);
var resultValue = GetResultValue <ReservationsResponse>(result);
var day1Data = GetDailyData(resultValue.Reservations, 2.February(2021));
var day2Data = GetDailyData(resultValue.Reservations, 3.February(2021));
Assert.Equal(new[] { "User1", "User2" }, day1Data.UserIds);
Assert.Equal(new[] { "User2", "User3" }, day2Data.UserIds);
}
public static async Task Returns_empty_list_when_search_string_is_empty()
{
var users = new[]
{
CreateUser.With(
userId: "User1",
firstName: "Mariam",
lastName: "Brayn",
alternativeRegistrationNumber: "A12XYZ")
};
var controller = new RegistrationNumbersController(CreateUserRepository.WithUsers(users));
var result = await controller.GetAsync(string.Empty);
var resultValue = GetResultValue <RegistrationNumbersResponse>(result);
Assert.NotNull(resultValue.RegistrationNumbers);
Assert.Empty(resultValue.RegistrationNumbers);
}
public static async Task Returns_empty_reservations_object_when_no_reservations_exist()
{
var activeDates = new[] { 15.February(2021) };
var controller = new ReservationsController(
CreateConfigurationRepository.WithDefaultConfiguration(),
CreateDateCalculator.WithActiveDates(activeDates),
CreateReservationRepository.WithReservations(activeDates, new List <Reservation>()),
CreateUserRepository.WithUsers(new List <User>()));
var result = await controller.GetAsync();
var resultValue = GetResultValue <ReservationsResponse>(result);
var data = GetDailyData(resultValue.Reservations, 15.February(2021));
Assert.NotNull(data.UserIds);
Assert.Empty(data.UserIds);
}
public static async Task Returns_empty_object_when_no_requests_exist()
{
var activeDates = new[] { 15.February(2021) };
var controller = new OverviewController(
CreateDateCalculator.WithActiveDates(activeDates),
CreateRequestRepository.WithRequests(activeDates, new List <Request>()),
CreateUserRepository.WithUsers(new List <User>()))
{
ControllerContext = CreateControllerContext.WithUsername("user1")
};
var result = await controller.GetAsync();
var resultValue = GetResultValue <OverviewResponse>(result);
var data = GetDailyData(resultValue.Overview, 15.February(2021));
Assert.Empty(data.AllocatedUsers);
Assert.Empty(data.InterruptedUsers);
}
public static async Task Returns_details_data_for_each_active_date()
{
var activeDates = new[] { 12.July(2021), 13.July(2021), 16.July(2021) };
var dateCalculator = CreateDateCalculator.WithActiveDates(activeDates);
var controller = new DailyDetailsController(
dateCalculator,
CreateRequestRepository.WithRequests(activeDates, new List <Request>()),
Mock.Of <ITriggerRepository>(),
CreateUserRepository.WithUsers(new List <User>()))
{
ControllerContext = CreateControllerContext.WithUsername("user1")
};
var result = await controller.GetAsync();
var resultValue = GetResultValue <DailyDetailsResponse>(result);
Assert.Equal(activeDates, resultValue.Details.Select(d => d.LocalDate));
}
public static async Task Ignores_cancelled_requests()
{
var activeDates = new[] { 16.July(2021), 17.July(2021) };
var dateCalculator = CreateDateCalculator.WithActiveDates(activeDates);
var users = new[]
{
CreateUser.With(userId: "user1", firstName: "Cathie", lastName: "Phoenix"),
CreateUser.With(userId: "user2", firstName: "Hynda", lastName: "Lindback"),
CreateUser.With(userId: "user3", firstName: "Shannen", lastName: "Muddicliffe"),
};
var requests = new[]
{
new Request("user1", 16.July(2021), RequestStatus.Cancelled),
new Request("user2", 16.July(2021), RequestStatus.Cancelled),
new Request("user3", 17.July(2021), RequestStatus.Cancelled),
};
var controller = new DailyDetailsController(
dateCalculator,
CreateRequestRepository.WithRequests(activeDates, requests),
Mock.Of <ITriggerRepository>(),
CreateUserRepository.WithUsers(users))
{
ControllerContext = CreateControllerContext.WithUsername("user1")
};
var result = await controller.GetAsync();
var resultValue = GetResultValue <DailyDetailsResponse>(result);
var day1Data = GetDailyData(resultValue.Details, 16.July(2021));
var day2Data = GetDailyData(resultValue.Details, 17.July(2021));
Assert.Empty(day1Data.AllocatedUsers);
Assert.Empty(day1Data.InterruptedUsers);
Assert.Empty(day2Data.PendingUsers);
}
public static async Task Updates_requests_with_last_given_value_for_each_date()
{
var activeDates = new[] { 2.February(2021), 3.February(2021) };
var mockRequestRepository =
CreateRequestRepository.MockWithRequests(UserId, activeDates, new List <Request>());
mockRequestRepository
.Setup(r => r.SaveRequests(It.IsAny <IReadOnlyCollection <Request> >(), It.IsAny <IReadOnlyCollection <User> >()))
.Returns(Task.CompletedTask);
var patchRequest = new RequestsPatchRequest(new[]
{
new RequestsPatchRequestDailyData(2.February(2021), true),
new RequestsPatchRequestDailyData(2.February(2021), false),
new RequestsPatchRequestDailyData(2.February(2021), true),
new RequestsPatchRequestDailyData(3.February(2021), false),
new RequestsPatchRequestDailyData(3.February(2021), true),
new RequestsPatchRequestDailyData(3.February(2021), false),
});
var controller = new RequestsController(
CreateDateCalculator.WithActiveDates(activeDates),
mockRequestRepository.Object,
Mock.Of <ITriggerRepository>(),
CreateUserRepository.WithUsers(DefaultUsers))
{
ControllerContext = CreateControllerContext.WithUsername(UserId)
};
await controller.PatchAsync(patchRequest);
var expectedSavedRequests = new[]
{
new Request(UserId, 2.February(2021), RequestStatus.Pending),
new Request(UserId, 3.February(2021), RequestStatus.Cancelled),
};
CheckSavedRequests(mockRequestRepository, expectedSavedRequests, DefaultUsers);
}
public static async Task Returns_overview_data_for_each_active_date()
{
var activeDates = new[] { 15.February(2021), 16.February(2021), 18.February(2021) };
var controller = new OverviewController(
CreateDateCalculator.WithActiveDates(activeDates),
CreateRequestRepository.WithRequests(activeDates, new List <Request>()),
CreateUserRepository.WithUsers(new List <User>()))
{
ControllerContext = CreateControllerContext.WithUsername("user1")
};
var result = await controller.GetAsync();
var resultValue = GetResultValue <OverviewResponse>(result);
var visibleDays = GetVisibleDays(resultValue.Overview);
Assert.Equal(activeDates, visibleDays.Select(d => d.LocalDate));
Assert.All(visibleDays, d => Assert.NotNull(d.Data));
}
public static async Task Highlights_active_user()
{
var activeDates = new[] { 15.February(2021), 16.February(2021) };
var users = new[]
{
CreateUser.With(userId: "user1", firstName: "Cathie", lastName: "Phoenix"),
CreateUser.With(userId: "user2", firstName: "Hynda", lastName: "Lindback"),
};
var requests = new[]
{
new Request("user1", 15.February(2021), RequestStatus.Allocated),
new Request("user2", 15.February(2021), RequestStatus.SoftInterrupted),
new Request("user1", 16.February(2021), RequestStatus.Interrupted),
new Request("user2", 16.February(2021), RequestStatus.Allocated),
};
var controller = new OverviewController(
CreateDateCalculator.WithActiveDates(activeDates),
CreateRequestRepository.WithRequests(activeDates, requests),
CreateUserRepository.WithUsers(users))
{
ControllerContext = CreateControllerContext.WithUsername("user2")
};
var result = await controller.GetAsync();
var resultValue = GetResultValue <OverviewResponse>(result);
var day1Data = GetDailyData(resultValue.Overview, 15.February(2021));
var day2Data = GetDailyData(resultValue.Overview, 16.February(2021));
Assert.False(day1Data.AllocatedUsers.Single().IsHighlighted);
Assert.True(day1Data.InterruptedUsers.Single().IsHighlighted);
Assert.True(day2Data.AllocatedUsers.Single().IsHighlighted);
Assert.False(day2Data.InterruptedUsers.Single().IsHighlighted);
}
public static async Task Returns_reservations_data_for_each_active_date()
{
var activeDates = new[] { 15.February(2021), 16.February(2021), 18.February(2021) };
var controller = new ReservationsController(
CreateConfigurationRepository.WithDefaultConfiguration(),
CreateDateCalculator.WithActiveDates(activeDates),
CreateReservationRepository.WithReservations(activeDates, new List <Reservation>()),
CreateUserRepository.WithUsers(DefaultUsers));
var result = await controller.GetAsync();
var resultValue = GetResultValue <ReservationsResponse>(result);
Assert.NotNull(resultValue.Reservations);
var visibleDays = GetVisibleDays(resultValue.Reservations);
Assert.Equal(activeDates, visibleDays.Select(d => d.LocalDate));
Assert.All(visibleDays, d => Assert.NotNull(d.Data));
}
