public async Task Should_delete_hearing_by_id()
        {
            var request         = CreateHearingRequest();
            var hearingResponse = await CreateHearing(request);

            await DeleteHearing(hearingResponse.Id);

            VerifyResponse(HttpStatusCode.NoContent, true);
            HearingsToDelete.Remove(hearingResponse);
        }
        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);
        }