public async Task TalkingStick_Race_ParticipantsTakeStick_MakePresenter() { // arrange var(conn, conference) = await ConnectToOpenedConference(); AssertSuccess(await conn.Hub.InvokeAsync <SuccessOrError <Unit> >(nameof(CoreHub.SetScene), new TalkingStickScene(TalkingStickMode.Race))); var pleb = CreateUser(); var plebConn = await ConnectUserToConference(pleb, conference); // act AssertSuccess(await plebConn.Hub.InvokeAsync <SuccessOrError <Unit> >(nameof(CoreHub.TalkingStickTake))); // assert await conn.SyncObjects.AssertSyncObject <SynchronizedScene>( SynchronizedScene.SyncObjId(RoomOptions.DEFAULT_ROOM_ID), syncObj => { Assert.Equal(syncObj.SceneStack, new IScene[] { new TalkingStickScene(TalkingStickMode.Race), new PresenterScene(pleb.Sub), new ActiveSpeakerScene(), }); }); await plebConn.SyncObjects.AssertSyncObject <SynchronizedParticipantPermissions>( SynchronizedParticipantPermissions.SyncObjId(pleb.Sub), permissions => { Assert.Contains(permissions.Permissions, x => Equals(x, DefinedPermissions.Scenes.CanOverwriteContentScene.Configure(true))); }); }
public async Task TalkingStick_Race_PresenterLeaves_RemoveScene() { // arrange var(conn, conference) = await ConnectToOpenedConference(); AssertSuccess(await conn.Hub.InvokeAsync <SuccessOrError <Unit> >(nameof(CoreHub.SetScene), new TalkingStickScene(TalkingStickMode.Race))); var pleb = CreateUser(); var plebConn = await ConnectUserToConference(pleb, conference); AssertSuccess(await plebConn.Hub.InvokeAsync <SuccessOrError <Unit> >(nameof(CoreHub.TalkingStickTake))); await conn.SyncObjects.AssertSyncObject <SynchronizedScene>( SynchronizedScene.SyncObjId(RoomOptions.DEFAULT_ROOM_ID), syncObj => { Assert.Equal(syncObj.SceneStack, new IScene[] { new TalkingStickScene(TalkingStickMode.Race), new PresenterScene(pleb.Sub), new ActiveSpeakerScene(), }); }); // act await plebConn.Hub.DisposeAsync(); // assert await conn.SyncObjects.AssertSyncObject <SynchronizedScene>( SynchronizedScene.SyncObjId(RoomOptions.DEFAULT_ROOM_ID), syncObj => { Assert.Equal(syncObj.SceneStack, new IScene[] { new TalkingStickScene(TalkingStickMode.Race), }); }); }
public async ValueTask <IEnumerable <PermissionLayer> > FetchPermissionsForParticipant(Participant participant) { var rooms = await _mediator.FetchSynchronizedObject <SynchronizedRooms>(participant.ConferenceId, SynchronizedRooms.SyncObjId); if (!rooms.Participants.TryGetValue(participant.Id, out var roomId)) { return(Enumerable.Empty <PermissionLayer>()); } var permissions = new List <PermissionLayer>(); var scenes = await _mediator.FetchSynchronizedObject <SynchronizedScene>(participant.ConferenceId, SynchronizedScene.SyncObjId(roomId)); foreach (var scene in scenes.SceneStack) { var provider = FindProviderForScene(scene); var sceneLayers = await provider.FetchPermissionsForParticipant(scene, participant, scenes.SceneStack); permissions.AddRange(sceneLayers); } return(permissions); }
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_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 ValueTask InvalidateTalkingSceneWithLockAcquired(string conferenceId, string roomId) { var scenes = await _mediator.FetchSynchronizedObject <SynchronizedScene>(conferenceId, SynchronizedScene.SyncObjId(roomId)); var talkingStickScene = GetTalkingStickScene(scenes); if (talkingStickScene == null) { return; } var rooms = await _mediator.FetchSynchronizedObject <SynchronizedRooms>(conferenceId, SynchronizedRooms.SyncObjId); var currentSpeaker = await _repository.GetCurrentSpeaker(conferenceId, roomId); currentSpeaker = await VerifyCurrentSpeakerInRoom(currentSpeaker, roomId, rooms); if (currentSpeaker == null) { await ElectNewCurrentSpeaker(conferenceId, roomId, rooms, talkingStickScene.Mode); } }
public async Task JoinToRoom_DoNothing_SynchronizeAvailableScenes() { // arrange var(conn, _) = await ConnectToOpenedConference(); // assert await conn.SyncObjects.AssertSyncObject <SynchronizedScene>( SynchronizedScene.SyncObjId(RoomOptions.DEFAULT_ROOM_ID), syncObj => { Assert.NotEmpty(syncObj.AvailableScenes); Assert.Equal(AutonomousScene.Instance, syncObj.SelectedScene); Assert.Equal(DefaultSceneStack, syncObj.SceneStack); }); }
public async Task SetScene_MakePresenter_UpdateSceneStack() { // arrange var(conn, _) = await ConnectToOpenedConference(); // act await conn.Hub.InvokeAsync <SuccessOrError <Unit> >(nameof(CoreHub.SetScene), new PresenterScene(conn.User.Sub)); // assert await conn.SyncObjects.AssertSyncObject <SynchronizedScene>( SynchronizedScene.SyncObjId(RoomOptions.DEFAULT_ROOM_ID), syncObj => Assert.Equal(new IScene[] { new PresenterScene(conn.User.Sub), ActiveSpeakerScene.Instance }, syncObj.SceneStack)); }
public async Task OpenBreakoutRooms_Joined_BreakoutRoomSceneBecomesAvailable() { // arrange var(conn, _) = await ConnectToOpenedConference(); await conn.SyncObjects.AssertSyncObject(SynchronizedScene.SyncObjId(RoomOptions.DEFAULT_ROOM_ID), (SynchronizedScene syncObj) => Assert.DoesNotContain(syncObj.AvailableScenes, x => x is BreakoutRoomScene)); // act AssertSuccess(await conn.Hub.InvokeAsync <SuccessOrError <Unit> >(nameof(CoreHub.OpenBreakoutRooms), new OpenBreakoutRoomsDto(5, null, null, null))); // assert await conn.SyncObjects.AssertSyncObject <SynchronizedScene>( SynchronizedScene.SyncObjId(RoomOptions.DEFAULT_ROOM_ID), syncObj => Assert.Contains(syncObj.AvailableScenes, x => x is BreakoutRoomScene)); }
public async Task SetScene_SceneIsAvailable_UpdateSynchronizedObject() { // arrange var(conn, _) = await ConnectToOpenedConference(); // act var result = await conn.Hub.InvokeAsync <SuccessOrError <Unit> >(nameof(CoreHub.SetScene), GridScene.Instance); // assert AssertSuccess(result); await conn.SyncObjects.AssertSyncObject <SynchronizedScene>( SynchronizedScene.SyncObjId(RoomOptions.DEFAULT_ROOM_ID), syncObj => { Assert.Equal(GridScene.Instance, syncObj.SelectedScene); Assert.Single(syncObj.SceneStack, GridScene.Instance); }); }
public async Task SetScene_SceneIsNotAvailable_DontChangeCurrentScene() { // arrange var(conn, _) = await ConnectToOpenedConference(); var current = await conn.SyncObjects.WaitForSyncObj <SynchronizedScene>( SynchronizedScene.SyncObjId(RoomOptions.DEFAULT_ROOM_ID)); // act await conn.Hub.InvokeAsync <SuccessOrError <Unit> >(nameof(CoreHub.SetScene), new ScreenShareScene("5342")); // assert await conn.SyncObjects.AssertSyncObject <SynchronizedScene>( SynchronizedScene.SyncObjId(RoomOptions.DEFAULT_ROOM_ID), syncObj => Assert.Equal(current.SceneStack, syncObj.SceneStack)); }
public async Task SetOverwrittenScene_SceneIsNotAvailable_DontSetScene() { // arrange var(conn, _) = await ConnectToOpenedConference(); // act var result = await conn.Hub.InvokeAsync <SuccessOrError <Unit> >(nameof(CoreHub.SetOverwrittenScene), new ScreenShareScene("1235")); // assert AssertSuccess(result); await conn.SyncObjects.AssertSyncObject <SynchronizedScene>( SynchronizedScene.SyncObjId(RoomOptions.DEFAULT_ROOM_ID), syncObj => { Assert.Null(syncObj.OverwrittenContent); Assert.Equal(syncObj.SceneStack, DefaultSceneStack); }); }
public async Task <Unit> Handle(UpdateScenesRequest request, CancellationToken cancellationToken) { var(conferenceId, roomId) = request; await using (await _sceneRepository.LockScene(conferenceId, roomId)) { var scene = await _sceneRepository.GetScene(conferenceId, roomId); scene ??= SynchronizedSceneProvider.GetDefaultActiveScene(); var state = await _sceneRepository.GetSceneState(conferenceId, roomId); state ??= SynchronizedSceneProvider.GetEmptySceneState(); await ApplyScene(conferenceId, roomId, scene, state); } await _mediator.Send( new UpdateSynchronizedObjectRequest(conferenceId, SynchronizedScene.SyncObjId(roomId))); return(Unit.Value); }
public async Task CloseBreakoutRooms_BreakoutRoomIsCurrentScene_RemoveCurrentScene() { // arrange var(conn, _) = await ConnectToOpenedConference(); // act AssertSuccess(await conn.Hub.InvokeAsync <SuccessOrError <Unit> >(nameof(CoreHub.OpenBreakoutRooms), new OpenBreakoutRoomsDto(5, null, null, null))); AssertSuccess( await conn.Hub.InvokeAsync <SuccessOrError <Unit> >(nameof(CoreHub.SetScene), BreakoutRoomScene.Instance)); await conn.SyncObjects.AssertSyncObject <SynchronizedScene>( SynchronizedScene.SyncObjId(RoomOptions.DEFAULT_ROOM_ID), syncObj => Assert.Equal(BreakoutRoomScene.Instance, syncObj.SelectedScene)); AssertSuccess(await conn.Hub.InvokeAsync <SuccessOrError <Unit> >(nameof(CoreHub.CloseBreakoutRooms))); // assert await conn.SyncObjects.AssertSyncObject <SynchronizedScene>( SynchronizedScene.SyncObjId(RoomOptions.DEFAULT_ROOM_ID), syncObj => Assert.Equal(AutonomousScene.Instance, syncObj.SelectedScene)); }
public async Task SetOverwrittenContentSceneRequest_ValidScene_UpdateSynchronizedObject() { // arrange await Mediator.Send(new OpenConferenceRequest(ConferenceId)); await JoinParticipant(TestData.Sven); var scene = ActiveSpeakerScene.Instance; // act await Mediator.Send(new SetOverwrittenContentSceneRequest(ConferenceId, DefaultRoomId, scene)); // assert var scenes = SynchronizedObjectListener.GetSynchronizedObject <SynchronizedScene>(TestData.Sven.Participant, SynchronizedScene.SyncObjId(DefaultRoomId)); Assert.Equal(DefaultSceneStack.Concat(new[] { ActiveSpeakerScene.Instance }), scenes.SceneStack); Assert.Equal(scene, scenes.OverwrittenContent); }
public async Task JoinRoom_DoNothing_HasSceneStack() { // arrange await Mediator.Send(new OpenConferenceRequest(ConferenceId)); // act await JoinParticipant(TestData.Sven); // assert var scenes = SynchronizedObjectListener.GetSynchronizedObject <SynchronizedScene>(TestData.Sven.Participant, SynchronizedScene.SyncObjId(DefaultRoomId)); Assert.Equal(SynchronizedSceneProvider.GetDefaultScene(), scenes.SelectedScene); Assert.Equal(DefaultSceneStack, scenes.SceneStack); Assert.Null(scenes.OverwrittenContent); Assert.NotNull(scenes.AvailableScenes); }
public async Task SetSceneRequest_BreakoutRoomsClosed_RevertToOverwrittenScene() { // arrange await Mediator.Send(new OpenConferenceRequest(ConferenceId)); await JoinParticipant(TestData.Sven); await Mediator.Send(new OpenBreakoutRoomsRequest(5, null, null, null, ConferenceId)); await Mediator.Send(new SetSceneRequest(ConferenceId, DefaultRoomId, BreakoutRoomScene.Instance)); await Mediator.Send(new SetOverwrittenContentSceneRequest(ConferenceId, DefaultRoomId, GridScene.Instance)); var scenes = SynchronizedObjectListener.GetSynchronizedObject <SynchronizedScene>(TestData.Sven.Participant, SynchronizedScene.SyncObjId(DefaultRoomId)); Assert.Equal(new IScene[] { BreakoutRoomScene.Instance, GridScene.Instance }, scenes.SceneStack); // act await Mediator.Send(new CloseBreakoutRoomsRequest(ConferenceId)); // assert scenes = SynchronizedObjectListener.GetSynchronizedObject <SynchronizedScene>(TestData.Sven.Participant, SynchronizedScene.SyncObjId(DefaultRoomId)); Assert.Equal(GridScene.Instance, scenes.SelectedScene); Assert.Null(scenes.OverwrittenContent); Assert.Equal(new IScene[] { GridScene.Instance }, scenes.SceneStack); }
public async Task ConferenceChanged_DefaultSceneSelected_UpdateSynchronizedObject() { // arrange await Mediator.Send(new OpenConferenceRequest(ConferenceId)); await JoinParticipant(TestData.Sven); var scenes = SynchronizedObjectListener.GetSynchronizedObject <SynchronizedScene>(TestData.Sven.Participant, SynchronizedScene.SyncObjId(DefaultRoomId)); Assert.Equal(DefaultSceneStack, scenes.SceneStack); // act var patchResult = await Mediator.Send(new PatchConferenceRequest(ConferenceId, new JsonPatchDocument <ConferenceData>().Add(x => x.Configuration.Scenes.DefaultScene, SceneOptions.BasicSceneType.ActiveSpeaker))); Assert.True(patchResult.Success); // assert scenes = SynchronizedObjectListener.GetSynchronizedObject <SynchronizedScene>(TestData.Sven.Participant, SynchronizedScene.SyncObjId(DefaultRoomId)); Assert.Equal(new IScene[] { AutonomousScene.Instance, ActiveSpeakerScene.Instance }, scenes.SceneStack); }
private void AssertSceneStack(Participant participant, params IScene[] expectedStack) { var scenes = SynchronizedObjectListener.GetSynchronizedObject <SynchronizedScene>(participant, SynchronizedScene.SyncObjId(DefaultRoomId)); Assert.Equal(expectedStack, scenes.SceneStack); }
public async Task SetScene_SetToTalkingStick_UpdateSynchronizedObject() { // arrange await Mediator.Send(new OpenConferenceRequest(ConferenceId)); await JoinParticipant(TestData.Sven); var talkingStickScene = new TalkingStickScene(TalkingStickMode.Queue); // act await Mediator.Send(new SetSceneRequest(ConferenceId, DefaultRoomId, talkingStickScene)); // assert var scenes = SynchronizedObjectListener.GetSynchronizedObject <SynchronizedScene>(TestData.Sven.Participant, SynchronizedScene.SyncObjId(DefaultRoomId)); Assert.Equal(talkingStickScene, scenes.SelectedScene); Assert.Equal(new[] { talkingStickScene }, scenes.SceneStack); }
public async Task SetSceneRequest_InvalidScene_UpdateSynchronizedObject() { // arrange await Mediator.Send(new OpenConferenceRequest(ConferenceId)); await JoinParticipant(TestData.Sven); var scene = new ScreenShareScene("some participant"); // act await Mediator.Send(new SetSceneRequest(ConferenceId, DefaultRoomId, scene)); // assert var scenes = SynchronizedObjectListener.GetSynchronizedObject <SynchronizedScene>(TestData.Sven.Participant, SynchronizedScene.SyncObjId(DefaultRoomId)); Assert.Equal(DefaultSceneStack, scenes.SceneStack); }