public async Task Should_update_participant_in_hearing_and_conference()
{
await CreateAndConfirmHearing();
var participant = Hearing.Participants.First(x => x.HearingRoleName == RoleData.INDV_HEARING_ROLE_NAME && !x.LinkedParticipants.Any());
var interpreter = Hearing.Participants.FirstOrDefault(x => x.HearingRoleName == RoleData.INTERPRETER_HEARING_ROLE_NAME);
var request = new UpdateParticipantRequest
{
DisplayName = $"{participant.DisplayName} {HearingData.UPDATED_TEXT}",
OrganisationName = $"{participant.Organisation} {HearingData.UPDATED_TEXT}",
TelephoneNumber = UserData.UPDATED_TELEPHONE_NUMBER,
Title = $"{participant.Title} {HearingData.UPDATED_TEXT}",
LinkedParticipants = new LinkedParticipantsRequestBuilder(participant.ContactEmail, interpreter.ContactEmail).Build()
};
await BookingApiClient.UpdateParticipantDetailsAsync(Hearing.Id, participant.Id, request);
var conferenceDetails = await PollForConferenceParticipantUpdated(Hearing.Id, participant.Id, HearingData.UPDATED_TEXT);
var updatedParticipant = conferenceDetails.Participants.First(x => x.Username.Equals(participant.Username));
var updatedInterpreter = conferenceDetails.Participants.FirstOrDefault(x => x.HearingRole == RoleData.INTERPRETER_HEARING_ROLE_NAME);
updatedParticipant.DisplayName.Should().Be(request.DisplayName);
updatedParticipant.ContactTelephone.Should().Be(request.TelephoneNumber);
updatedParticipant.LinkedParticipants.FirstOrDefault().LinkedId.Should().Be(updatedInterpreter.Id);
}
public async Task Should_delete_conference_when_hearing_deleted()
{
await CreateAndConfirmHearing();
await BookingApiClient.RemoveHearingAsync(Hearing.Id);
var result = await PollForConferenceDeleted(Hearing.Id);
Hearing.Status = BookingStatus.Cancelled;
result.Should().BeTrue();
}
public async Task Should_remove_participant_from_hearing_and_conference()
{
await CreateAndConfirmHearing();
var participant = Hearing.Participants.First(x => x.UserRoleName.Equals("Individual"));
await BookingApiClient.RemoveParticipantFromHearingAsync(Hearing.Id, participant.Id);
var conferenceDetails = await PollForConferenceParticipantPresence(Hearing.Id, participant.Username, false);
conferenceDetails.Participants.Any(x => x.Username.Equals(participant.Username)).Should().BeFalse();
}
private async Task ConfirmMultiDayHearing(HearingDetailsResponse hearing)
{
var confirmRequest = new UpdateBookingStatusRequestBuilder()
.UpdatedBy(HearingData.CREATED_BY(Context.Config.UsernameStem))
.Build();
await BookingApiClient.UpdateBookingStatusAsync(hearing.Id, confirmRequest);
Conference = await GetConferenceByHearingIdPollingAsync(hearing.Id);
Verify.ConferenceDetailsResponse(Conference, hearing);
}
private async Task <List <HearingDetailsResponse> > PollForAllMultiDayHearings(string username, string expectedCaseName, int expectedNumberOfHearings)
{
var policy = Policy
.HandleResult <List <HearingDetailsResponse> >(responses => responses.Where(x => x.Cases.Single().Name.StartsWith(expectedCaseName)).ToList().Count != expectedNumberOfHearings)
.WaitAndRetryAsync(Retries, retryAttempt =>
TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)));
var allHearingsForUser = await policy.ExecuteAsync(async() => await BookingApiClient.GetHearingsByUsernameAsync(username) as List <HearingDetailsResponse>);
var multiDayHearingsOnly = allHearingsForUser.Where(x => x.Cases.Single().Name.StartsWith(expectedCaseName)).ToList();
multiDayHearingsOnly.Count.Should().Be(expectedNumberOfHearings);
return(multiDayHearingsOnly);
}
public async Task Should_add_participant_to_hearing_and_conference()
{
await CreateAndConfirmHearing();
var request = new AddParticipantsToHearingRequest()
{
Participants = new HearingParticipantsBuilder(Context.Config.UsernameStem, false).AddUser("Individual", 2).Build()
};
await BookingApiClient.AddParticipantsToHearingAsync(Hearing.Id, request);
var conferenceDetails = await PollForConferenceParticipantPresence(Hearing.Id, request.Participants.First().Username, true);
var participant = conferenceDetails.Participants.First(x => x.Username == request.Participants.First().Username);
Verify.ParticipantDetails(participant, request);
}
public async Task Should_delete_conference_when_hearing_cancelled()
{
await CreateAndConfirmHearing();
const string updatedBy = "*****@*****.**";
var request = new UpdateBookingStatusRequestBuilder()
.WithStatus(UpdateBookingStatus.Cancelled)
.UpdatedBy(updatedBy)
.Build();
await BookingApiClient.UpdateBookingStatusAsync(Hearing.Id, request);
var result = await PollForConferenceDeleted(Hearing.Id);
Hearing.Status = BookingStatus.Cancelled;
result.Should().BeTrue();
}
public async Task Should_create_cacd_conference_from_hearing()
{
await CreateAndConfirmHearing();
var request = new BookHearingRequestBuilder(Context.Config.UsernameStem).CacdHearing().Build();
var hearing = await BookingApiClient.BookNewHearingAsync(request);
var confirmRequest = new UpdateBookingStatusRequestBuilder()
.UpdatedBy(HearingData.CREATED_BY(Context.Config.UsernameStem))
.Build();
await BookingApiClient.UpdateBookingStatusAsync(hearing.Id, confirmRequest);
var conferenceDetailsResponse = await GetConferenceByHearingIdPollingAsync(Hearing.Id);
conferenceDetailsResponse.Should().NotBeNull();
Verify.ConferenceDetailsResponse(conferenceDetailsResponse, Hearing);
}
public async Task Should_create_multi_day_conference_from_hearing()
{
var request = new BookHearingRequestBuilder(Context.Config.UsernameStem).MoveScheduledDateIfWeekend().Build();
var initialHearing = await BookingApiClient.BookNewHearingAsync(request);
Hearings.Add(initialHearing);
const int numberOfDays = 2;
var numberOfDaysNotIncludingWeekends = CalculateDaysWithoutWeekend(numberOfDays, initialHearing.ScheduledDateTime);
var start = initialHearing.ScheduledDateTime;
var end = initialHearing.ScheduledDateTime.AddDays(numberOfDaysNotIncludingWeekends);
var dates = DateListMapper.GetListOfWorkingDates(start, end);
dates.Count.Should().Be(numberOfDays);
// Add the initial hearing day
const int totalNumberOfDays = numberOfDays + 1;
var multiHearingsRequest = new CloneHearingRequest()
{
Dates = dates
};
await BookingApiClient.CloneHearingAsync(initialHearing.Id, multiHearingsRequest);
var anyParticipant = initialHearing.Participants.First();
var multiDays = await PollForAllMultiDayHearings(anyParticipant.Username, initialHearing.Cases.Single().Name, totalNumberOfDays);
Hearings.AddRange(multiDays);
multiDays.Count.Should().Be(totalNumberOfDays);
foreach (var day in multiDays)
{
await ConfirmMultiDayHearing(day);
}
}
public async Task Should_update_conference_when_hearing_updated()
{
await CreateAndConfirmHearing();
var caseRequests = new List <CaseRequest>
{
new CaseRequest
{
IsLeadCase = Hearing.Cases.First().IsLeadCase,
Name = $"{Hearing.Cases.First().Name} {HearingData.UPDATED_TEXT}",
Number = $"{Hearing.Cases.First().Number} {HearingData.UPDATED_TEXT}"
}
};
var request = new UpdateHearingRequest
{
AudioRecordingRequired = !Hearing.AudioRecordingRequired,
Cases = caseRequests,
HearingRoomName = $"{Hearing.HearingRoomName} {HearingData.UPDATED_TEXT}",
HearingVenueName = Hearing.HearingVenueName.Equals(HearingData.VENUE_NAME) ? HearingData.VENUE_NAME_ALTERNATIVE : HearingData.VENUE_NAME,
OtherInformation = $"{Hearing.OtherInformation} {HearingData.UPDATED_TEXT}",
QuestionnaireNotRequired = !Hearing.QuestionnaireNotRequired,
ScheduledDateTime = Hearing.ScheduledDateTime.AddMinutes(10),
ScheduledDuration = Hearing.ScheduledDuration / 2,
UpdatedBy = EmailData.NON_EXISTENT_USERNAME
};
var hearingDetails = await BookingApiClient.UpdateHearingDetailsAsync(Hearing.Id, request);
Verify.UpdatedHearing(hearingDetails, request);
var response = await GetUpdatedConferenceDetailsPollingAsync(Hearing.Id);
response.Should().NotBeNull();
Verify.UpdatedConference(response, request);
}
