Example #1
0
        public async Task Should_allocate_multiple_users_no_users_exist()
        {
            var userTypes = new List <UserType>()
            {
                UserType.Judge,
                UserType.Individual,
                UserType.Representative,
                UserType.Observer,
                UserType.PanelMember,
                UserType.Winger,
                UserType.CaseAdmin,
                UserType.Witness,
                UserType.Interpreter
            };

            var request = new AllocateUsersRequestBuilder()
                          .WithUserTypes(userTypes)
                          .ForApplication(Application.TestApi)
                          .Build();

            var uri = ApiUriFactory.AllocationEndpoints.AllocateUsers;

            await SendPatchRequest(uri, RequestHelper.Serialise(request));

            VerifyResponse(HttpStatusCode.OK, true);
            var response = RequestHelper.Deserialise <List <UserDetailsResponse> >(Json);

            response.Should().NotBeNull();
            Verify.UsersDetailsResponse(response, userTypes);
        }
Example #2
0
        public async Task Should_allocate_multiple_users_unallocated_users_exist()
        {
            var judgeUser = await Context.Data.SeedUser();

            var individualUser = await Context.Data.SeedUser(UserType.Individual);

            var representativeUser = await Context.Data.SeedUser(UserType.Representative);

            var caseAdminUser = await Context.Data.SeedUser(UserType.CaseAdmin);

            var users = new List <UserDto>()
            {
                judgeUser, individualUser, representativeUser, caseAdminUser
            };

            var userTypes = new List <UserType>()
            {
                judgeUser.UserType, individualUser.UserType, representativeUser.UserType, caseAdminUser.UserType
            };

            var request = new AllocateUsersRequestBuilder()
                          .WithUserTypes(userTypes)
                          .ForApplication(Application.TestApi)
                          .Build();

            var uri = ApiUriFactory.AllocationEndpoints.AllocateUsers;

            await SendPatchRequest(uri, RequestHelper.Serialise(request));

            VerifyResponse(HttpStatusCode.OK, true);
            var response = RequestHelper.Deserialise <List <UserDetailsResponse> >(Json);

            response.Should().NotBeNull();
            Verify.UsersDetailsResponse(response, users);
        }
Example #3
0
        public async Task Should_pass_validation_with_one_vho()
        {
            var request = new AllocateUsersRequestBuilder()
                          .WithVideoHearingsOfficer()
                          .ForApplication(Application.TestApi)
                          .Build();

            var result = await _validator.ValidateAsync(request);

            result.IsValid.Should().BeTrue();
        }
Example #4
0
        public async Task Should_pass_validation_with_case_admin()
        {
            var request = new AllocateUsersRequestBuilder()
                          .WithDefaultTypes()
                          .ForApplication(Application.TestApi)
                          .Build();

            var result = await _validator.ValidateAsync(request);

            result.IsValid.Should().BeTrue();
        }
Example #5
0
        public async Task Should_return_empty_application_error()
        {
            var request = new AllocateUsersRequestBuilder()
                          .WithDefaultTypes()
                          .Build();

            var result = await _validator.ValidateAsync(request);

            result.IsValid.Should().BeFalse();
            result.Errors.Count.Should().Be(1);
            result.Errors.First().ErrorMessage.Should()
            .Be(AllocateUsersRequestValidator.EMPTY_APPLICATION_ERROR_MESSAGE);
        }
Example #6
0
        public async Task Should_return_more_than_one_judge_error()
        {
            var request = new AllocateUsersRequestBuilder()
                          .WithMoreThanOneJudge()
                          .ForApplication(Application.TestApi)
                          .Build();

            var result = await _validator.ValidateAsync(request);

            result.IsValid.Should().BeFalse();
            result.Errors.Count.Should().Be(1);
            result.Errors.First().ErrorMessage.Should()
            .Be(AllocateUsersRequestValidator.MORE_THAN_ONE_JUDGE_ERROR_MESSAGE);
        }
Example #7
0
        public async Task Should_return_empty_users_error()
        {
            var request = new AllocateUsersRequestBuilder()
                          .WithEmptyUsers()
                          .ForApplication(Application.TestApi)
                          .Build();

            var result = await _validator.ValidateAsync(request);

            result.IsValid.Should().BeFalse();
            result.Errors.Count.Should().BeGreaterThan(0);
            result.Errors.Any(x => x.ErrorMessage == AllocateUsersRequestValidator.EMPTY_USERS_ERROR_MESSAGE)
            .Should().BeTrue();
        }
