public async Task <Unit> Handle(TalkingStickPassRequest request, CancellationToken cancellationToken) { var(participant, roomId, failIfHasSpeaker) = request; await using (await _repository.LockRoom(participant.ConferenceId, roomId)) { await _mediator.Send(new ClearCacheRequest()); if (failIfHasSpeaker) { var currentSpeaker = await _repository.GetCurrentSpeaker(participant.ConferenceId, roomId); if (currentSpeaker != null) { throw SceneError.AlreadyHasSpeaker.ToException(); } } if (!await CheckParticipantIsInRoom(participant, roomId)) { throw new ParticipantNotFoundException(participant); } await _repository.SetCurrentSpeakerAndRemoveFromQueue(participant, roomId); await _modeHandler.InvalidateTalkingSceneWithLockAcquired(participant.ConferenceId, roomId); } await _mediator.Send(new UpdateSynchronizedObjectRequest(participant.ConferenceId, SynchronizedSceneTalkingStick.SyncObjId(roomId))); return(Unit.Value); }
public async Task TalkingStick_Queue_Enqueue_MakePresenter() { // arrange var(conn, conference) = await ConnectToOpenedConference(); AssertSuccess(await conn.Hub.InvokeAsync <SuccessOrError <Unit> >(nameof(CoreHub.SetScene), new TalkingStickScene(TalkingStickMode.Queue))); var pleb = CreateUser(); var plebConn = await ConnectUserToConference(pleb, conference); // act AssertSuccess(await plebConn.Hub.InvokeAsync <SuccessOrError <Unit> >(nameof(CoreHub.TalkingStickEnqueue))); // assert await conn.SyncObjects.AssertSyncObject <SynchronizedScene>( SynchronizedScene.SyncObjId(RoomOptions.DEFAULT_ROOM_ID), syncObj => { Assert.Equal(syncObj.SceneStack, new IScene[] { new TalkingStickScene(TalkingStickMode.Queue), new PresenterScene(pleb.Sub), new ActiveSpeakerScene(), }); }); await conn.SyncObjects.AssertSyncObject <SynchronizedSceneTalkingStick>( SynchronizedSceneTalkingStick.SyncObjId(RoomOptions.DEFAULT_ROOM_ID), syncObj => { Assert.Equal(pleb.Sub, syncObj.CurrentSpeakerId); Assert.Empty(syncObj.SpeakerQueue); }); }
public async Task TalkingStick_Moderated_Dequeue_RemoveFromQueue() { // arrange var(conn, conference) = await ConnectToOpenedConference(); AssertSuccess(await conn.Hub.InvokeAsync <SuccessOrError <Unit> >(nameof(CoreHub.SetScene), new TalkingStickScene(TalkingStickMode.Moderated))); var pleb = CreateUser(); var plebConn = await ConnectUserToConference(pleb, conference); AssertSuccess(await plebConn.Hub.InvokeAsync <SuccessOrError <Unit> >(nameof(CoreHub.TalkingStickEnqueue))); await conn.SyncObjects.AssertSyncObject <SynchronizedSceneTalkingStick>( SynchronizedSceneTalkingStick.SyncObjId(RoomOptions.DEFAULT_ROOM_ID), syncObj => { Assert.Null(syncObj.CurrentSpeakerId); Assert.Single(syncObj.SpeakerQueue, pleb.Sub); }); // act AssertSuccess(await plebConn.Hub.InvokeAsync <SuccessOrError <Unit> >(nameof(CoreHub.TalkingStickDequeue))); // assert await conn.SyncObjects.AssertSyncObject <SynchronizedSceneTalkingStick>( SynchronizedSceneTalkingStick.SyncObjId(RoomOptions.DEFAULT_ROOM_ID), syncObj => { Assert.Empty(syncObj.SpeakerQueue); }); }
public async Task <Unit> Handle(TalkingStickReturnRequest request, CancellationToken cancellationToken) { var participant = request.Participant; var rooms = await _mediator.FetchSynchronizedObject <SynchronizedRooms>(participant.ConferenceId, SynchronizedRooms.SyncObjId); if (!rooms.Participants.TryGetValue(participant.Id, out var roomId)) { throw SceneError.RoomNotFound.ToException(); } await using (await _repository.LockRoom(participant.ConferenceId, roomId)) { var currentSpeaker = await _repository.GetCurrentSpeaker(participant.ConferenceId, roomId); if (currentSpeaker != null && currentSpeaker.Value.Equals(participant)) { await _repository.RemoveCurrentSpeaker(currentSpeaker.Value.ConferenceId, roomId); await _modeHandler.InvalidateTalkingSceneWithLockAcquired(currentSpeaker.Value.ConferenceId, roomId); } else { return(Unit.Value); } } await _mediator.Send(new UpdateSynchronizedObjectRequest(participant.ConferenceId, SynchronizedSceneTalkingStick.SyncObjId(roomId))); return(Unit.Value); }
public async Task TalkingStick_Moderated_PassToParticipant_MakePresenter() { // arrange var(conn, conference) = await ConnectToOpenedConference(); AssertSuccess(await conn.Hub.InvokeAsync <SuccessOrError <Unit> >(nameof(CoreHub.SetScene), new TalkingStickScene(TalkingStickMode.Moderated))); var pleb = CreateUser(); await ConnectUserToConference(pleb, conference); await conn.SyncObjects.AssertSyncObject <SynchronizedRooms>(SynchronizedRooms.SyncObjId, participants => Assert.Equal(2, participants.Participants.Count)); // act AssertSuccess(await conn.Hub.InvokeAsync <SuccessOrError <Unit> >(nameof(CoreHub.TalkingStickPass), pleb.Sub)); // assert await conn.SyncObjects.AssertSyncObject <SynchronizedScene>( SynchronizedScene.SyncObjId(RoomOptions.DEFAULT_ROOM_ID), syncObj => { Assert.Equal(syncObj.SceneStack, new IScene[] { new TalkingStickScene(TalkingStickMode.Moderated), new PresenterScene(pleb.Sub), new ActiveSpeakerScene(), }); }); await conn.SyncObjects.AssertSyncObject <SynchronizedSceneTalkingStick>( SynchronizedSceneTalkingStick.SyncObjId(RoomOptions.DEFAULT_ROOM_ID), syncObj => { Assert.Equal(pleb.Sub, syncObj.CurrentSpeakerId); }); }
public async Task Handle(ParticipantsRoomChangedNotification notification, CancellationToken cancellationToken) { var updatedRooms = GetRoomsWithAParticipantLeft(notification); foreach (var updatedRoom in updatedRooms) { await using (await _repository.LockRoom(notification.ConferenceId, updatedRoom)) { var participants = GetParticipantsThatLeftRoom(notification, updatedRoom); await _repository.RemoveFromQueue(participants, updatedRoom); await _modeHandler.InvalidateTalkingSceneWithLockAcquired(notification.ConferenceId, updatedRoom); } await _mediator.Send(new UpdateSynchronizedObjectRequest(notification.ConferenceId, SynchronizedSceneTalkingStick.SyncObjId(updatedRoom))); } }
public async Task <Unit> Handle(TalkingStickEnqueueRequest request, CancellationToken cancellationToken) { var(participant, remove) = request; var rooms = await _mediator.FetchSynchronizedObject <SynchronizedRooms>(participant.ConferenceId, SynchronizedRooms.SyncObjId); if (!rooms.Participants.TryGetValue(participant.Id, out var roomId)) { throw SceneError.RoomNotFound.ToException(); } await using (await _repository.LockRoom(participant.ConferenceId, roomId)) { await _mediator.Send(new ClearCacheRequest()); if (!await CheckParticipantIsInRoom(participant, roomId)) { throw new ConcurrencyException("Participant switched room."); } if (remove) { await _repository.RemoveFromQueue(participant.Yield(), roomId); } else { var queue = await _repository.FetchQueue(participant.ConferenceId, roomId); if (!queue.Contains(participant.Id)) { await _repository.Enqueue(participant, roomId); } await _modeHandler.InvalidateTalkingSceneWithLockAcquired(participant.ConferenceId, roomId); } } await _mediator.Send(new UpdateSynchronizedObjectRequest(participant.ConferenceId, SynchronizedSceneTalkingStick.SyncObjId(roomId))); return(Unit.Value); }
private async ValueTask <SynchronizedSceneTalkingStick> GetSyncObj(string conferenceId, string roomId) { return(await _mediator.FetchSynchronizedObject <SynchronizedSceneTalkingStick>(conferenceId, SynchronizedSceneTalkingStick.SyncObjId(roomId))); }
public async Task ReturnStick_NoQueueMode_RemovePresenter() { // arrange var participant = await PrepareTalkingStick(TalkingStickMode.Moderated); await Mediator.Send(new TalkingStickPassRequest(participant, DefaultRoomId, true)); // act await Mediator.Send(new TalkingStickReturnRequest(participant)); // assert var talkingStick = SynchronizedObjectListener.GetSynchronizedObject <SynchronizedSceneTalkingStick>(participant, SynchronizedSceneTalkingStick.SyncObjId(DefaultRoomId)); Assert.Null(talkingStick.CurrentSpeakerId); AssertSceneStack(participant, new TalkingStickScene(TalkingStickMode.Moderated)); }
public async Task EnqueueRequest_NoQueueMode_StayInQueue() { // arrange var participant = await PrepareTalkingStick(TalkingStickMode.Moderated); // act await Mediator.Send(new TalkingStickEnqueueRequest(participant, false)); // assert var talkingStick = SynchronizedObjectListener.GetSynchronizedObject <SynchronizedSceneTalkingStick>(participant, SynchronizedSceneTalkingStick.SyncObjId(DefaultRoomId)); Assert.Single(talkingStick.SpeakerQueue, participant.Id); }
public async Task PassTalkingStickRequest_ParticipantWasInQueue_RemoveFromQueue() { // arrange var participant = await PrepareTalkingStick(TalkingStickMode.Moderated); await Mediator.Send(new TalkingStickEnqueueRequest(participant, false)); await Mediator.Send(new TalkingStickPassRequest(participant, DefaultRoomId, true)); // assert var talkingStick = SynchronizedObjectListener.GetSynchronizedObject <SynchronizedSceneTalkingStick>(participant, SynchronizedSceneTalkingStick.SyncObjId(DefaultRoomId)); Assert.Empty(talkingStick.SpeakerQueue); }
public async Task PassTalkingStickRequestWithFailFlag_HasPresenter_ThrowError() { // arrange var participant = await PrepareTalkingStick(TalkingStickMode.Moderated); await Mediator.Send(new TalkingStickPassRequest(participant, DefaultRoomId, true)); await JoinParticipant(TestData.Vincent); var participant2 = TestData.Vincent.Participant; // act await Assert.ThrowsAsync <IdErrorException>(async() => await Mediator.Send(new TalkingStickPassRequest(participant2, DefaultRoomId, true))); // assert var talkingStick = SynchronizedObjectListener.GetSynchronizedObject <SynchronizedSceneTalkingStick>(participant, SynchronizedSceneTalkingStick.SyncObjId(DefaultRoomId)); Assert.Equal(participant.Id, talkingStick.CurrentSpeakerId); }
public async Task PassTalkingStickRequest_HasPresenter_ReplacePresenter() { // arrange var participant = await PrepareTalkingStick(TalkingStickMode.Moderated); await Mediator.Send(new TalkingStickPassRequest(participant, DefaultRoomId, true)); await JoinParticipant(TestData.Vincent); var participant2 = TestData.Vincent.Participant; // act await Mediator.Send(new TalkingStickPassRequest(participant2, DefaultRoomId, false)); // assert var talkingStick = SynchronizedObjectListener.GetSynchronizedObject <SynchronizedSceneTalkingStick>(participant, SynchronizedSceneTalkingStick.SyncObjId(DefaultRoomId)); Assert.Equal(participant2.Id, talkingStick.CurrentSpeakerId); Assert.Empty(talkingStick.SpeakerQueue); AssertSceneStack(participant2, SceneStackWithPresenter(TalkingStickMode.Moderated, participant2.Id)); }
public async Task Queue_ReturnStick_NonEmptyQueue_SetNewPresenter() { // arrange var participant = await PrepareTalkingStick(TalkingStickMode.Queue); await Mediator.Send(new TalkingStickEnqueueRequest(participant, false)); await JoinParticipant(TestData.Vincent); var participant2 = TestData.Vincent.Participant; await Mediator.Send(new TalkingStickEnqueueRequest(participant2, false)); // act await Mediator.Send(new TalkingStickReturnRequest(participant)); // assert var talkingStick = SynchronizedObjectListener.GetSynchronizedObject <SynchronizedSceneTalkingStick>(participant, SynchronizedSceneTalkingStick.SyncObjId(DefaultRoomId)); Assert.Equal(participant2.Id, talkingStick.CurrentSpeakerId); Assert.Empty(talkingStick.SpeakerQueue); AssertSceneStack(participant, SceneStackWithPresenter(TalkingStickMode.Queue, participant2.Id)); }
public async Task Queue_DequeueRequest_HasPresenter_RemoveFromQueue() { // arrange var participant = await PrepareTalkingStick(TalkingStickMode.Queue); await Mediator.Send(new TalkingStickEnqueueRequest(participant, false)); await JoinParticipant(TestData.Vincent); var participant2 = TestData.Vincent.Participant; await Mediator.Send(new TalkingStickEnqueueRequest(participant2, false)); // act await Mediator.Send(new TalkingStickEnqueueRequest(participant2, true)); // assert var talkingStick = SynchronizedObjectListener.GetSynchronizedObject <SynchronizedSceneTalkingStick>(participant, SynchronizedSceneTalkingStick.SyncObjId(DefaultRoomId)); Assert.Equal(participant.Id, talkingStick.CurrentSpeakerId); Assert.Empty(talkingStick.SpeakerQueue); }
public async Task Queue_EnqueueRequest_NoPresenter_MakeParticipantPresenter() { // arrange var participant = await PrepareTalkingStick(TalkingStickMode.Queue); // act await Mediator.Send(new TalkingStickEnqueueRequest(participant, false)); // assert var talkingStick = SynchronizedObjectListener.GetSynchronizedObject <SynchronizedSceneTalkingStick>(participant, SynchronizedSceneTalkingStick.SyncObjId(DefaultRoomId)); Assert.Equal(participant.Id, talkingStick.CurrentSpeakerId); Assert.Empty(talkingStick.SpeakerQueue); AssertSceneStack(participant, SceneStackWithPresenter(TalkingStickMode.Queue, participant.Id)); }