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);
}