Example #8
0
        public async Task Should_allocate_multiple_users_allocated_users_exist_with_other_test_types(TestType testType)
        {
            const Application APPLICATION = Application.TestApi;

            var judgeUser = await Context.Data.SeedUser(testType);

            await Context.Data.SeedAllocation(judgeUser.Id);

            await Context.Data.AllocateUser(judgeUser.Id);

            var individualUser = await Context.Data.SeedUser(testType, UserType.Individual);

            await Context.Data.SeedAllocation(individualUser.Id);

            await Context.Data.AllocateUser(individualUser.Id);

            var representativeUser = await Context.Data.SeedUser(testType, UserType.Representative);

            await Context.Data.SeedAllocation(representativeUser.Id);

            await Context.Data.AllocateUser(representativeUser.Id);

            var caseAdminUser = await Context.Data.SeedUser(testType, UserType.CaseAdmin);

            await Context.Data.SeedAllocation(caseAdminUser.Id);

            await Context.Data.AllocateUser(caseAdminUser.Id);

            var userTypes = new List <UserType>()
            {
                judgeUser.UserType, individualUser.UserType, representativeUser.UserType, caseAdminUser.UserType
            };

            var request = new AllocateUsersRequestBuilder()
                          .WithUserTypes(userTypes)
                          .ForApplication(APPLICATION)
                          .WithTestType(testType)
                          .Build();

            var uri = ApiUriFactory.AllocationEndpoints.AllocateUsers;

            await SendPatchRequest(uri, RequestHelper.Serialise(request));

            VerifyResponse(HttpStatusCode.OK, true);
            var response = RequestHelper.Deserialise <List <UserDetailsResponse> >(Json);

            response.Should().NotBeNull();
            Verify.UsersDetailsResponse(response, userTypes);
        }
Example #9
0
        public async Task Should_be_greater_than_zero_for_expiry()
        {
            var request = new AllocateUsersRequestBuilder()
                          .WithDefaultTypes()
                          .ForApplication(Application.TestApi)
                          .WithExpiryInMinutes(-1)
                          .Build();

            var result = await _validator.ValidateAsync(request);

            result.IsValid.Should().BeFalse();
            result.Errors.Count.Should().Be(1);
            result.Errors.First().ErrorMessage.Should()
            .Be(AllocateUsersRequestValidator.EXPIRES_IN_GREATER_THAN_ZERO_ERROR_MESSAGE);
        }
Example #10
0
        public async Task Should_be_less_than_thirty_days_for_expiry()
        {
            var request = new AllocateUsersRequestBuilder()
                          .WithDefaultTypes()
                          .ForApplication(Application.TestApi)
                          .WithExpiryInMinutes(Convert.ToInt32(TimeSpan.FromDays(30).Add(TimeSpan.FromMinutes(1)).TotalMinutes))
                          .Build();

            var result = await _validator.ValidateAsync(request);

            result.IsValid.Should().BeFalse();
            result.Errors.Count.Should().Be(1);
            result.Errors.First().ErrorMessage.Should()
            .Be(AllocateUsersRequestValidator.EXPIRES_IN_LESS_THAN_THIRTY_DAYS_ERROR_MESSAGE);
        }
        public async Task Should_create_hearing_and_allocate_users()
        {
            var userTypes = new List <UserType>()
            {
                UserType.Judge,
                UserType.VideoHearingsOfficer,
                UserType.CaseAdmin,
                UserType.Individual,
                UserType.Representative,
                UserType.Individual,
                UserType.Representative,
                UserType.Interpreter,
                UserType.Observer,
                UserType.PanelMember,
                UserType.Witness
            };

            var allocateRequest = new AllocateUsersRequestBuilder()
                                  .WithUserTypes(userTypes)
                                  .ForApplication(Application.TestApi)
                                  .Build();

            var allocateUsersUri = ApiUriFactory.AllocationEndpoints.AllocateUsers;

            await SendPatchRequest(allocateUsersUri, RequestHelper.Serialise(allocateRequest));

            VerifyResponse(HttpStatusCode.OK, true);
            var usersDetails = RequestHelper.Deserialise <List <UserDetailsResponse> >(Json);

            usersDetails.Should().NotBeNull();
            Verify.UsersDetailsResponse(usersDetails, userTypes);

            var users = UserDetailsResponseToUserMapper.Map(usersDetails);

            var hearingRequest = new HearingBuilder(users)
                                 .TypeOfTest(TestType.Automated)
                                 .Build();

            var createHearingUri = ApiUriFactory.HearingEndpoints.CreateHearing;

            await SendPostRequest(createHearingUri, RequestHelper.Serialise(hearingRequest));

            VerifyResponse(HttpStatusCode.Created, true);

            var hearing = RequestHelper.Deserialise <HearingDetailsResponse>(Json);

            hearing.Should().NotBeNull();
            HearingsToDelete.Add(hearing);

            var caseAdmin = hearingRequest.Users.First(x => x.UserType == UserType.CaseAdmin);

            var request = new UpdateBookingRequestBuilder().Build();

            var uri = ApiUriFactory.HearingEndpoints.ConfirmHearing(hearing.Id);

            await SendPatchRequest(uri, RequestHelper.Serialise(request));

            VerifyResponse(HttpStatusCode.Created, true);
            var conference = RequestHelper.Deserialise <ConferenceDetailsResponse>(Json);

            conference.Should().NotBeNull();
            Verify.ConferenceDetailsResponse(conference, hearing);

            var unallocateUsersRequest = new UnallocateUsersRequest()
            {
                Usernames = users.Select(user => user.Username).ToList()
            };

            var unallocateUri = ApiUriFactory.AllocationEndpoints.UnallocateUsers;

            await SendPatchRequest(unallocateUri, RequestHelper.Serialise(unallocateUsersRequest));

            VerifyResponse(HttpStatusCode.OK, true);
        }
