public void It_Should_Create_A_Chime_Meeting()
{
// Setup Mocks ============================================
var user = new User()
{
id = Guid.NewGuid(), room = new Room()
{
identifier = Guid.NewGuid()
}
};
var unitOfWork = new Mock <IUnitOfWork>();
unitOfWork.Setup(x => x.Save()).Returns(Task.CompletedTask);
var userRepository = new Mock <IUserRepository>();
userRepository.Setup(x => x.FindById(It.IsAny <Guid>())).Returns(Task.FromResult(user));
// ========================================================
var request = new CreateChimeMeetingRequest();
request.userIdentifier = user.id;
var service = new ChimeService(unitOfWork.Object, userRepository.Object);
Task <CreateChimeMeetingResponse> response = service.CreateChimeMeeting(request);
Assert.IsInstanceOfType(response.Result, typeof(CreateChimeMeetingResponse));
Assert.IsNull(response.Result.error);
Assert.IsInstanceOfType(response.Result.attendeeResponse, typeof(Amazon.Chime.Model.CreateAttendeeResponse));
Assert.IsInstanceOfType(response.Result.meetingResponse, typeof(Amazon.Chime.Model.CreateMeetingResponse));
}
public void Create_Chime_Meeting_Should_Return_Error_When_User_Is_Null()
{
// Setup Mocks ============================================
var unitOfWork = new Mock <IUnitOfWork>();
unitOfWork.Setup(x => x.Save()).Returns(Task.CompletedTask);
var userRepository = new Mock <IUserRepository>();
userRepository.Setup(x => x.FindById(It.IsAny <Guid>())).Returns(Task.FromResult <User>(null));
// ========================================================
var request = new CreateChimeMeetingRequest();
request.userIdentifier = Guid.NewGuid();
var service = new ChimeService(unitOfWork.Object, userRepository.Object);
try
{
Task <CreateChimeMeetingResponse> response = service.CreateChimeMeeting(request);
}
catch (Exception e)
{
Assert.IsInstanceOfType(e, typeof(ApplicationError));
}
}
public async Task CreateChimeMeeting(CreateChimeMeetingRequest request)
{
try
{
var ctx = new ValidationContext(request);
var results = new List <ValidationResult>();
Validator.TryValidateObject(request, ctx, results, true);
if (results.Count > 0)
{
throw new ApplicationError("[CreateChimeMeeting]", 4);
}
var response = await _chimeService.CreateChimeMeeting(request);
await Clients.Caller.ChimeMeetingCreated(response);
}
catch (Exception e)
{
var errorResponse = ApplicationError.GetError <CreateChimeMeetingResponse>(e, "[CreateChimeMeeting]");
_logger.LogError(e.Message);
await Clients.Caller.ChimeMeetingCreated(errorResponse);
}
}
/**
* Create a new chime meeting.
* This video conference can be joined by others,
* if they have the creator's meetingId
*/
public async Task <CreateChimeMeetingResponse> CreateChimeMeeting(CreateChimeMeetingRequest payload)
{
try
{
var response = new CreateChimeMeetingResponse();
MyChat.Domain.Model.User user = await _userRepository.FindById((Guid)payload.userIdentifier);
if (user == null)
{
throw new ApplicationError("CreateChimeMeeting.CreateChimeMeeting]", 1);
}
//TODO: interface this so our domain doesn't depend on an external service.
var meetingResponse = await chime.CreateMeetingAsync(
new CreateMeetingRequest()
{
ClientRequestToken = Guid.NewGuid().ToString(),
MediaRegion = "eu-west-2"
});
var attendeeResponse = await chime.CreateAttendeeAsync(
new CreateAttendeeRequest()
{
MeetingId = meetingResponse.Meeting.MeetingId,
ExternalUserId = user.id.ToString()
});
response.meetingResponse = meetingResponse;
response.attendeeResponse = attendeeResponse;
return(response);
}
catch (Exception e)
{
throw e;
}
}
