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)); }