Example #12
0
        public async Task Should_allocate_multiple_joh_ejud_users_and_none_ejud()
        {
            const Application APPLICATION = Application.TestApi;

            var individualUser = await Context.Data.SeedUser(UserType.Individual);

            await Context.Data.SeedAllocation(individualUser.Id);

            var representativeUser = await Context.Data.SeedUser(UserType.Representative);

            await Context.Data.SeedAllocation(representativeUser.Id);

            var userTypes = new List <UserType>()
            {
                UserType.Judge, UserType.PanelMember, UserType.Winger, individualUser.UserType, representativeUser.UserType
            };

            var request = new AllocateUsersRequestBuilder()
                          .WithUserTypes(userTypes)
                          .ForApplication(APPLICATION)
                          .IsEjud()
                          .Build();

            var uri = ApiUriFactory.AllocationEndpoints.AllocateUsers;

            await SendPatchRequest(uri, RequestHelper.Serialise(request));

            VerifyResponse(HttpStatusCode.OK, true);
            var response = RequestHelper.Deserialise <List <UserDetailsResponse> >(Json);

            response.Should().NotBeNull();

            var allocateJudge           = response.Single(x => x.UserType == UserType.Judge);
            var allocatedPanelMember    = response.Single(x => x.UserType == UserType.PanelMember);
            var allocatedWinger         = response.Single(x => x.UserType == UserType.Winger);
            var allocatedIndividual     = response.Single(x => x.UserType == UserType.Individual);
            var allocatedRepresentative = response.Single(x => x.UserType == UserType.Representative);

            allocateJudge.ContactEmail.Should().EndWith(Context.Config.EjudUsernameStem);
            allocateJudge.ContactEmail.Should().NotEndWith(Context.Config.UsernameStem);
            allocateJudge.Username.Should().EndWith(Context.Config.EjudUsernameStem);
            allocateJudge.Username.Should().NotEndWith(Context.Config.UsernameStem);

            allocatedPanelMember.ContactEmail.Should().EndWith(Context.Config.EjudUsernameStem);
            allocatedPanelMember.ContactEmail.Should().NotEndWith(Context.Config.UsernameStem);
            allocatedPanelMember.Username.Should().EndWith(Context.Config.EjudUsernameStem);
            allocatedPanelMember.Username.Should().NotEndWith(Context.Config.UsernameStem);

            allocatedWinger.ContactEmail.Should().EndWith(Context.Config.EjudUsernameStem);
            allocatedWinger.ContactEmail.Should().NotEndWith(Context.Config.UsernameStem);
            allocatedWinger.Username.Should().EndWith(Context.Config.EjudUsernameStem);
            allocatedWinger.Username.Should().NotEndWith(Context.Config.UsernameStem);

            allocatedIndividual.ContactEmail.Should().NotEndWith(Context.Config.EjudUsernameStem);
            allocatedIndividual.Username.Should().EndWith(Context.Config.UsernameStem);
            allocatedIndividual.Username.Should().NotEndWith(Context.Config.EjudUsernameStem);

            allocatedRepresentative.ContactEmail.Should().NotEndWith(Context.Config.EjudUsernameStem);
            allocatedRepresentative.Username.Should().EndWith(Context.Config.UsernameStem);
            allocatedRepresentative.Username.Should().NotEndWith(Context.Config.EjudUsernameStem);
        }