public async void AddMessageToCapsule(Message[] messages)
{
// Arrange
var messageToAdd = messages[0];
var capsule = new Models.Capsule("Capsule id");
var messageSrvMock = new Mock <IMessageService>();
messageSrvMock.Setup(srv => srv.GetMessageByIdAsync(It.IsAny <int>())).Returns(() => Task <Message> .Run(() => messageToAdd));
var capsuleSrvMock = new Mock <ICapsuleService>();
capsuleSrvMock.Setup(srv => srv.SaveCapsuleAsync(It.IsAny <Capsule>())).Verifiable();
capsuleSrvMock.Setup(srv => srv.GetCapsuleByUserAsync()).Returns(() => Task <Capsule> .Run(() => capsule));
var controller = new CapsuleController(messageService: messageSrvMock.Object, capsuleService: capsuleSrvMock.Object);
// Act
var result = await controller.AddMessageToCapsule(messageId : messageToAdd.Id, returnUrl : null) as RedirectToActionResult;
// Assert
Assert.IsType <RedirectToActionResult>(result);
Assert.Equal("Capsule", result.ControllerName);
Assert.Equal("Index", result.ActionName);
messageSrvMock.Verify(srv => srv.GetMessageByIdAsync(It.IsAny <int>()), Times.Once);
capsuleSrvMock.Verify(srv => srv.GetCapsuleByUserAsync(), Times.Once);
capsuleSrvMock.Verify(srv => srv.SaveCapsuleAsync(It.IsAny <Capsule>()), Times.Once);
}
public async Task <IActionResult> GetCapsuleByUser(string user)
{
IActionResult result = null;
Models.Capsule capsule = null;
try
{
if (string.IsNullOrEmpty(user))
{
return(BadRequest($"The capsule is invalid (null or empty string)"));
}
capsule = await _repository.GetCapsuleByUserAsync(user);
if (capsule != null)
{
result = Ok(capsule);
}
else
{
result = this.CreatedAtRoute(
routeName: "default",
value: await _repository.CreateNewCapsuleAsync(user));
}
return(result);
}
catch (Exception ex)
{
throw new CapsuleDomainException("An error caused an exception", ex);
}
}
public async Task <Models.Capsule> SaveCapsuleAsync(Models.Capsule capsule)
=> await Task <Models.Capsule> .Run(() => {
Models.Capsule capsuleFromSession =
_httpContextAccessor.HttpContext.Session.SetJson <Models.Capsule>(
capsule.Id,
capsule);
return(capsuleFromSession);
});
public async Task ClearAsync()
=> await Task.Run(() => {
var user = _applicationUserService.GetApplicaitonUser();
Models.Capsule capsule = _httpContextAccessor.HttpContext.Session.GetJson <Models.Capsule>(user);
if (capsule != null)
{
_httpContextAccessor.HttpContext.Session.SetJson <Models.Capsule>(
capsule?.Id,
null);
}
});
public async Task <Models.Capsule> GetCapsuleByUserAsync()
=> await Task <Models.Capsule> .Run(() => {
var user = _applicationUserService.GetApplicaitonUser();
Models.Capsule capsule = _httpContextAccessor.HttpContext.Session.GetJson <Models.Capsule>(user);
if (capsule == null)
{
capsule = _httpContextAccessor.HttpContext.Session.SetJson <Models.Capsule>(
user,
new Models.Capsule(user));
}
return(capsule);
});
public async void SaveCapsuleOk(Models.Capsule[] capsules)
{
// Arrange
var mock = new Mock <ICapsuleRepository>();
Models.Capsule capsuleToSave = capsules[0];
mock.Setup(rep => rep.GetCapsuleByUserAsync(It.IsAny <string>())).Returns(Task <Models.Capsule> .Run(() => capsuleToSave));
CapsuleController controller = new CapsuleController(mock.Object);
// Act
OkObjectResult result = await controller.SaveCapsule(capsuleToSave) as OkObjectResult;
// Assert
Assert.Equal((int?)HttpStatusCode.OK, result?.StatusCode);
mock.Verify(rep => rep.SaveCapsuleAsync(It.IsAny <Models.Capsule>()), Times.Once);
}
private IEnumerable <object> GetCapsules()
{
for (int i = 0; i < 5; i++)
{
var capsule = new Models.Capsule($"User {i + 1}");
var messages = new List <Message>();
for (int j = 0; j < 5; j++)
{
messages.Add(
new Message
{
Id = j + 1,
Name = $"Name {j + 1}",
Body = $"Body {j + 1}"
});
}
capsule.Messages = messages;
yield return(capsule);
}
}
public async Task <IActionResult> RemoveFromCapsule(int messageId, string returnUrl)
{
IActionResult result = RedirectToAction("Index", "Capsule", new { returnUrl });
try
{
Models.Capsule capsule = await _capsuleService.GetCapsuleByUserAsync();
Message message = capsule[messageId];
if (message != null)
{
capsule.RemoveMessage(message);
capsule = await _capsuleService.SaveCapsuleAsync(capsule);
}
}
catch (Exception) // (BrokenCircuitException)
{
// Catch error when API is in circuit-opened mode
//HandleBrokenCircuitException();
}
return(result);
}
public async Task <IActionResult> SaveCapsule([FromBody] Models.Capsule capsule)
{
IActionResult result = null;
Models.Capsule capsuleFromRepository = null;
if (capsule == null)
{
return(BadRequest($"The capsule is invalid (null)"));
}
if (string.IsNullOrEmpty(capsule?.Id))
{
return(BadRequest($"The capsule id is invalid (null or empty string)"));
}
try
{
capsuleFromRepository = await _repository.GetCapsuleByUserAsync(capsule.Id);
if (capsuleFromRepository != null)
{
result = Ok(await _repository.SaveCapsuleAsync(capsule));
}
else
{
result = this.CreatedAtRoute(
routeName: "default",
value: await _repository.CreateNewCapsuleAsync(capsule));
}
return(result);
}
catch (Exception ex)
{
throw new CapsuleDomainException("An error caused an exception", ex);
}
}
public async Task <IActionResult> AddMessageToCapsule(int messageId, string returnUrl)
{
IActionResult result = RedirectToAction("Index", "Capsule", new { returnUrl });
try
{
var message = await _messageService.GetMessageByIdAsync(messageId);
if (message != null)
{
Models.Capsule capsule = await _capsuleService.GetCapsuleByUserAsync();
capsule?.AddMessage(message);
await _capsuleService.SaveCapsuleAsync(capsule : capsule);
}
}
catch (Exception) // (BrokenCircuitException)
{
// Catch error when API is in circuit-opened mode
//HandleBrokenCircuitException();
}
return(result);
}
