public async Task should_return_bad_request_when_endpoint_is_already_in_room()
{
var endpointWithDefenceAdvocate = TestConference.GetEndpoints().First(x => !string.IsNullOrWhiteSpace(x.DefenceAdvocate));
var defenceAdvocate = TestConference.GetParticipants().First(x =>
x.Username.Equals(endpointWithDefenceAdvocate.DefenceAdvocate,
StringComparison.CurrentCultureIgnoreCase));
var room = new ConsultationRoom(TestConference.Id, "Label", VideoApi.Domain.Enums.VirtualCourtRoomType.Participant, false);
room.AddEndpoint(new RoomEndpoint(Guid.NewGuid()));
QueryHandlerMock.Setup(x => x.Handle <GetConsultationRoomByIdQuery, ConsultationRoom>(It.IsAny <GetConsultationRoomByIdQuery>())).ReturnsAsync(room);
var request = new EndpointConsultationRequest()
{
ConferenceId = TestConference.Id,
EndpointId = endpointWithDefenceAdvocate.Id,
RequestedById = defenceAdvocate.Id,
RoomLabel = "Label"
};
var result = await Controller.StartConsultationWithEndpointAsync(request);
var actionResult = result.As <BadRequestObjectResult>();
actionResult.Should().NotBeNull();
actionResult.Value.Should().Be("Room already has an active endpoint");
}
public async Task Should_return_error_when_consultation_accepted_but_no_room_is_available()
{
var conferenceId = TestConference.Id;
var requestedBy = TestConference.GetParticipants()[2];
var requestedFor = TestConference.GetParticipants()[3];
VideoPlatformServiceMock
.Setup(x => x.StartPrivateConsultationAsync(TestConference, requestedBy, requestedFor))
.ThrowsAsync(new DomainRuleException("Unavailable room", "No consultation rooms available"));
// make sure no rooms are available
TestConference.Participants[1].UpdateCurrentRoom(RoomType.ConsultationRoom1);
TestConference.Participants[4].UpdateCurrentRoom(RoomType.ConsultationRoom2);
var answer = ConsultationAnswer.Accepted;
var request = new ConsultationRequest
{
ConferenceId = conferenceId,
RequestedBy = requestedBy.Id,
RequestedFor = requestedFor.Id,
Answer = answer
};
var result = await Controller.HandleConsultationRequestAsync(request);
var typedResult = (ObjectResult)result;
typedResult.StatusCode.Should().Be((int)HttpStatusCode.BadRequest);
((SerializableError)typedResult.Value).ContainsKeyAndErrorMessage("ConsultationRoom", "No consultation room available");
VideoPlatformServiceMock.Verify(x =>
x.StartPrivateConsultationAsync(TestConference, requestedBy, requestedFor), Times.Once);
VideoPlatformServiceMock.VerifyNoOtherCalls();
}
public async Task Should_remove_given_participants_from_conference()
{
var conferenceId = TestConference.Id;
var participant = TestConference.GetParticipants()[1];
await Controller.RemoveParticipantFromConferenceAsync(conferenceId, participant.Id);
MockQueryHandler.Verify(m => m.Handle <GetConferenceByIdQuery, VideoApi.Domain.Conference>(It.IsAny <GetConferenceByIdQuery>()), Times.Once);
MockCommandHandler.Verify(c =>
c.Handle(It.Is <RemoveParticipantsFromConferenceCommand>(x => x.Participants[0].Id == participant.Id)), Times.Once);
}
public async Task should_return_video_api_error()
{
var participant = TestConference.GetJudge();
var user = new ClaimsPrincipalBuilder()
.WithUsername(participant.Username)
.WithRole(AppRoles.JudgeRole).Build();
Controller = SetupControllerWithClaims(user);
var responseMessage = "Could not pause a video hearing";
var apiException = new Services.Video.VideoApiException <ProblemDetails>("Internal Server Error", (int)HttpStatusCode.InternalServerError,
responseMessage, null, default, null);
public async Task Should_save_heartbeat()
{
var conferenceId = TestConference.Id;
var participantId = TestConference.GetParticipants()[1].Id;
var result = await Controller.SaveHeartbeatDataForParticipantAsync(conferenceId, participantId, new AddHeartbeatRequest());
MockCommandHandler.Verify(c => c.Handle(It.IsAny <SaveHeartbeatCommand>()), Times.Once);
result.Should().NotBeNull();
result.Should().BeAssignableTo <NoContentResult>();
}
public async Task Should_update_given_participants_details()
{
var conferenceId = TestConference.Id;
var participant = TestConference.GetParticipants()[1];
var result = await Controller.UpdateParticipantDetailsAsync(conferenceId, participant.Id, _updateParticipantRequest);
MockCommandHandler.Verify(c => c.Handle(It.IsAny <UpdateParticipantDetailsCommand>()), Times.Once);
var typedResult = (NoContentResult)result;
typedResult.Should().NotBeNull();
}
public async Task should_return_video_api_error()
{
var judge = TestConference.GetJudge();
var witness = TestConference.Participants.First(x => x.HearingRole == "Witness");
var user = new ClaimsPrincipalBuilder()
.WithUsername(judge.Username)
.WithRole(AppRoles.JudgeRole).Build();
Controller = SetupControllerWithClaims(user);
var responseMessage = "Could not start transfer participant";
var apiException = new VideoApiException <ProblemDetails>("Internal Server Error",
(int)HttpStatusCode.InternalServerError,
responseMessage, null, default, null);
private StartConsultationRequest InitConsultationRequestForJudge()
{
if (TestConference.Participants == null)
{
Assert.Fail("No participants found in conference");
}
return(new StartConsultationRequest
{
ConferenceId = TestConference.Id,
RequestedBy = TestConference.GetParticipants().First(x =>
x.UserRole.Equals(UserRole.Judge)).Id,
RoomType = Contract.Enums.VirtualCourtRoomType.JudgeJOH
});
}
public async Task Should_return_badrequest_when_participant_current_room_is_not_consultation_room_type()
{
var conferenceId = TestConference.Id;
var request = TestConference.GetParticipants()[2];
var leaveConsultationRequest = new LeaveConsultationRequest
{
ConferenceId = conferenceId,
ParticipantId = request.Id
};
var result = await Controller.LeaveConsultationAsync(leaveConsultationRequest);
result.Should().BeOfType <BadRequestObjectResult>();
}
public async Task should_add_username_to_command_when_provided()
{
var conferenceId = TestConference.Id;
var participant = TestConference.GetParticipants()[1];
_updateParticipantRequest.Username = "******";
var result = await Controller.UpdateParticipantDetailsAsync(conferenceId, participant.Id, _updateParticipantRequest);
MockCommandHandler.Verify(c => c.Handle(It.Is <UpdateParticipantDetailsCommand>(c => c.Username == _updateParticipantRequest.Username)), Times.Once);
var typedResult = (NoContentResult)result;
typedResult.Should().NotBeNull();
}
public async Task Should_leave_private_consultation_with_valid_conference_and_room_type()
{
var conferenceId = TestConference.Id;
var request = TestConference.GetParticipants()[1];
var leaveConsultationRequest = new LeaveConsultationRequest {
ConferenceId = conferenceId,
ParticipantId = request.Id
};
await Controller.LeavePrivateConsultationAsync(leaveConsultationRequest);
QueryHandlerMock.Verify(q => q.Handle <GetConferenceByIdQuery, VideoApi.Domain.Conference>(It.IsAny <GetConferenceByIdQuery>()), Times.Once);
VideoPlatformServiceMock.Verify(v => v.StopPrivateConsultationAsync(TestConference, RoomType.ConsultationRoom1), Times.Once);
VideoPlatformServiceMock.VerifyNoOtherCalls();
}
public async Task Should_leave_private_consultation_with_valid_conference_and_room_type()
{
var conferenceId = TestConference.Id;
var participant = TestConference.GetParticipants()[1];
var leaveConsultationRequest = new LeaveConsultationRequest {
ConferenceId = conferenceId,
ParticipantId = participant.Id
};
await Controller.LeaveConsultationAsync(leaveConsultationRequest);
QueryHandlerMock.Verify(q => q.Handle <GetConferenceByIdQuery, VideoApi.Domain.Conference>(It.IsAny <GetConferenceByIdQuery>()), Times.Once);
ConsultationServiceMock.Verify(v => v.LeaveConsultationAsync(TestConference.Id, leaveConsultationRequest.ParticipantId, participant.GetCurrentRoom(), RoomType.WaitingRoom.ToString()), Times.Once);
ConsultationServiceMock.VerifyNoOtherCalls();
}
private StartConsultationRequest RequestBuilder()
{
if (TestConference.Participants == null)
{
Assert.Fail("No participants found in conference");
}
_testConsultationRoom = new ConsultationRoom(TestConference.Id, "JohRoom1", VirtualCourtRoomType.JudgeJOH.MapToDomainEnum(), false);
return(new StartConsultationRequest
{
ConferenceId = TestConference.Id,
RequestedBy = TestConference.GetParticipants().First(x =>
x.UserRole.MapToContractEnum().Equals(UserRole.Judge)).Id,
RoomType = VirtualCourtRoomType.JudgeJOH
});
}
public async Task Should_return_nocontent_when_participant_current_room_is_not_consultation_room_type()
{
var conferenceId = TestConference.Id;
var request = TestConference.GetParticipants()[2];
var leaveConsultationRequest = new LeaveConsultationRequest
{
ConferenceId = conferenceId,
ParticipantId = request.Id
};
var result = await Controller.LeavePrivateConsultationAsync(leaveConsultationRequest);
var typedResult = (NoContentResult)result;
typedResult.Should().NotBeNull();
}
public async Task should_return_not_found_when_conference_not_found()
{
var conferenceId = Guid.NewGuid();
var endpointId = TestConference.GetEndpoints().First().Id;
var request = new EndpointConsultationRequest()
{
ConferenceId = conferenceId,
EndpointId = endpointId
};
var result = await Controller.StartConsultationWithEndpointAsync(request);
var actionResult = result.As <NotFoundObjectResult>();
actionResult.Should().NotBeNull();
actionResult.Value.Should().Be($"Unable to find conference {request.ConferenceId}");
}
public async Task should_return_ok_when_vho_invites()
{
// Arrange
var endpointWithoutDefenceAdvocate = TestConference.GetEndpoints().First(x => string.IsNullOrWhiteSpace(x.DefenceAdvocate));
var request = new EndpointConsultationRequest()
{
ConferenceId = TestConference.Id,
EndpointId = endpointWithoutDefenceAdvocate.Id,
RequestedById = Guid.Empty,
RoomLabel = "NewRoom_NotInDb"
};
// Act
var result = await Controller.StartConsultationWithEndpointAsync(request);
// Assert
result.Should().BeOfType <OkResult>();
}
public async Task should_return_ok_when_judge_invites()
{
// Arrange
var endpointWithoutDefenceAdvocate = TestConference.GetEndpoints().First(x => string.IsNullOrWhiteSpace(x.DefenceAdvocate));
var requestedByJudge = TestConference.GetParticipants().First(x => x.UserRole == VideoApi.Domain.Enums.UserRole.Judge);
var request = new EndpointConsultationRequest()
{
ConferenceId = TestConference.Id,
EndpointId = endpointWithoutDefenceAdvocate.Id,
RequestedById = requestedByJudge.Id,
RoomLabel = "NewRoom_NotInDb"
};
// Act
var result = await Controller.StartConsultationWithEndpointAsync(request);
// Assert
result.Should().BeOfType <OkResult>();
}
public async Task should_return_accepted_when_endpoint_is_linked_with_defence_advocate()
{
var endpointWithDefenceAdvocate = TestConference.GetEndpoints().First(x => !string.IsNullOrWhiteSpace(x.DefenceAdvocate));
var defenceAdvocate = TestConference.GetParticipants().First(x =>
x.Username.Equals(endpointWithDefenceAdvocate.DefenceAdvocate,
StringComparison.CurrentCultureIgnoreCase));
var request = new EndpointConsultationRequest()
{
ConferenceId = TestConference.Id,
EndpointId = endpointWithDefenceAdvocate.Id,
DefenceAdvocateId = defenceAdvocate.Id
};
var result = await Controller.StartPrivateConsultationWithEndpointAsync(request);
var actionResult = result.As <AcceptedResult>();
actionResult.Should().NotBeNull();
}
public async Task should_return_unauthorised_when_endpoint_is_not_linked_with_defence_advocate()
{
var endpointWithDefenceAdvocate = TestConference.GetEndpoints().First(x => !string.IsNullOrWhiteSpace(x.DefenceAdvocate));
var defenceAdvocate = TestConference.GetParticipants().First(x =>
!x.Username.Equals(endpointWithDefenceAdvocate.DefenceAdvocate,
StringComparison.CurrentCultureIgnoreCase) && x.UserRole != VideoApi.Domain.Enums.UserRole.Judge);
var request = new EndpointConsultationRequest()
{
ConferenceId = TestConference.Id,
EndpointId = endpointWithDefenceAdvocate.Id,
RequestedById = defenceAdvocate.Id
};
var result = await Controller.StartConsultationWithEndpointAsync(request);
var actionResult = result.As <UnauthorizedObjectResult>();
actionResult.Should().NotBeNull();
actionResult.Value.Should().Be("Defence advocate is not allowed to speak to requested endpoint");
}
public async Task Should_return_notfound_when_no_room_label_provided()
{
var conferenceId = TestConference.Id;
var participant = TestConference.GetParticipants()[3];
var requestedBy = TestConference.GetParticipants()[2].Id;
var request = new ConsultationRequestResponse
{
ConferenceId = conferenceId,
RequestedFor = participant.Id,
RequestedBy = requestedBy,
RoomLabel = "",
Answer = ConsultationAnswer.Rejected
};
var result = await Controller.RespondToConsultationRequestAsync(request);
var typedResult = (NotFoundResult)result;
typedResult.Should().NotBeNull();
}
public async Task should_return_unauthorised_when_endpoint_does_not_have_defence_advocate()
{
var endpointWithDefenceAdvocate = TestConference.GetEndpoints().First(x => !string.IsNullOrWhiteSpace(x.DefenceAdvocate));
var endpointWithoutDefenceAdvocate = TestConference.GetEndpoints().First(x => string.IsNullOrWhiteSpace(x.DefenceAdvocate));
var defenceAdvocate = TestConference.GetParticipants().First(x =>
x.Username.Equals(endpointWithDefenceAdvocate.DefenceAdvocate,
StringComparison.CurrentCultureIgnoreCase));
var request = new EndpointConsultationRequest()
{
ConferenceId = TestConference.Id,
EndpointId = endpointWithoutDefenceAdvocate.Id,
RequestedById = defenceAdvocate.Id
};
var result = await Controller.StartConsultationWithEndpointAsync(request);
var actionResult = result.As <UnauthorizedObjectResult>();
actionResult.Should().NotBeNull();
actionResult.Value.Should().Be("Endpoint does not have a defence advocate linked");
}
public async Task should_return_unauthorised_if_participant_does_not_exists()
{
var judge = TestConference.GetJudge();
var user = new ClaimsPrincipalBuilder()
.WithUsername(judge.Username)
.WithRole(AppRoles.JudgeRole).Build();
Controller = SetupControllerWithClaims(user);
var result = await Controller.CallWitnessAsync(TestConference.Id, Guid.NewGuid());
result.Should().BeOfType <UnauthorizedObjectResult>();
var typedResult = (UnauthorizedObjectResult)result;
typedResult.Should().NotBeNull();
typedResult.Value.Should().Be("Participant is not a witness");
VideoApiClientMock.Verify(
x => x.TransferParticipantAsync(TestConference.Id,
It.IsAny <TransferParticipantRequest>()), Times.Never);
}
public async Task Should_return_notfound_when_no_requested_for_participant_is_found()
{
var conferenceId = TestConference.Id;
var requestedFor = TestConference.GetParticipants()[3];
var answer = ConsultationAnswer.Accepted;
var request = new ConsultationRequestResponse
{
ConferenceId = conferenceId,
RequestedBy = Guid.NewGuid(),
RequestedFor = requestedFor.Id,
Answer = answer
};
var result = await Controller.RespondToConsultationRequestAsync(request);
var typedResult = (NotFoundResult)result;
typedResult.Should().NotBeNull();
}
public async Task Should_not_transfer_participant_when_consultation_is_not_accepted()
{
var conferenceId = TestConference.Id;
var participant = TestConference.GetParticipants()[3];
var roomFrom = participant.GetCurrentRoom();
var request = new ConsultationRequestResponse
{
ConferenceId = conferenceId,
RequestedFor = participant.Id,
RoomLabel = "ConsultationRoom",
Answer = ConsultationAnswer.Rejected
};
await Controller.RespondToConsultationRequestAsync(request);
ConsultationServiceMock.Verify(x =>
x.LeaveConsultationAsync(conferenceId, participant.Id, roomFrom, request.RoomLabel),
Times.Never);
ConsultationServiceMock.VerifyNoOtherCalls();
}
public async Task Should_transfer_participant_when_consultation_is_accepted()
{
var conferenceId = TestConference.Id;
var participant = TestConference.GetParticipants()[3];
var requestedBy = TestConference.GetParticipants()[1];
var request = new ConsultationRequestResponse
{
ConferenceId = conferenceId,
RequestedBy = requestedBy.Id,
RequestedFor = participant.Id,
RoomLabel = "ConsultationRoom",
Answer = ConsultationAnswer.Accepted
};
await Controller.RespondToConsultationRequestAsync(request);
ConsultationServiceMock.Verify(x => x.ParticipantTransferToRoomAsync(conferenceId, participant.Id, request.RoomLabel),
Times.Once);
ConsultationServiceMock.VerifyNoOtherCalls();
}
public async Task should_return_unauthorised_if_participant_is_not_a_witness()
{
var judge = TestConference.GetJudge();
var participant = TestConference.Participants.First(x => x.Role == Role.Individual);
var user = new ClaimsPrincipalBuilder()
.WithUsername(judge.Username)
.WithRole(AppRoles.JudgeRole).Build();
Controller = SetupControllerWithClaims(user);
var result = await Controller.DismissWitnessAsync(TestConference.Id, participant.Id);
var typedResult = (UnauthorizedObjectResult)result;
typedResult.Should().NotBeNull();
typedResult.Value.Should().Be("Participant is not a witness");
VideoApiClientMock.Verify(
x => x.TransferParticipantAsync(TestConference.Id,
It.Is <TransferParticipantRequest>(r => r.ParticipantId == participant.Id)), Times.Never);
}
public async Task Should_not_transfer_participant_when_consultation_is_not_accepted()
{
var conferenceId = TestConference.Id;
var participant = TestConference.GetParticipants()[3];
var roomFrom = participant.CurrentRoom.Value;
var request = new AdminConsultationRequest
{
ConferenceId = conferenceId,
ParticipantId = participant.Id,
ConsultationRoom = RoomType.ConsultationRoom1,
Answer = ConsultationAnswer.Rejected
};
await Controller.RespondToAdminConsultationRequestAsync(request);
VideoPlatformServiceMock.Verify(x =>
x.TransferParticipantAsync(conferenceId, participant.Id, roomFrom, request.ConsultationRoom),
Times.Never);
VideoPlatformServiceMock.VerifyNoOtherCalls();
}
public async Task should_return_ok_when_endpoint_is_linked_with_defence_advocate()
{
var endpointWithDefenceAdvocate = TestConference.GetEndpoints().First(x => !string.IsNullOrWhiteSpace(x.DefenceAdvocate));
var defenceAdvocate = TestConference.GetParticipants().First(x =>
x.Username.Equals(endpointWithDefenceAdvocate.DefenceAdvocate,
StringComparison.CurrentCultureIgnoreCase));
var room = new ConsultationRoom(TestConference.Id, "Label", VideoApi.Domain.Enums.VirtualCourtRoomType.Participant, false);
QueryHandlerMock.Setup(x => x.Handle <GetConsultationRoomByIdQuery, ConsultationRoom>(It.IsAny <GetConsultationRoomByIdQuery>())).ReturnsAsync(room);
var request = new EndpointConsultationRequest()
{
ConferenceId = TestConference.Id,
EndpointId = endpointWithDefenceAdvocate.Id,
RequestedById = defenceAdvocate.Id,
RoomLabel = "Label"
};
var result = await Controller.StartConsultationWithEndpointAsync(request);
result.Should().BeOfType <OkResult>();
}
public async Task Should_close_conference_and_not_call_delete_audio_recording_application_if_audio_recording_file_not_found()
{
TestConference.AudioRecordingRequired = true;
TestConference.UpdateConferenceStatus(VideoApi.Domain.Enums.ConferenceState.InSession);
QueryHandlerMock
.Setup(x => x.Handle <GetConferenceByIdQuery, VideoApi.Domain.Conference>(It.IsAny <GetConferenceByIdQuery>()))
.ReturnsAsync(TestConference);
AzureStorageServiceFactoryMock.Setup(x => x.Create(AzureStorageServiceType.Vh)).Returns(AzureStorageServiceMock.Object);
AudioPlatformServiceMock.Reset();
AzureStorageServiceMock.Reset();
AzureStorageServiceMock.Setup(x => x.GetAllBlobNamesByFilePathPrefix(It.IsAny <string>())).ReturnsAsync(new List <string>());
await Controller.CloseConferenceAsync(Guid.NewGuid());
CommandHandlerMock.Verify(c => c.Handle(It.IsAny <CloseConferenceCommand>()), Times.Once);
AzureStorageServiceMock.Verify(x => x.GetAllBlobNamesByFilePathPrefix(It.IsAny <string>()), Times.Once);
AudioPlatformServiceMock.Verify(v => v.DeleteAudioApplicationAsync(It.IsAny <Guid>()), Times.Never);
}
public async Task Should_get_heartbeatResponses()
{
var conferenceId = TestConference.Id;
var participantId = TestConference.GetParticipants()[1].Id;
var result = await Controller.GetHeartbeatDataForParticipantAsync(conferenceId, participantId);
MockQueryHandler.Verify(m => m.Handle <GetHeartbeatsFromTimePointQuery, IList <Heartbeat> >(It.IsAny <GetHeartbeatsFromTimePointQuery>()), Times.Once);
result.Should().NotBeNull();
result.Should().BeAssignableTo <OkObjectResult>();
var responses = result.As <OkObjectResult>().Value.As <IEnumerable <ParticipantHeartbeatResponse> >().ToList();
responses.Should().NotBeNull().And.NotBeEmpty().And.NotContainNulls();
var heartbeatResponse = responses.First().As <ParticipantHeartbeatResponse>();
heartbeatResponse.BrowserName.Should().Be("chrome");
heartbeatResponse.BrowserVersion.Should().Be("1");
heartbeatResponse.RecentPacketLoss.Should().Be(8);
heartbeatResponse.OperatingSystem.Should().Be("Mac OS X");
heartbeatResponse.OperatingSystemVersion.Should().Be("10.15.7");
}
