public async Task TestCreateMessage_SuccessOkResponse()
{
//Arrange
var id = 1;
var hotelMessage = new HotelMessageViewModel()
{
MessageId = 0,
HotelId = id,
MessageTitle = "Title1",
MessageTypeId = id,
MessageDescription = "sajdk",
StartDate = DateTime.Now,
EndDate = DateTime.Now,
IsActive = true,
ObjectState = ObjectState.Added
};
mockMessagesRepository.Setup(a => a.SaveAndUpdateMessage(It.IsAny <HotelMessageViewModel>(), It.IsAny <string>())).Returns(Task.FromResult(new BaseResult <Message>()
{
Result = new Message {
Id = id
}
}));
//Act
IActionResult result = await mockMessageController.CreateMessage(hotelMessage);
BaseResult <Message> finalResult = (result as Microsoft.AspNetCore.Mvc.OkObjectResult).Value as BaseResult <Message>;
//Assert
Assert.AreEqual(((Microsoft.AspNetCore.Mvc.ObjectResult)result).StatusCode, 200);
Assert.IsNotNull(finalResult);
Assert.IsTrue(!finalResult.IsError);
Assert.IsTrue(finalResult.Result.Id == id);
}
public void TestSaveAndUpdateMessage_Failed_Error()
{
//Arrange
var id = 1;
var userName = "******";
var hotelMessages = new HotelMessageViewModel()
{
MessageId = 0,
HotelId = id,
MessageTitle = "Title1",
MessageTypeId = id,
MessageDescription = "sajdk",
StartDate = DateTime.Now,
EndDate = DateTime.Now,
IsActive = true,
ObjectState = Extranet.Helper.ObjectState.Added
};
iMessageLibrary.Setup(a => a.InsertEntity(It.IsAny <Message>())).Returns(Task.FromResult(new BaseResult <long>()
{
IsError = true,
ExceptionMessage = Helper.Common.GetMockException()
})).Verifiable();
//Act
var result = messageRepository.SaveAndUpdateMessage(hotelMessages, userName);
//Assert
iMessageLibrary.Verify();
Assert.IsTrue(result.Result.IsError);
Assert.IsTrue(result.Result.ExceptionMessage != null);
}
/// <summary>
/// Maps view model of message to message model
/// </summary>
/// <param name="hotelMessageViewModel"></param>
/// <param name="messageDatabase"></param>
/// <param name="userName"></param>
/// <returns>Message</returns>
public static Message AutoMapperMessage(HotelMessageViewModel hotelMessageViewModel, Message messageDatabase, string userName)
{
var messageMapped = AutoMapper.Mapper.Map <Message>(hotelMessageViewModel);
ResolveRemainingParamters(messageMapped, messageDatabase, userName);
return(messageMapped);
}
public async Task TestMessage_Failed_Error()
{
//Arrange
var id = 1;
var hotelMessage = new HotelMessageViewModel()
{
MessageId = 0,
HotelId = id,
MessageTitle = "Title1",
MessageTypeId = id,
StartDate = DateTime.Now,
EndDate = DateTime.Now,
IsActive = true,
ObjectState = ObjectState.Added
};
mockMessagesRepository.Setup(a => a.SaveAndUpdateMessage(It.IsAny <HotelMessageViewModel>(), It.IsAny <string>())).Returns(Task.FromResult(new BaseResult <Message>()
{
IsError = true,
ExceptionMessage = Helper.Common.GetMockException()
})).Verifiable();
//Act
IActionResult result = await mockMessageController.CreateMessage(hotelMessage);
//Assert
mockMessagesRepository.Verify();
Assert.AreEqual(((Microsoft.AspNetCore.Mvc.ObjectResult)result).StatusCode, 500);
}
/// <summary>
/// Creates new message or edits the message
/// </summary>
/// <param name="request"></param>
/// <param name="userName"></param>
/// <returns>Task<BaseResult<long>></returns>
public async Task <BaseResult <Message> > SaveAndUpdateMessage(HotelMessageViewModel request, string userName)
{
BaseResult <Message> result = new BaseResult <Message>();
result.Result = new Message();
if (request.ObjectState == ObjectState.Added)
{
Message message = new Message()
{
HotelId = (int)request.HotelId,
MessageTypeId = (int)request.MessageTypeId,
MessageTitle = request.MessageTitle,
MessageDescription = request.MessageDescription,
IsActive = (bool)request.IsActive,
StartDate = request.StartDate,
EndDate = request.EndDate,
CreatedBy = userName,
UpdatedBy = userName
};
var insertResult = await iMessageLibrary.InsertEntity(message).ConfigureAwait(false);
if (insertResult.IsError || insertResult.ExceptionMessage != null)
{
result.IsError = true;
result.ExceptionMessage = insertResult.ExceptionMessage;
return(result);
}
result.Result.Id = (int)insertResult.Result;
return(result);
}
else if (request.ObjectState == ObjectState.Modified)
{
var message = iMessageLibrary.GetListByPredicate(x => x.Id == request.MessageId && !x.IsDeleted);
if (message.Result.Result.Count > 0 && message != null)
{
var updatedMessage = MessageRequestMapper.AutoMapperMessage(request, message.Result.Result[0], userName);
var updateResult = await iMessageLibrary.UpdateEntityByDapper(updatedMessage);
if (updateResult.IsError || updateResult.ExceptionMessage != null)
{
result.IsError = true;
result.ExceptionMessage = updateResult.ExceptionMessage;
return(result);
}
if (updateResult.Result == true)
{
result.Result.Id = updatedMessage.Id;
}
return(result);
}
else
{
result.IsError = true;
result.ErrorCode = (int)coreHelper.Constants.ErrorCodes.NoMessageOfID;
result.Message = string.Format(coreHelper.Constants.ErrorMessage.NoMessageOfID, request.MessageId);
return(result);
}
}
return(result);
}
/// <summary>
/// Validates the request for creating messgae
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
private BaseResult <bool> ValidateMessageRequest(HotelMessageViewModel request)
{
BaseResult <bool> validateMessageRequest = new BaseResult <bool>()
{
IsError = false
};
if ((request.EndDate.Date < request.StartDate.Date || request.StartDate.Date < DateTime.Now.Date || request.EndDate.Date < DateTime.Now.Date) && request.ObjectState == ObjectState.Added)
{
validateMessageRequest.IsError = true;
validateMessageRequest.ErrorCode = (int)coreHelper.Constants.ErrorCodes.StartDateEndDateViolation;
validateMessageRequest.Message = string.Format(coreHelper.Constants.ErrorMessage.StartDateEndDateViolation);
return(validateMessageRequest);
}
return(validateMessageRequest);
}
/// <summary>
/// Map model to view model
/// </summary>
/// <param name="message"></param>
/// <returns>BaseResult<HotelMessageViewModel></returns>
public static BaseResult <HotelMessageViewModel> MapMessage(Message message)
{
BaseResult <HotelMessageViewModel> result = new BaseResult <HotelMessageViewModel>();
HotelMessageViewModel messageModel = new HotelMessageViewModel
{
MessageId = message.Id,
MessageDescription = message.MessageDescription,
IsActive = message.IsActive,
EndDate = message.EndDate,
StartDate = message.StartDate,
MessageTitle = message.MessageTitle,
HotelId = message.HotelId,
MessageTypeId = message.MessageTypeId
};
result.Result = messageModel;
return(result);
}
public async Task TestCreateMessage_Failed_BadRequest()
{
//Arrange
var id = 1;
var hotelMessage = new HotelMessageViewModel()
{
MessageId = 0,
HotelId = id,
MessageTitle = "Title1",
MessageTypeId = id,
StartDate = DateTime.Now,
EndDate = DateTime.Now.AddDays(-2),
IsActive = true,
ObjectState = ObjectState.Added
};
//Act
var result = await mockMessageController.CreateMessage(hotelMessage);
//Assert
mockMessagesRepository.Verify();
Assert.IsTrue(result is BadRequestObjectResult);
Assert.AreEqual(((BadRequestObjectResult)result).StatusCode, 400);
}
public async Task <IActionResult> CreateMessage([FromBody] HotelMessageViewModel request)
{
BaseResult <Message> createMessageResponse = new BaseResult <Message>();
BaseResult <bool> validateResponse = new BaseResult <bool>();
validateResponse = ValidateMessageRequest(request);
if (validateResponse == null || !validateResponse.Result && validateResponse.IsError && validateResponse.Message != null)
{
return(BadRequest(validateResponse));
}
if (!validateResponse.Result)
{
createMessageResponse = await iMessage.SaveAndUpdateMessage(request, base.LoggedInUserName);
}
if (createMessageResponse.IsError || createMessageResponse.ExceptionMessage != null || createMessageResponse.Result.Id == 0)
{
return(StatusCode(500, createMessageResponse));
}
else if (createMessageResponse.Message != null)
{
return(BadRequest(createMessageResponse));
}
return(Ok(createMessageResponse)); //200
}
