public void WhenGivenAModelWithQuestions_ShouldInitializeTheQuestionsCorrectly()
{
var wrapper = new QuestionnaireWrapper(m_questionnaire);
Assert.NotNull(wrapper.Questions);
CheckModelQuestionsCollectionIsInSync(wrapper);
}
public void WhenProvidedData_ShouldLoadQuestionnaire()
{
var model = new QuestionnaireModel(Guid.NewGuid(), "");
var qmodel1 = new QuestionModel(
Guid.NewGuid(),
Guid.NewGuid(),
"1",
true,
false,
new BooleanQuestionType());
var qmodel2 = new QuestionModel(
Guid.NewGuid(),
Guid.NewGuid(),
"2",
true,
false,
new BooleanQuestionType());
model.Questions.Add(qmodel1);
model.Questions.Add(qmodel2);
var wrappedModel = new QuestionnaireWrapper(model);
var dataProviderMock = new Mock <IQuestionnaireDataProvider>();
dataProviderMock
.Setup(x => x.GetSingleQuestionnaire())
.Returns(wrappedModel);
var viewModel = new QuestionnaireViewModel(dataProviderMock.Object);
viewModel.Load();
Assert.AreEqual(2, viewModel.Questionnaire.Questions.Count);
}
public void WhenRemovedQuestion_ShouldBeInSync()
{
var wrapper = new QuestionnaireWrapper(m_questionnaire);
var questionToRemove = wrapper.Questions.Single(q => q.Model == m_inputQuestion2);
wrapper.Questions.Remove(questionToRemove);
CheckModelQuestionsCollectionIsInSync(wrapper);
}
public void WhenAddedQuestion_ShouldBeInSync()
{
m_questionnaire.Questions.Remove(m_inputQuestion2);
var wrapper = new QuestionnaireWrapper(m_questionnaire);
wrapper.Questions.Add(new QuestionWrapper(m_inputQuestion2));
CheckModelQuestionsCollectionIsInSync(wrapper);
}
private void CheckModelQuestionsCollectionIsInSync(QuestionnaireWrapper wrapper)
{
Assert.AreEqual(
expected: m_questionnaire.Questions.Count,
actual: wrapper.Questions.Count);
Assert.IsTrue(m_questionnaire.Questions.All(
q => wrapper.Questions.Any(wq => wq.Model == q)));
}
public async Task <ActionResult <QuestionnaireStoreModel> > PostStepperSchema(QuestionnaireViewModel model)
{
QuestionnaireStoreModel schema = new QuestionnaireWrapper(model).GetStoreModel();
_context.JsonSchema.Add(schema);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetStepperSchema", new { id = schema.Id }, schema));
}
public void WhenGivenModel_ShouldbeContainedInModelProperty()
{
var wrapper = new QuestionnaireWrapper(m_questionnaire);
Assert.AreEqual(expected: m_questionnaire, actual: wrapper.Model);
var calculateQuestionWrapper = new CalculatedQuestionWrapper(m_calculatedQuestion);
Assert.AreEqual(expected: m_calculatedQuestion, actual: calculateQuestionWrapper.Model);
}
public void WhenAskingForUnderlyinModelsName_ShouldReturnCorrectValue()
{
var questionaireName = "Fred";
m_questionnaire.Name = questionaireName;
var wrapper = new QuestionnaireWrapper(m_questionnaire);
Assert.AreEqual(
expected: questionaireName,
actual: wrapper.Name);
}
public void WhenQuestionnaireWrapperHasModel_ShouldGetUnderlyingModelValues()
{
m_questionnaire.Questions.Add(m_inputQuestion1);
var wrapper = new QuestionnaireWrapper(m_questionnaire);
Assert.AreEqual(
expected: m_questionnaire.QuestionnaireId,
actual: wrapper.QuestionnaireId);
Assert.AreEqual(
expected: m_questionnaire.QuestionnaireDisplayName,
actual: wrapper.QuestionnaireDisplayName);
Assert.AreEqual(
expected: m_questionnaire.Questions.Count,
actual: wrapper.Questions.Count);
}
public async Task <ActionResult <QuestionnaireGetViewModel> > GetQuestionnaire(string id, string language)
{
var questionnaire = await _context.Questionnaire
.Include(i => i.Questions).ThenInclude(i => i.QuestionTemplate).ThenInclude(i => i.Options)
.Include(i => i.Questions).ThenInclude(i => i.QuestionTemplate).ThenInclude(i => i.Validations)
.Include(i => i.QuestionRules).ThenInclude(i => i.ExpressionModel)
.SingleOrDefaultAsync(x => x.Id == id);
if (questionnaire == null)
{
return(NotFound());
}
var viewModel = new QuestionnaireWrapper(questionnaire).GetViewModel(language);
return(viewModel);
}
public async Task <ActionResult <QuestionnaireViewModel> > GetStepperSchema(int id)
{
QuestionnaireStoreModel stepperSchema = await _context.JsonSchema
.Include(j => j.fieldGroup).ThenInclude(j => j.templateOptions)
.Include(j => j.fieldGroup).ThenInclude(j => j.fieldGroup).ThenInclude(j => j.templateOptions)
.Include(j => j.fieldGroup).ThenInclude(j => j.fieldGroup).ThenInclude(j => j.templateOptions).ThenInclude(j => j.options)
.Include(j => j.fieldGroup).ThenInclude(j => j.expressionProperties)
.SingleOrDefaultAsync(x => x.Id == id);
QuestionnaireViewModel schema = new QuestionnaireWrapper(stepperSchema).GetViewModel();
if (stepperSchema == null)
{
return(NotFound());
}
return(schema);
}
public async Task <ActionResult <Questionnaire> > PostQuestionnaire(QuestionnairePostViewModel questionnaire)
{
var wrappedQuestionnaire = new QuestionnaireWrapper(questionnaire).GetStoreModel()
?? throw new ArgumentNullException("questionnaire");
_context.Questionnaire.Add(wrappedQuestionnaire);
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateException)
{
if (QuestionnaireExists(wrappedQuestionnaire.Id))
{
return(Conflict());
}
else
{
throw;
}
}
return(CreatedAtAction("GetQuestionnaire", new { id = wrappedQuestionnaire.Id }, wrappedQuestionnaire));
}
public void WhenQuestionnaireWrapperGivenModel_ShouldbeContainedInModelProperty()
{
var wrapper = new QuestionnaireWrapper(m_questionnaire);
Assert.AreEqual(expected: m_questionnaire, actual: wrapper.Model);
}
