public void SubmitUserQuestionnaire_WhenClientIsDeleted_ThrowsException()
{
try {
// Arrange
var client = new ClientModel {
Id = 1, IsDeleted = true
};
var user = new UserInfoModel {
Id = 1, Client = client
};
var questionnaire = new UserQuestionnaireModel {
UserId = user.Id
};
_mockDb.Setup(m => m.Users)
.Returns(TestHelper.GetQueryableMockDbSet(new List <UserInfoModel> {
user
}));
// Act
_service.SubmitUserQuestionnaire(questionnaire);
} catch {
// Assert
_mockDb.Verify(m => m.UserQuestionnaires.Add(It.IsAny <UserQuestionnaireModel>()), Times.Never,
"Expected NO questionnare to be added");
_mockDb.Verify(m => m.SaveChanges(), Times.Never,
"Expected NO db changes to be saved");
_mockMessageService.Verify(m =>
m.SendQuestionnaireToClient(It.IsAny <UserQuestionnaireModel>()), Times.Never,
"Expected NO message sent to client");
}
}
/// <summary>
/// Gets placeholder values from questionnaires
/// </summary>
public string GetPlaceHolderValueForQuestionnaire(string placeholder, UserQuestionnaireModel questionnaire)
{
switch (placeholder)
{
case HeaderPlaceholder:
return(_resourceProvider.EmailHeader);
case FooterPlaceholder:
return(_resourceProvider.EmailFooter);
case ClientNamePlaceholder:
return(questionnaire.Client.Name);
case MemberCodePlaceholder:
return(questionnaire.Client.MemberCode);
case FirstNamePlaceholder:
return(questionnaire.User.FirstName);
case LastNamePlaceholder:
return(questionnaire.User.LastName);
case PhoneNumberPlaceholder:
return(questionnaire.User.PhoneNumber);
case QuestionnairePlaceholder:
return(questionnaire.ToStringQuestionsAndAnswers());
}
return(string.Empty);
}
public void Post_WhenError_LogsAndReturnsError() {
// Arrange
var questionnaire = new UserQuestionnaireModel { };
var exception = new ApplicationException("An error has occurred.");
_mockUserService.Setup(m => m.SubmitUserQuestionnaire(It.IsAny<UserQuestionnaireModel>())).Throws(exception);
// Act
var response = _controller.Post(questionnaire);
// Assert
Assert.AreEqual(HttpStatusCode.InternalServerError, response.StatusCode, "Expected InternalServerError");
_mockUserService.Verify(m => m.SubmitUserQuestionnaire(questionnaire), Times.Once, "Expected questionnaire to be submitted");
_mockLoggingService.Verify(m => m.LogCriticalError(exception), Times.Once, "Expected critical error to be logged.");
}
public void IsFit2Work_YesConditions(string qaData)
{
// Arrange
var q = new UserQuestionnaireModel {
QuestionsAndAnswersData = qaData
};
// Act
var result = q.IsFit2Work;
// Assert
Assert.IsTrue(result);
}
public void QuestionsAndAnswersData_WithoutData_DeserializesToEmptyList()
{
// Arrange
var q = new UserQuestionnaireModel {
QuestionsAndAnswersData = string.Empty
};
// Act
var qa = q.QuestionsAndAnswers;
// Assert
Assert.IsNotNull(qa);
Assert.AreEqual(0, qa.Count, "Expected 0 question answers");
}
public HttpResponseMessage Post(UserQuestionnaireModel questionnaire)
{
var response = new HttpResponseMessage(HttpStatusCode.OK);
try {
var result = _userService.SubmitUserQuestionnaire(questionnaire);
response.Content = new StringContent(JsonConvert.SerializeObject(result));
} catch (Exception ex) {
_loggingService.LogCriticalError(ex);
response = Request.CreateErrorResponse(
HttpStatusCode.InternalServerError, ex);
}
return(response);
}
private void SendUserQuestionnaire(UserQuestionnaireModel questionnaire)
{
var result = _messageService.SendQuestionnaireToClient(questionnaire);
if (!result.IsOk)
{
throw new ApplicationException(
$"Failed to send questionnaire ({questionnaire.Id}) to {result.Recipient}.", result.Exception);
}
// Log each email sent otherwise we have no auditing
_loggingService.LogMessage(
$"Questionnaire ({questionnaire.Id}) for client {questionnaire.Client.Name} sent to {result.Recipient}.",
result.MessageContent);
}
public void Post_NotFitToWork_ReturnsOk() {
// Arrange
var questionnaire = new UserQuestionnaireModel { };
var questionnaireResult = new QuestionnaireResult { IsFitToWork = false, UserMessage = "NotFitToWork" };
_mockUserService.Setup(m => m.SubmitUserQuestionnaire(questionnaire))
.Returns(questionnaireResult);
// Act
var response = _controller.Post(questionnaire);
// Assert
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode, "Expected OK");
var result = JsonConvert.DeserializeObject<QuestionnaireResult>(response.Content.ReadAsStringAsync().Result);
Assert.AreEqual(questionnaireResult.IsFitToWork, result.IsFitToWork);
Assert.AreEqual(questionnaireResult.UserMessage, result.UserMessage);
_mockUserService.Verify(m => m.SubmitUserQuestionnaire(questionnaire), Times.Once, "Expected questionnaire to be submitted");
}
private string PopulatePlaceHoldersForQuestionnaire(string content,
UserQuestionnaireModel questionnaire)
{
var result = content;
foreach (var placeholder in _placeHolders)
{
if (content.Contains(placeholder))
{
result = result.Replace(placeholder,
GetPlaceHolderValueForQuestionnaire(placeholder, questionnaire));
}
}
return(result);
}
public QuestionnaireResult SubmitUserQuestionnaire(UserQuestionnaireModel questionnaire)
{
QuestionnaireResult result = new QuestionnaireResult();
try {
CreateUserQuestionnaire(questionnaire);
SendUserQuestionnaire(questionnaire);
// Set the result for sending back to the user
result.IsFitToWork = questionnaire.IsFit2Work;
result.UserMessage = questionnaire.IsFit2Work
? _resourceProvider.UserPrimaryMessageText
: _resourceProvider.UserSecondaryMessageText;
} catch (Exception ex) {
throw new ApplicationException($"Failed to submit questionniare ({questionnaire}).", ex);
}
return(result);
}
public void SubmitUserQuestionnaire_WithoutUser_ThrowsException()
{
try {
// Arrange
var questionnaire = new UserQuestionnaireModel();
// Act
_service.SubmitUserQuestionnaire(questionnaire);
} catch {
// Assert
_mockDb.Verify(m => m.UserQuestionnaires.Add(It.IsAny <UserQuestionnaireModel>()), Times.Never,
"Expected NO questionnare to be added");
_mockDb.Verify(m => m.SaveChanges(), Times.Never,
"Expected NO db changes to be saved");
_mockMessageService.Verify(m =>
m.SendQuestionnaireToClient(It.IsAny <UserQuestionnaireModel>()), Times.Never,
"Expected NO message sent to client");
}
}
public void QuestionsAndAnswersData_DeserializesToList(string qaData, string answers)
{
// Arrange
var q = new UserQuestionnaireModel {
QuestionsAndAnswersData = qaData
};
var expectedAnswers = answers.Split(',');
// Act
var qa = q.QuestionsAndAnswers;
// Assert
Assert.IsNotNull(qa);
Assert.AreEqual(expectedAnswers.Length, qa.Count, "Expected count to match");
for (var i = 0; i < expectedAnswers.Length; i++)
{
Assert.AreEqual(expectedAnswers[i], qa[i].Answer,
$"Expected answer {i} to match");
}
}
public MessageResult SendQuestionnaireToClient(UserQuestionnaireModel questionnaire)
{
var user = questionnaire.User;
string from = _configurationProvider.ClientEmailFromAddress;
string to = questionnaire.IsFit2Work ?
questionnaire.Client.PrimaryEmailAddress :
questionnaire.Client.SecondaryEmailAddress;
string subject = PopulatePlaceHoldersForQuestionnaire(
questionnaire.IsFit2Work ?
_resourceProvider.PrimaryEmailSubjectFormat :
_resourceProvider.SecondaryEmailSubjectFormat,
questionnaire);
string body = PopulatePlaceHoldersForQuestionnaire(
questionnaire.IsFit2Work ?
_resourceProvider.PrimaryEmailBodyFormat :
_resourceProvider.SecondaryEmailBodyFormat,
questionnaire);
var result = _emailProvider.SendMail(from, to, subject, body);
result.MessageContent = body;
return(result);
}
private void CreateUserQuestionnaire(UserQuestionnaireModel questionnaire)
{
questionnaire.User = Fit2WorkDb.Users.Include("Client")
.FirstOrDefault(u => u.Id == questionnaire.UserId);
if (questionnaire.User == null)
{
throw new ApplicationException(
$"Failed to find user ({questionnaire.User.Id}) for questionnaire.");
}
if (questionnaire.User.Client == null)
{
throw new ApplicationException(
$"Failed to find client for user ({questionnaire.User.Id}) for questionnaire.");
}
questionnaire.Client = questionnaire.User.Client;
if (questionnaire.User.Client.IsDeleted)
{
throw new ApplicationException(
$"Failed to find active client ({questionnaire.User.Client.Id}) for questionnaire.");
}
questionnaire.CreatedDate = DateTime.UtcNow;
Fit2WorkDb.UserQuestionnaires.Add(questionnaire);
Fit2WorkDb.SaveChanges();
}
public void SubmitUserQuestionnaire_NotFitToWork_Success()
{
// Arrange
var client = new ClientModel {
Id = 1, IsDeleted = false
};
var user = new UserInfoModel {
Id = 1, Client = client
};
var questionnaire = new UserQuestionnaireModel {
UserId = user.Id, QuestionsAndAnswers = { new UserAnswerModel {
Answer = "Yes"
} }
};
_mockDb.Setup(m => m.Users).Returns(TestHelper.GetQueryableMockDbSet(new List <UserInfoModel> {
user
}));
_mockMessageService.Setup(m => m.SendQuestionnaireToClient(It.IsAny <UserQuestionnaireModel>())).Returns(new MessageResult());
// Act
var result = _service.SubmitUserQuestionnaire(questionnaire);
// Assert
Assert.IsNotNull(result);
Assert.IsFalse(result.IsFitToWork, "Expected NOT result.IsFitToWork");
Assert.AreEqual("UserSecondaryMessageText", result.UserMessage, "Expected UserSecondaryMessageText");
Assert.IsTrue(questionnaire.CreatedDate > DateTime.MinValue, "Expected questionnaire created date to be set");
_mockDb.Verify(m => m.UserQuestionnaires.Add(It.IsAny <UserQuestionnaireModel>()), Times.Once,
"Expected questionnare to be added");
_mockDb.Verify(m => m.SaveChanges(), Times.Once, "Expected db changes to be saved");
_mockMessageService.Verify(m =>
m.SendQuestionnaireToClient(It.IsAny <UserQuestionnaireModel>()), Times.Once,
"Expected message sent to client");
_mockLoggingService.Verify(m => m.LogMessage(It.IsAny <string>(), It.IsAny <string>()), Times.Once,
"Expeced message to be logged");
}
