Ejemplo n.º 1
0
        public void Should_map_all_properties()
        {
            var user = new UserBuilder(EmailData.FAKE_EMAIL_STEM, 1)
                       .WithUserType(UserType.Individual)
                       .ForApplication(Application.TestApi)
                       .BuildUserDto();

            var userDetails = new List <UserDetailsResponse>
            {
                new UserDetailsResponse
                {
                    Application  = user.Application,
                    ContactEmail = user.ContactEmail,
                    CreatedDate  = DateTime.UtcNow,
                    DisplayName  = user.DisplayName,
                    FirstName    = user.FirstName,
                    LastName     = user.LastName,
                    Number       = user.Number,
                    Username     = user.Username,
                    UserType     = user.UserType
                }
            };

            var response = UserDetailsResponseToUserMapper.Map(userDetails);

            response.First().Should().BeEquivalentTo(user, options =>
                                                     options.Excluding(x => x.CreatedDate).Excluding(x => x.Id));
        }
        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);
        }