public async Task UpdateStatus_ConnectedEquipment_UpdateSynchronizedObject()
{
// arrange
var testMic = new EquipmentDevice("mic1", "Microphone", DeviceType.Mic);
var testDevices = new List <EquipmentDevice> {
testMic
};
var(user, equipmentHub) = await ConnectEquipment(testDevices);
var update = new Dictionary <ProducerSource, UseMediaStateInfo>
{
{ ProducerSource.Mic, new UseMediaStateInfo(true, true, false, null) }
};
// act
await equipmentHub.InvokeAsync(nameof(EquipmentHub.UpdateStatus), update);
// assert
await user.SyncObjects.AssertSyncObject <SynchronizedEquipment>(
SynchronizedEquipment.SyncObjId(user.User.Sub), syncObj =>
{
var connection = Assert.Single(syncObj.Connections).Value;
Assert.Equal(update, connection.Status);
});
}
public async Task Handle(EquipmentDisconnectedNotification notification, CancellationToken cancellationToken)
{
await _repository.RemoveConnection(notification.Participant, notification.ConnectionId);
await _mediator.Send(new UpdateSynchronizedObjectRequest(notification.Participant.ConferenceId,
SynchronizedEquipment.SyncObjId(notification.Participant.Id)));
}
public async Task InitializeEquipment_MultipleDevicesSameId_UpdateSynchronizedObject()
{
// arrange
var testMic = new EquipmentDevice("mic1", "Microphone", DeviceType.Mic);
var testMic2 = new EquipmentDevice("mic1", "Webcam", DeviceType.Webcam);
var testDevices = new List <EquipmentDevice> {
testMic, testMic2
};
var(user, _) = await ConnectEquipment(testDevices);
// assert
await user.SyncObjects.AssertSyncObject <SynchronizedEquipment>(
SynchronizedEquipment.SyncObjId(user.User.Sub), syncEquipment =>
{
var connection = Assert.Single(syncEquipment.Connections);
AssertHelper.AssertScrambledEquals(testDevices, connection.Value.Devices);
});
}
public async Task Disconnect_EquipmentConnected_RemoveFromSynchronizedObject()
{
// arrange
var testDevices = Array.Empty <EquipmentDevice>();
var(user, equipmentHub) = await ConnectEquipment(testDevices);
await user.SyncObjects.AssertSyncObject <SynchronizedEquipment>(
SynchronizedEquipment.SyncObjId(user.User.Sub),
syncEquipment => { Assert.Single(syncEquipment.Connections); });
// act
await equipmentHub.DisposeAsync();
// assert
await user.SyncObjects.AssertSyncObject <SynchronizedEquipment>(
SynchronizedEquipment.SyncObjId(user.User.Sub),
syncEquipment => { Assert.Empty(syncEquipment.Connections); });
}
public async Task <Unit> Handle(InitializeEquipmentRequest request, CancellationToken cancellationToken)
{
var connection = new EquipmentConnection(request.ConnectionId, request.Name, request.Devices,
ImmutableDictionary <ProducerSource, UseMediaStateInfo> .Empty);
await _repository.SetConnection(request.Participant, connection);
var isJoined = await _mediator.Send(new CheckIsParticipantJoinedRequest(request.Participant));
if (!isJoined)
{
await _repository.RemoveConnection(request.Participant, connection.ConnectionId);
throw EquipmentError.ParticipantNotJoined.ToException();
}
await _mediator.Send(new UpdateSynchronizedObjectRequest(request.Participant.ConferenceId,
SynchronizedEquipment.SyncObjId(request.Participant.Id)));
return(Unit.Value);
}
public async Task InitializeEquipment_WithValidToken_UpdateSynchronizedObject()
{
// arrange
var testMic = new EquipmentDevice("mic1", "Microphone", DeviceType.Mic);
var testDevices = new List <EquipmentDevice> {
testMic
};
var(user, _) = await ConnectEquipment(testDevices);
// assert
await user.SyncObjects.AssertSyncObject <SynchronizedEquipment>(
SynchronizedEquipment.SyncObjId(user.User.Sub), syncEquipment =>
{
var connection = Assert.Single(syncEquipment.Connections);
Assert.Equal(EquipmentName, connection.Value.Name);
Assert.Empty(connection.Value.Status);
var actualDevice = Assert.Single(connection.Value.Devices);
Assert.Equal(testMic, actualDevice);
});
}
public async Task <Unit> Handle(UpdateStatusRequest request, CancellationToken cancellationToken)
{
var(participant, connectionId, status) = request;
var connection = await _repository.GetConnection(participant, connectionId);
if (connection == null)
{
throw EquipmentError.NotInitialized.ToException();
}
var updatedConnection = connection with {
Status = status
};
await _repository.SetConnection(participant, updatedConnection);
await _mediator.Send(new UpdateSynchronizedObjectRequest(participant.ConferenceId,
SynchronizedEquipment.SyncObjId(participant.Id)));
return(Unit.Value);
}
}
